Algorithm Book

GeeksforGeeks
Articles
Created By Jing Connect on LinkedIn

All rights belong to geeksforgeeks.org
This document will be updated here.
Return maximum occurring character in the input string
Write an efficient C function to return maximum occurring character in the input string e.g., if input string
is “test string” then function should return ‘t’.
Algorithm:
Input string = “test”

1: Construct character count array from the input string.
count['e'] = 1
count['s'] = 1
count['t'] = 2
2: Return the index of maximum value in count array (returns ‘t’).

Implementation:

#include <stdio.h>
#include <stdlib.h>
#define NO_OF_CHARS 256
int *getCharCountArray(char *);

char getIndexOfMax(int *, int);
/* Returns the maximum occurring character in

the input string */
char getMaxOccuringChar(char *str)
{
int *count = getCharCountArray(str);
return getIndexOfMax(count, NO_OF_CHARS);
}
/* Returns an array of size 256 containg count

of characters in the passed char array */
int *getCharCountArray(char *str)
{
int *count = (int *)calloc(NO_OF_CHARS, sizeof(int));
int i;
for (i = 0; *(str+i); i++)

count[*(str+i)]++;
return count;
}
char getIndexOfMax(int ar[], int ar_size)

{
int i;
int max_index = 0;
for(i = 1; i < ar_size; i++)

if(ar[i] > ar[max_index])
max_index = i;
/* free memory allocated to count */

free(ar);
ar = NULL;
return max_index;
}
int main()
{
char str[] = "sample string";
printf("%c", getMaxOccuringChar(str));
getchar();
return 0;
}

Time Complexity: O(n)
Notes:
If more than one character have the same and maximum count then function returns only the first character
in alphabetical order. For example if input string is “test sample” then function will return only ‘e’.
Print all the duplicates in the input string.
Write an efficient C program to print all the duplicates and their counts in the input string
Algorithm: Let input string be “geeksforgeeks”

count[‘e’] = 4
count[‘g’] = 2
count[‘k’] = 2
……
2: Print all the indexes from the constructed array which have value greater than 0.
Solution
# include <stdio.h>
# include <stdlib.h>
# define NO_OF_CHARS 256
/* Fills count array with frequency of characters */

void fillCharCounts(char *str, int *count)
{
int i;
for (i = 0; *(str+i); i++)
count[*(str+i)]++;
}
/* Print duplicates present in the passed string */

void printDups(char *str)
{
// Create an array of size 256 and fill count of every character in it
int *count = (int *)calloc(NO_OF_CHARS, sizeof(int));
fillCharCounts(str, count);
// Print characters having count more than 0

int i;
for (i = 0; i < NO_OF_CHARS; i++)
if(count[i] > 1)
printf("%c, count = %d \n", i, count[i]);
free(count);
}
/* Driver program to test to pront printDups*/

int main()
{
char str[] = "test string";
printDups(str);
getchar();
return 0;
}

Output:

s, count = 2
t, count = 3


Remove all duplicates from the input string.
Below are the different methods to remove duplicates in a string.
METHOD 1 (Use Sorting)
Algorithm:
1) Sort the elements.

2) Now in a loop, remove duplicates by comparing the
current character with previous character.
3) Remove extra characters at the end of the resultant string.

Example:

Input string: geeksforgeeks
1) Sort the characters
eeeefggkkosss
2) Remove duplicates
efgkosgkkosss
3) Remove extra characters
efgkos

Note that, this method doesn’t keep the original order of the input string. For example, if we are to remove
duplicates for geeksforgeeks and keep the order of characters same, then output should be geksfor, but above
function returns efgkos. We can modify this method by storing the original order. METHOD 2 keeps the
order same.
Implementation:
# include <stdio.h>
/* Function to remove duplicates in a sorted array */

char *removeDupsSorted(char *str);
/* Utitlity function to sort array A[] */

void quickSort(char A[], int si, int ei);
/* Function removes duplicate characters from the string

This function work in-place and fills null characters
in the extra space left */
char *removeDups(char *str)
{
int len = strlen(str);
quickSort(str, 0, len-1);
return removeDupsSorted(str);
}
/* Function to remove duplicates in a sorted array */

char *removeDupsSorted(char *str)
{
{
int res_ind = 1, ip_ind = 1;
/* In place removal of duplicate characters*/

while(*(str + ip_ind))
{
if(*(str + ip_ind) != *(str + ip_ind - 1))
{
*(str + res_ind) = *(str + ip_ind);
res_ind++;
}
ip_ind++;
}
/* After above step string is stringiittg.

Removing extra iittg after string*/
*(str + res_ind) = '\0';

return str;
}
/* Driver program to test removeDups */

int main()
{
char str[] = "eeeefggkkosss";
printf("%s", removeDups(str));
getchar();
return 0;
}
/* FOLLOWING FUNCTIONS ARE ONLY FOR SORTING

PURPOSE */
void exchange(char *a, char *b)
{
char temp;
temp = *a;
*a = *b;
*b = temp;
}
int partition(char A[], int si, int ei)

{
char x = A[ei];
int i = (si - 1);
int j;
for (j = si; j <= ei - 1; j++)

{
if(A[j] <= x)
{
i++;
exchange(&A[i], &A[j]);
}
}
exchange (&A[i + 1], &A[ei]);
return (i + 1);
}
/* Implementation of Quick Sort

A[] --> Array to be sorted
si --> Starting index
ei --> Ending index
*/
void quickSort(char A[], int si, int ei)
{
{
int pi; /* Partitioning index */
if(si < ei)
{
pi = partition(A, si, ei);
quickSort(A, si, pi - 1);
quickSort(A, pi + 1, ei);
}
}

Time Complexity: O(nlogn) If we use some nlogn sorting algorithm instead of quicksort.
METHOD 2 (Use Hashing )
Algorithm:
1: Initialize:
str = "test string" /* input string */
ip_ind = 0 /* index to keep track of location of next
character in input string */
res_ind = 0 /* index to keep track of location of
next character in the resultant string */
bin_hash[0..255] = {0,0, ….} /* Binary hash to see if character is
already processed or not */
2: Do following for each character *(str + ip_ind) in input string:
(a) if bin_hash is not set for *(str + ip_ind) then
// if program sees the character *(str + ip_ind) first time
(i) Set bin_hash for *(str + ip_ind)
(ii) Move *(str + ip_ind) to the resultant string.
This is done in-place.
(iii) res_ind++
(b) ip_ind++
/* String obtained after this step is "te sringng" */
3: Remove extra characters at the end of the resultant string.
/* String obtained after this step is "te sring" */

Implementation:

# include <stdio.h>
# define bool int
/* Function removes duplicate characters from the string

This function work in-place and fills null characters
in the extra space left */
char *removeDups(char *str)
{
bool bin_hash[NO_OF_CHARS] = {0};
int ip_ind = 0, res_ind = 0;
char temp;
/* In place removal of duplicate characters*/

{
temp = *(str + ip_ind);
if(bin_hash[temp] == 0)
{
bin_hash[temp] = 1;
res_ind++;
}
ip_ind++;
}
/* After above step string is stringiittg.

Removing extra iittg after string*/
*(str+res_ind) = '\0';

return str;
}
/* Driver program to test removeDups */

int main()
{
char str[] = "geeksforgeeks";
printf("%s", removeDups(str));
getchar();
return 0;
}

NOTES:
* It is assumed that number of possible characters in input string are 256. NO_OF_CHARS should be
changed accordingly.
* calloc is used instead of malloc for memory allocations of counting array (count) to initialize allocated
memory to ‘\0′. malloc() followed by memset() could also be used.
* Above algorithm also works for an integer array inputs if range of the integers in array is given. Example
problem is to find maximum occurring number in an input array given that the input array contain integers
only between 1000 to 1100
Write a function to get Nth node in a Linked List
Write a GetNth() function that takes a linked list and an integer index and returns the data
value stored in the node at that index position.
Algorithm:
1. Initialize count = 0
2. Loop through the link list
a. if count is equal to the passed index then return current
node
b. Increment count
c. change current to point to next of the current.

Implementation:
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
/* Link list node */

struct node
{
int data;
struct node* next;
};
/* Given a reference (pointer to pointer) to the head

of a list and an int, push a new node on the front
of the list. */
void push(struct node** head_ref, int new_data)
{
/* allocate node */
struct node* new_node =
(struct node*) malloc(sizeof(struct node));
/* put in the data */

new_node->data = new_data;

/* link the old list off the new node */
new_node->next = (*head_ref);

/* move the head to point to the new node */
(*head_ref) = new_node;
}
/* Takes head pointer of the linked list and index

as arguments and return data at index*/
int GetNth(struct node* head, int index)
{
struct node* current = head;
int count = 0; /* the index of the node we're currently
looking at */
while (current != NULL)
{
if (count == index)
return(current->data);
count++;
current = current->next;
}

/* if we get to this line, the caller was asking
for a non-existent element so we assert fail */
assert(0);
}
/* Drier program to test above function*/

int main()
{
/* Start with the empty list */
struct node* head = NULL;

/* Use push() to construct below list
1->12->1->4->1 */
push(&head, 1);
push(&head, 4);
push(&head, 1);
push(&head, 12);
push(&head, 1);

/* Check the count function */
printf("Element at index 3 is %d", GetNth(head, 3));
getchar();
}


Given only a pointer to a node to be deleted in a singly linked list, how do
you delete it?
A simple solution is to traverse the linked list until you find the node you want to delete. But this solution
requires pointer to the head node which contradicts the problem statement.
Fast solution is to copy the data from the next node to the node to be deleted and delete the next node.
Something like following.
struct node *temp = node_ptr->next;

node_ptr->data = temp->data;
node_ptr->next = temp->next;
free(temp);

Program:
#include<stdio.h>
#include<assert.h>
#include<stdlib.h>

struct node
{
int data;
struct node* next;
};

of the list. */
{
/* allocate node */



}
void printList(struct node *head)

{
struct node *temp = head;
while(temp != NULL)
{
printf("%d ", temp->data);
temp = temp->next;
}
}
void deleteNode(struct node *node_ptr)
{
free(temp);
}

int main()
{

1->12->1->4->1 */
push(&head, 1);
push(&head, 4);
push(&head, 1);
push(&head, 12);
push(&head, 1);
printf("\n Before deleting \n");

printList(head);
/* I m deleting the head itself.

You can check for more cases */
deleteNode(head);
printf("\n After deleting \n");

printList(head);
getchar();
return 0;
}

This solution doesn’t work if the node to be deleted is the last node of the list. To make this
solution work we can mark the end node as a dummy node. But the programs/functions that are using this
function should also be modified.
You can try this problem for doubly linked list.

Remove characters from the first string which are present in the second
string
Write an efficient C function that takes two strings as arguments and removes the characters
from first string which are present in second string (mask string).
Algorithm: Let first input string be”test string” and the string which has characters to be removed from
first string be “mask”
1: Initialize:
res_ind = 0 /* index to keep track of processing of each character in i/p string */
ip_ind = 0 /* index to keep track of processing of each character in the resultant string */
2: Construct count array from mask_str. Count array would be:

(We can use Boolean array here instead of int count array because we don’t need count, we need to know
only if character is present in mask string)
count[‘a’] = 1
count[‘k’] = 1
count[‘m’] = 1
count[‘s’] = 1
3: Process each character of the input string and if count of that character is 0 then only add the character to
the resultant string.
str = “tet tringng” // ’s’ has been removed because ’s’ was present in mask_str but we we have got two extra
characters “ng”
ip_ind = 11
res_ind = 9
4: Put a ‘\0′ at the end of the string?
Implementation:

#include <stdio.h>
#include <stdlib.h>

{
int *count = (int *)calloc(sizeof(int), NO_OF_CHARS);
int i;
for (i = 0; *(str+i); i++)
count[*(str+i)]++;
return count;
}
/* removeDirtyChars takes two string as arguments: First

string (str) is the one from where function removes dirty
characters. Second string is the string which contain all
dirty characters which need to be removed from first string */
char *removeDirtyChars(char *str, char *mask_str)
{
int *count = getCharCountArray(mask_str);
int ip_ind = 0, res_ind = 0;
char temp;
{
temp = *(str + ip_ind);
if(count[temp] == 0)
{
res_ind++;
}
ip_ind++;
}
/* After above step string is ngring.

Removing extra "iittg" after string*/
*(str+res_ind) = '\0';
return str;
}
/* Driver program to test getCharCountArray*/

int main()
{
char mask_str[] = "mask";
printf("%s", removeDirtyChars(str, mask_str));
getchar();
return 0;
}

Time Complexity: O(m+n) Where m is the length of mask string and n is the length of the input string.
A Program to check if strings are rotations of each other or not
Given a string s1 and a string s2, write a snippet to say whether s2 is a rotation of s1 using only one call to
strstr routine?
(eg given s1 = ABCD and s2 = CDAB, return true, given s1 = ABCD, and s2 = ACBD , return false)
Algorithm: areRotations(str1, str2)
1. Create a temp string and store concatenation of str1 to

str1 in temp.
temp = str1.str1
2. If str2 is a substring of temp then str1 and str2 are
rotations of each other.
Example:
str1 = "ABACD"
str2 = "CDABA"
temp = str1.str1 = "ABACDABACD"

Since str2 is a substring of temp, str1 and str2 are
rotations of each other.

Implementation:

# include <stdio.h>
# include <string.h>
/* Function checks if passed strings (str1 and str2)

are rotations of each other */
int areRotations(char *str1, char *str2)
{
int size1 = strlen(str1);
int size2 = strlen(str2);
char *temp;
void *ptr;
/* Check if sizes of two strings are same */

if (size1 != size2)
return 0;
/* Create a temp string with value str1.str1 */

temp = (char *)malloc(sizeof(char)*(size1*2 + 1));
temp[0] = '\0';
strcat(temp, str1);
strcat(temp, str1);
/* Now check if str2 is a substring of temp */

ptr = strstr(temp, str2);
free(temp); // Free dynamically allocated memory
/* strstr returns NULL if the second string is NOT a

substring of first string */
if (ptr != NULL)
return 1;
else
return 0;
}
/* Driver program to test areRotations */

int main()
{
char *str1 = "AACD";
char *str2 = "ACDA";
if (areRotations(str1, str2))
printf("Strings are rotations of each other");
else
printf("Strings are not rotations of each other");
getchar();
return 0;
}

Output:

Strings are rotations of each other

Library Functions Used:
strstr:
strstr finds a sub-string within a string.
Prototype: char * strstr(const char *s1, const char *s2);
See http://www.lix.polytechnique.fr/Labo/Leo.Liberti/public/computing/prog/c/C/MAN/strstr.htm for
more details
strcat:
strncat concatenate two strings
Prototype: char *strcat(char *dest, const char *src);
See http://www.lix.polytechnique.fr/Labo/Leo.Liberti/public/computing/prog/c/C/MAN/strcat.htm for
more details
Time Complexity: Time complexity of this problem depends on the implementation of strstr function.
If implementation of strstr is done using KMP matcher then complexity of the above program is (-)(n1 + n2)
where n1 and n2 are lengths of strings. KMP matcher takes (-)(n) time to find a substrng in a string of length
n where length of substring is assumed to be smaller than the string.
Output of the program | Dereference, Reference, Dereference, Reference….
Predict the output of below program
int main()
{
char *ptr = "geeksforgeeks";
printf("%c\n", *&*&*ptr);

getchar();
return 0;
}

Output: g
Explanation: The operator * is used for dereferencing and the operator & is used to get the address. These
operators cancel effect of each other when used one after another. We can apply them alternatively any no. of
times. For example *ptr gives us g, &*ptr gives address of g, *&*ptr again g, &*&*ptr address of g, and finally
*&*&*ptr gives ‘g’
Now try below
int main()
{
char *ptr = "geeksforgeeks";
printf("%s\n", *&*&ptr);

getchar();
return 0;
}

Output of the Program | Use Macros Carefully!
Predict the output of the below program
#define square(x) x*x

int main()
{
int x;
x = 36/square(6);
printf("%d",x);

getchar();
return 0;
}

Output: 36
Explanation:
Preprocessor replaces square(6) by 6*6 and the expression becomes x = 36/6*6 and value of x is calculated
as 36. If we want correct behavior from macro square(x), we should declare it as
#define square(x) ((x)*(x)) /* Note that the expression

(x*x) will also fail for square(6-2) */
Output of the Program | Pointer to a Constant or Constant Pointer?
Predict the output of the below program.
int main()
{
int x = 5;
int * const ptr = &x;
++(*ptr);
printf("%d", x);

getchar();
return 0;
}

Output: 6
Explananation:
See following declarations to know the difference between constant pointer and a pointer to a constant.
int * const ptr —> ptr is constant pointer. You can change the value at the location pointed by pointer p, but
you can not change p to point to other location.
int const * ptr —> ptr is a pointer to a constant. You can change ptr to point other variable. But you cannot
change the value pointed by ptr.
Therefore above program works well because we have a constant pointer and we are not changing ptr to
point to any other location. We are only icrementing value pointed by ptr.
Try below program, you will get compiler error.
int main()
{
int x = 5;
int const * ptr = &x;
++(*ptr);
printf("%d", x);

getchar();
return 0;
}

Next Power of 2
Write a function that, for a given no n, finds a number p which is greater than or equal to n and is a power of
2.
IP 5
OP 8
IP 17
OP 32
IP 32
OP 32

There are plenty of solutions for this. Let us take the example of 17 to explain some of them.
Method 1(Using Log of the number)
1. Calculate Position of set bit in p(next power of 2):

pos = ceil(lgn) (ceiling of log n with base 2)
2. Now calculate p:
p = pow(2, pos)

Example
Let us try for 17

pos = 5
p = 32

Method 2 (By getting the position of only set bit in result )
/* If n is a power of 2 then return n */

1 If (n & !(n&(n-1))) then return n
2 Else keep right shifting n until it becomes zero
and count no of shifts
a. Initialize: count = 0
b. While n ! = 0
n = n>>1
count = count + 1
/* Now count has the position of set bit in result */

3 Return (1
Example:

Let us try for 17
count = 5
p = 32

unsigned int nextPowerOf2(unsigned int n)
{
unsigned count = 0;
/* First n in the below condition is for the case where n is 0*/

if (n && !(n&(n-1)))
return n;
while( n != 0)
{
n >>= 1;
count += 1;
}
return 1<<count;
}
/* Driver program to test above function */

int main()
{
unsigned int n = 0;
printf("%d", nextPowerOf2(n));
getchar();
return 0;
}

Method 3(Shift result one by one)
Thanks to coderyogi for suggesting this method . This method is a variation of method
2 where instead of getting count, we shift the result one by one in a loop.

{
unsigned int p = 1;
if (n && !(n & (n - 1)))
return n;
while (p < n) {
p <<= 1;
}
return p;
}

int main()
{
unsigned int n = 5;
getchar();
return 0;
}

Time Complexity: O(lgn)
Method 4(Customized and Fast)

1. Subtract n by 1
n = n -1
2. Set all bits after the leftmost set bit.
/* Below solution works only if integer is 32 bits */

n = n | (n >> 1);
n = n | (n >> 2);
n = n | (n >> 4);
n = n | (n >> 8);
n = n | (n >> 16);
3. Return n + 1

Example:

Steps 1 & 3 of above algorithm are to handle cases
of power of 2 numbers e.g., 1, 2, 4, 8, 16,
Let us try for 17(10001)

step 1
n = n - 1 = 16 (10000)
step 2
n = n | n >> 1
n = 10000 | 01000
n = 11000
n = n | n >> 2
n = 11000 | 00110
n = 11110
n = n | n >> 4
n = 11110 | 00001
n = 11111
n = n | n >> 8
n = 11111 | 00000
n = 11111
n = n | n >> 16
n = 11110 | 00000
n = 11111
step 3: Return n+1

We get n + 1 as 100000 (32)

Program:
Program:

# include <stdio.h>
/* Finds next power of two for n. If n itself

is a power of two then returns n*/

{
n--;
n |= n >> 1;
n |= n >> 2;
n |= n >> 4;
n |= n >> 8;
n |= n >> 16;
n++;
return n;
}

int main()
{
unsigned int n = 5;
getchar();
return 0;
Time Complexity: O(lgn)
References:
http://en.wikipedia.org/wiki/Power_of_2

Efficient way to multiply with 7
We can multiply a number by 7 using bitwise operator. First left shift the number by 3 bits (you will get 8n)
then subtract the original numberfrom the shifted number and return the difference (8n – n).
Program:
# include<stdio.h>
int multiplyBySeven(unsigned int n)

{
/* Note the inner bracket here. This is needed
because precedence of '-' operator is higher
than '<<' */
return ((n<<3) - n);
}

int main()
{
unsigned int n = 4;
printf("%u", multiplyBySeven(n));
getchar();
return 0;
}

Time Complexity: O(1)

Space Complexity: O(1)
Note: Works only for positive integers.

Same concept can be used for fast multiplication by 9 or other numbers.
Write a C program to find the parity of an unsigned integer
Parity: Parity of a number refers to whether it contains an odd or even number of 1-bits. The number has
“odd parity”, if it contains odd number of 1-bits and is “even parity” if it contains even number of 1-bits.
Main idea of the below solution is – Loop while n is not 0 and in loop unset one of the set bits and invert
parity.
Algorithm: getParity(n)
1. Initialize parity = 0
2. Loop while n != 0
a. Invert parity
parity = !parity
b. Unset rightmost set bit
n = n & (n-1)
3. return parity
Example:
Initialize: n = 13 (1101) parity = 0
n = 13 & 12 = 12 (1100) parity = 1

n = 12 & 11 = 8 (1000) parity = 0
n = 8 & 7 = 0 (0000) parity = 1

Program:
# include <stdio.h>
# define bool int
/* Function to get parity of number n. It returns 1

if n has odd parity, and returns 0 if n has even
parity */
bool getParity(unsigned int n)
{
bool parity = 0;
while (n)
{
parity = !parity;
n = n & (n - 1);
}
return parity;
}
/* Driver program to test getParity() */

int main()
{
unsigned int n = 7;
printf("Parity of no %d = %s", n,
(getParity(n)? "odd": "even"));

getchar();
return 0;
}

Above solution can be optimized by using lookup table. Please refer to Bit Twiddle Hacks[1st reference] for
details.
Time Complexity: The time taken by above algorithm is proportional to the number of bits set. Worst case
complexity is O(Logn).
Uses: Parity is used in error detection and cryptography.
References:
http://graphics.stanford.edu/~seander/bithacks.html#ParityNaive – last checked on 30 May 2009.
Write an Efficient Method to Check if a Number is Multiple of 3
The very first solution that comes to our mind is the one that we learned in school. If sum of digits in a
number is multiple of 3 then number is multiple of 3 e.g., for 612 sum of digits is 9 so it’s a multiple of 3. But
this solution is not efficient. You have to get all decimal digits one by one, add them and then check if sum is
multiple of 3.
There is a pattern in binary representation of the number that can be used to find if number is a multiple of
3. If difference between count of odd set bits (Bits set at odd positions) and even set bits is multiple of 3 then
is the number.
Example: 23 (00..10111)
1) Get count of all set bits at odd positions (For 23 it’s 3).
2) Get count of all set bits at even positions (For 23 it’s 1).
3) If difference of above two counts is a multiple of 3 then number is also a multiple of 3.
(For 23 it’s 2 so 23 is not a multiple of 3)
Take some more examples like 21, 15, etc…
Algorithm: isMutlipleOf3(n)
1) Make n positive if n is negative.
2) If number is 0 then return 1
3) If number is 1 then return 0
4) Initialize: odd_count = 0, even_count = 0
5) Loop while n != 0
a) If rightmost bit is set then increment odd count.
b) Right-shift n by 1 bit
c) If rightmost bit is set then increment even count.
d) Right-shift n by 1 bit
6) return isMutlipleOf3(odd_count - even_count)

Proof:
Above can be proved by taking the example of 11 in decimal numbers. (In this context 11 in decimal numbers
is same as 3 in binary numbers)
If difference between sum of odd digits and even digits is multiple of 11 then decimal number is multiple of
11. Let’s see how.
Let’s take the example of 2 digit numbers in decimal

AB = 11A -A + B = 11A + (B – A)
So if (B – A) is a multiple of 11 then is AB.
Let us take 3 digit numbers.
ABC = 99A + A + 11B – B + C = (99A + 11B) + (A + C – B)

So if (A + C – B) is a multiple of 11 then is (A+C-B)
Let us take 4 digit numbers now.

ABCD = 1001A + D + 11C – C + 999B + B – A
= (1001A – 999B + 11C) + (D + B – A -C )
So, if (B + D – A – C) is a multiple of 11 then is ABCD.
This can be continued for all decimal numbers.

Above concept can be proved for 3 in binary numbers in the same way.
Time Complexity: O(logn)
Program:
#include<stdio.h>
/* Fnction to check if n is a multiple of 3*/

int isMultipleOf3(int n)
{
int odd_count = 0;
int even_count = 0;
/* Make no positive if +n is multiple of 3

then is -n. We are doing this to avoid
stack overflow in recursion*/
if(n < 0) n = -n;
if(n == 0) return 1;
if(n == 1) return 0;
while(n)
{
/* If odd bit is set then
increment odd counter */
if(n & 1)
odd_count++;
n = n>>1;
/* If even bit is set then

increment even counter */
if(n & 1)
even_count++;
n = n>>1;
}
return isMultipleOf3(abs(odd_count - even_count));

}
/* Program to test function isMultipleOf3 */

int main()
{
int num = 23;
if (isMultipleOf3(num))
printf("num is multiple of 3");
else
printf("num is not a multiple of 3");
getchar();
return 0;
}

Write one line C function to find whether a no is power of two
1. A simple method for this is to simply take the log of the number on base 2 and if you get an integer then
number is power of 2.
2. Another solution is to keep dividing the number by two, i.e, do n = n/2 iteratively. In any iteration, if n%2
becomes non-zero and n is not 1 then n is not a power of 2. If n becomes 1 then it is a power of 2.
#include<stdio.h>
#define bool int
/* Function to check if x is power of 2*/

bool isPowerOfTwo(int n)
{
if (n == 0)
return 0;
while (n != 1)
{
if (n%2 != 0)
return 0;
n = n/2;
}
return 1;
}
/*Driver program to test above function*/

int main()
{
isPowerOfTwo(31)? printf("Yes\n"): printf("No\n");
return 0;
}

Output:

No
No
Yes
Yes
No
Yes

3. All power of two numbers have only one bit set. So count the no. of set bits and if you get 1 then number is
a power of 2. Please see http://geeksforgeeks.org/?p=1176 for counting set bits.
4. If we subtract a power of 2 numbers by 1 then all unset bits after the only set bit become set; and the set bit
become unset.
For example for 4 ( 100) and 16(10000), we get following after subtracting 1
3 –> 011
15 –> 01111
So, if a number n is a power of 2 then bitwise & of n and n-1 will be zero. We can say n is a power of 2 or not
based on value of n&(n-1). The expression n&(n-1) will not work when n is 0. To handle this case also, our
expression will become n& (!n&(n-1)) (thanks to Mohammad for adding this case).
Below is the implementation of this method.
#include<stdio.h>
#define bool int

bool isPowerOfTwo (int x)
{
/* First x in the below expression is for the case when x is 0 */
return x && (!(x&(x-1)));
}

int main()
{
return 0;
}

Output:

No
No
Yes
Yes
No
Yes

Please write comments if you find anything incorrect, or you want to share more information about the topic
discussed above
Majority Element
Majority Element: A majority element in an array A[] of size n is an element that appears more than n/2
times (and hence there is at most one such element).
Write a function which takes an array and emits the majority element (if it exists), otherwise prints NONE as
follows:
I/P : 3 3 4 2 4 4 2 4 4
O/P : 4
I/P : 3 3 4 2 4 4 2 4
O/P : NONE

METHOD 1 (Basic)
The basic solution is to have two loops and keep track of maximum count for all different elements. If
maximum count becomes greater than n/2 then break the loops and return the element having maximum
count. If maximum count doesn’t become more than n/2 then majority element doesn’t exist.
Time Complexity: O(n*n).

Auxiliary Space : O(1).
METHOD 2 (Using Binary Search Tree)

Thanks to Sachin Midha for suggesting this solution.
Node of the Binary Search Tree (used in this approach) will be as follows.
struct tree
{
int element;
int count;
}BST;

Insert elements in BST one by one and if an element is already present then increment the count of the node.
At any stage, if count of a node becomes more than n/2 then return.
The method works well for the cases where n/2+1 occurrences of the majority element is present in the
starting of the array, for example {1, 1, 1, 1, 1, 2, 3, 4}.
Time Complexity: If a binary search tree is used then time complexity will be O(n^2). If a self-balancing-
binary-search tree is used then O(nlogn)
Auxiliary Space: O(n)
METHOD 3 (Using Moore’s Voting Algorithm)
This is a two step process.

1. Get an element occurring most of the time in the array. This phase will make sure that if there is a majority
element then it will return that only.
2. Check if the element obtained from above step is majority element.
1. Finding a Candidate:
The algorithm for first phase that works in O(n) is known as Moore’s Voting Algorithm. Basic idea of the
algorithm is if we cancel out each occurrence of an element e with all the other elements that are different
from e then e will exist till end if it is a majority element.
findCandidate(a[], size)
1. Initialize index and count of majority element
maj_index = 0, count = 1
2. Loop for i = 1 to size – 1
(a)If a[maj_index] == a[i]
count++
(b)Else
count--;
(c)If count == 0
maj_index = i;
count = 1
3. Return a[maj_index]

Above algorithm loops through each element and maintains a count of a[maj_index], If next element is same
then increments the count, if next element is not same then decrements the count, and if the count reaches 0
then changes the maj_index to the current element and sets count to 1.
First Phase algorithm gives us a candidate element. In second phase we need to check if the candidate is
really a majority element. Second phase is simple and can be easily done in O(n). We just need to check if
count of the candidate element is greater than n/2.
Example:
A[] = 2, 2, 3, 5, 2, 2, 6
Initialize:
maj_index = 0, count = 1 –> candidate ‘2?
2, 2, 3, 5, 2, 2, 6
Same as a[maj_index] => count = 2

2, 2, 3, 5, 2, 2, 6
Different from a[maj_index] => count = 1

2, 2, 3, 5, 2, 2, 6

Since count = 0, change candidate for majority element to 5 => maj_index = 3, count = 1
2, 2, 3, 5, 2, 2, 6

Since count = 0, change candidate for majority element to 2 => maj_index = 4
2, 2, 3, 5, 2, 2, 6
Same as a[maj_index] => count = 2

2, 2, 3, 5, 2, 2, 6
Finally candidate for majority element is 2.
First step uses Moore’s Voting Algorithm to get a candidate for majority element.
2. Check if the element obtained in step 1 is majority

printMajority (a[], size)

1. Find the candidate for majority
2. If candidate is majority. i.e., appears more than n/2 times.
Print the candidate
3. Else
Print "NONE"

Implementation of method 3:
/* Program for finding out majority element in an array */

# include<stdio.h>
# define bool int

int findCandidate(int *, int);
bool isMajority(int *, int, int);

/* Function to print Majority Element */
void printMajority(int a[], int size)
{
/* Find the candidate for Majority*/
int cand = findCandidate(a, size);

/* Print the candidate if it is Majority*/
if(isMajority(a, size, cand))
printf(" %d ", cand);
else
printf("NO Majority Element");
}

/* Function to find the candidate for Majority */
int findCandidate(int a[], int size)
{
int maj_index = 0, count = 1;
int i;
for(i = 1; i < size; i++)
{
if(a[maj_index] == a[i])
count++;
else
count--;
if(count == 0)
{
maj_index = i;
count = 1;
}
}
return a[maj_index];
}

/* Function to check if the candidate occurs more than n/2 times */
bool isMajority(int a[], int size, int cand)
{
int i, count = 0;
for (i = 0; i < size; i++)
if(a[i] == cand)
count++;
if (count > size/2)
if (count > size/2)
return 1;
else
return 0;
}

/* Driver function to test above functions */
int main()
{
int a[] = {1, 3, 3, 1, 2};
printMajority(a, 5);
getchar();
return 0;
}


Auxiliary Space : O(1)
Now give a try to below question

Given an array of 2n elements of which n elements are same and the remaining n elements are all different.
Write a C program to find out the value which is present n times in the array. There is no restriction on the
elements in the array. They are random (In particular they not sequential).
Given an array A[] and a number x, check for pair in A[] with sum as x
Write a C program that, given an array A[] of n numbers and another number x, determines whether or not
there exist two elements in S whose sum is exactly x.
Algorithm:
hasArrayTwoCandidates (A[], ar_size, sum)

1) Sort the array in non-decreasing order.
2) Initialize two index variables to find the candidate
elements in the sorted array.
(a) Initialize first to the leftmost index: l = 0
(b) Initialize second the rightmost index: r = ar_size-1
3) Loop while l
Time Complexity: Depends on what sorting algorithm we use. If we use Merge Sort or Heap
Sort then (-)(nlogn) in worst case. If we use Quick Sort then O(n^2) in worst case.
Auxiliary Space : Again, depends on sorting algorithm. For example auxiliary space is O(
n) for merge sort and O(1) for Heap Sort.
Example:
Let Array be {1, 4, 45, 6, 10, -8} and sum to find be 16
Sort the array
A = {-8, 1, 4, 6, 10, 45}
Initialize l = 0, r = 5
A[l] + A[r] ( -8 + 45) > 16 => decrement r. Now r = 10
A[l] + A[r] ( -8 + 10) increment l. Now l = 1
A[l] + A[r] ( 1 + 10) increment l. Now l = 2
A[l] + A[r] ( 4 + 10) increment l. Now l = 3
A[l] + A[r] ( 6 + 10) == 16 => Found candidates (return 1)
Note: If there are more than one pair having the given sum then this algorithm reports o
nly one. Can be easily extended for this though.
Implementation:

# include <stdio.h>
# define bool int
void quickSort(int *, int, int);
bool hasArrayTwoCandidates(int A[], int arr_size, int sum)

{
int l, r;
/* Sort the elements */
quickSort(A, 0, arr_size-1);
/* Now look for the two candidates in the sorted

array*/
l = 0;
r = arr_size-1;
while(l < r)
{
if(A[l] + A[r] == sum)
return 1;
else if(A[l] + A[r] < sum)
l++;
else // A[i] + A[j] > sum
r--;
}
return 0;
}

int main()
{
int A[] = {1, 4, 45, 6, 10, -8};
int n = 16;
int arr_size = 6;

if( hasArrayTwoCandidates(A, arr_size, n))
printf("Array has two elements with sum 16");
else
printf("Array doesn't have two elements with sum 16 ");
getchar();
return 0;
}

PURPOSE */
void exchange(int *a, int *b)
{
int temp;
temp = *a;
*a = *b;
*b = temp;
}
int partition(int A[], int si, int ei)

{
int x = A[ei];
int i = (si - 1);
int j;
for (j = si; j <= ei - 1; j++)

{
if(A[j] <= x)
{
i++;
}
}
return (i + 1);
}

ei --> Ending index
*/
void quickSort(int A[], int si, int ei)
{
if(si < ei)
{
}
}

METHOD 2 (Use Hash Map)
Thanks to Bindu for suggesting this method and thanks to Shekhu for providing code.
This method works in O(n) time if range of numbers is known.
Let sum be the given sum and A[] be the array in which we need to find pair.

1) Initialize Binary Hash Map M[] = {0, 0, …}
2) Do following for each element A[i] in A[]
(a) If M[x - A[i]] is set then print the pair (A[i], x – A[i])
(b) Set M[A[i]]

Implementation:

#include <stdio.h>
#define MAX 100000
void printPairs(int arr[], int arr_size, int sum)

{
int i, temp;
bool binMap[MAX] = {0}; /*initialize hash map as 0*/
for(i = 0; i < arr_size; i++)

{
temp = sum - arr[i];
if(temp >= 0 && binMap[temp] == 1)
{
printf("Pair with given sum %d is (%d, %d) \n", sum, arr[i], temp);
}
binMap[arr[i]] = 1;
}
}

int main()
{
int A[] = {1, 4, 45, 6, 10, 8};
int A[] = {1, 4, 45, 6, 10, 8};
int n = 16;
int arr_size = 6;
printPairs(A, arr_size, n);
getchar();
return 0;
}

Auxiliary Space: O(R) where R is range of integers.
If range of numbers include negative numbers then also it works. All we have to do for n
egative numbers is to make everything positive by adding the absolute value of smallest
negative integer to all numbers.
Please write comments if you find any of the above codes/algorithms incorrect, or find o
ther ways to solve the same problem.

Write a C program to reverse digits of a number
ITERATIVE WAY
Algorithm:
Input: num
(1) Initialize rev_num = 0
(2) Loop while num > 0
(a) Multiply rev_num by 10 and add remainder of num
divide by 10 to rev_num
rev_num = rev_num*10 + num%10;
(b) Divide num by 10
(3) Return rev_num

Example:
num = 4562
rev_num = 0
rev_num = rev_num *10 + num%10 = 2

num = num/10 = 456
rev_num = rev_num *10 + num%10 = 20 + 6 = 26

num = num/10 = 45

num = num/10 = 4

num = num/10 = 0
Program:

#include <stdio.h>
/* Iterative function to reverse digits of num*/

int reversDigits(int num)
{
int rev_num = 0;
while(num > 0)
{
rev_num = rev_num*10 + num%10;
num = num/10;
}
return rev_num;
}
/*Driver program to test reversDigits*/

int main()
{
int num = 4562;
printf("Reverse of no. is %d", reversDigits(num));
getchar();
return 0;
}

Time Complexity: O(Log(n)) where n is the input number.
RECURSIVE WAY
Thanks to Raj for adding this to the original post.

#include <stdio.h>;
/* Recursive function to reverse digits of num*/

int reversDigits(int num)
{
static int rev_num = 0;
static int base_pos = 1;
if(num > 0)
{
reversDigits(num/10);
rev_num += (num%10)*base_pos;
base_pos *= 10;
}
return rev_num;
}
/*Driver program to test reversDigits*/

int main()
{
int num = 4562;
printf("Reverse of no. is %d", reversDigits(num));
getchar();
return 0;
}

Time Complexity: O(Log(n)) where n is the input number
Note that above above program doesn’t consider leading zeroes. For example, for 100 program will print 1. If
you want to print 001 then see this comment from Maheshwar.
Try extensions of above functions that should also work for floating point numbers.
Position of rightmost set bit
Write a one line C function to return position of first 1 from right to left, in binary representation of an
Integer.
I/P 18, Binary Representation 010010

O/P 2
I/P 19, Binary Representation 010011
O/P 1

Let I/P be 12 (1100)
Algorithm: (Example 18(010010))
1. Take two's complement of the given no as all bits are reverted

except the first '1' from right to left (10111)
2 Do an bit-wise & with original no, this will return no with the
required one only (00010)
3 Take the log2 of the no, you will get position -1 (1)
4 Add 1 (2)

Program:
#include<stdio.h>
#include<math.h>
unsigned int getFirstSetBitPos(int n)

{
return log2(n&-n)+1;
}
int main()
{
int n = 12;
printf("%u", getFirstSetBitPos(n));
getchar();
return 0;
}

Print reverse of a string using recursion
Write a recursive C function to print reverse of a given string.
Program:
# include <stdio.h>
/* Function to print reverse of the passed string */

void reverse(char *str)
{
if(*str)
{
reverse(str+1);
printf("%c", *str);
}
}

int main()
{
char a[] = "Geeks for Geeks";
reverse(a);
getchar();
return 0;
}

Explanation: Recursive function (reverse) takes string pointer (str) as input and calls itself with next
location to passed pointer (str+1). Recursion continues this way, when pointer reaches ‘\0′, all functions
accumulated in stack print char at passed location (str) and return one by one.

Find the Number Occurring Odd Number of Times
Given an array of positive integers. All numbers occur even number of times except one number which
occurs odd number of times. Find the number in O(n) time & constant space.
Example:
I/P = [1, 2, 3, 2, 3, 1, 3]
O/P = 3
Algorithm:
Do bitwise XOR of all the elements. Finally we get the number which has odd occurrences.
Program:

#include <stdio.h>
int getOddOccurrence(int ar[], int ar_size)

{
int i;
int res = 0;
for (i=0; i < ar_size; i++)
res = res ^ ar[i];

return res;
}
/* Diver function to test above function */

int main()
{
int ar[] = {2, 3, 5, 4, 5, 2, 4, 3, 5, 2, 4, 4, 2};
int n = sizeof(ar)/sizeof(ar[0]);
printf("%d", getOddOccurrence(ar, n));
return 0;
}


Find the Missing Number
You are given a list of n-1 integers and these integers are in the range of 1 to n. There are no duplicates in list.
One of the integers is missing in the list. Write an efficient code to find the missing integer.
Example:
I/P [1, 2, 4, ,6, 3, 7, 8]
O/P 5

METHOD 1(Use sum formula)

Algorithm:
1. Get the sum of numbers

total = n*(n+1)/2
2 Subtract all the numbers from sum and
you will get the missing number.

Program:
#include<stdio.h>
/* getMissingNo takes array and size of array as arguments*/

int getMissingNo (int a[], int n)
{
int i, total;
total = (n+1)*(n+2)/2;
for ( i = 0; i< n; i++)
total -= a[i];
return total;
}
/*program to test above function */

int main()
{
int a[] = {1,2,4,5,6};
int miss = getMissingNo(a,5);
printf("%d", miss);
getchar();
}

METHOD 2(Use XOR)

1) XOR all the array elements, let the result of XOR be X1.
2) XOR all numbers from 1 to n, let XOR be X2.
3) XOR of X1 and X2 gives the missing number.

#include<stdio.h>
/* getMissingNo takes array and size of array as arguments*/

int getMissingNo(int a[], int n)
{
int i;
int x1 = a[0]; /* For xor of all the elemets in arary */
int x2 = 1; /* For xor of all the elemets from 1 to n+1 */

for (i = 1; i< n; i++)
x1 = x1â[i];

for ( i = 2; i <= n+1; i++)
x2 = x2î;

return (x1^x2);
}
/*program to test above function */

int main()
{
int a[] = {1, 2, 4, 5, 6};
int miss = getMissingNo(a, 5);
printf("%d", miss);
getchar();
}

In method 1, if the sum of the numbers goes beyond maximum allowed integer, then there can be integer
overflow and we may not get correct answer. Method 2 has no such problems.
Largest Sum Contiguous Subarray
Write an efficient C program to find the sum of contiguous subarray within a one-dimensional array of
numbers which has the largest sum.
Kadane’s Algorithm:
Initialize:
max_so_far = 0
max_ending_here = 0
Loop for each element of the array

(a) max_ending_here = max_ending_here + a[i]
(b) if(max_ending_here
Explanation:
Simple idea of the Kadane's algorithm is to look for all positive contiguous segments of
the array (max_ending_here is used for this). And keep track of maximum sum contiguous
segment among all positive segments (max_so_far is used for this). Each time we get a
positive sum compare it with max_so_far and update max_so_far if it is greater than max_
so_far
Lets take the example:
{-2, -3, 4, -1, -2, 1, 5, -3}
max_so_far = max_ending_here = 0
for i=0, a[0] = -2
max_ending_here = max_ending_here + (-2)
Set max_ending_here = 0 because max_ending_here Program:

#include<stdio.h>
int maxSubArraySum(int a[], int size)
{
int max_so_far = 0, max_ending_here = 0;
int i;
{
max_ending_here = max_ending_here + a[i];
if(max_ending_here < 0)
max_ending_here = 0;
if(max_so_far < max_ending_here)
max_so_far = max_ending_here;
}
return max_so_far;
}
/*Driver program to test maxSubArraySum*/

int main()
{
int a[] = {-2, -3, 4, -1, -2, 1, 5, -3};
int n = sizeof(a)/sizeof(a[0]);
int max_sum = maxSubArraySum(a, n);
printf("Maximum contiguous sum is %d\n", max_sum);
getchar();
return 0;
}

Notes:
Algorithm doesn't work for all negative numbers. It simply returns 0 if all numbers are
negative. For handling this we can add an extra phase before actual implementation. The
phase will look if all numbers are negative, if they are it will return maximum of them
(or smallest in terms of absolute value). There may be other ways to handle it though.
Above program can be optimized further, if we compare max_so_far with max_ending_here on

ly if max_ending_here is greater than 0.

{
int i;
{
/* Do not compare for all elements. Compare only

when max_ending_here > 0 */
else if (max_so_far < max_ending_here)
}
return max_so_far;
}

Algorithmic Paradigm: Dynamic Programming
Following is another simple implementation suggested by Mohit Kumar. The implementation

handles the case when all numbers in array are negative.

#include<stdio.h>
int max(int x, int y)

{ return (y > x)? y : x; }

{
int max_so_far = a[0], i;
int curr_max = a[0];
for (i = 1; i < size; i++)

{
curr_max = max(a[i], curr_max+a[i]);
max_so_far = max(max_so_far, curr_max);
}
}
return max_so_far;
}
/* Driver program to test maxSubArraySum */

int main()
{
int a[] = {-2, -3, 4, -1, -2, 1, 5, -3};
int max_sum = maxSubArraySum(a, n);
return 0;
}

Now try below question
Given an array of integers (possibly some of the elements negative), write a C program t
o find out the *maximum product* possible by adding 'n' consecutive integers in the arr
ay, n References:
http://en.wikipedia.org/wiki/Kadane%27s_Algorithm
Please write comments if you find anything incorrect, or you want to share more informati
on about the topic discussed above.

8 queen problem
The eight queens problem is the problem of placing eight queens on an 8×8 chessboard such that none of
them attack one another (no two are in the same row, column, or diagonal). More generally, the n queens
problem places n queens on an n×n chessboard.
There are different solutions for the problem.
You can find detailed solutions at http://en.literateprograms.org/Eight_queens_puzzle_(C)

Power Set
Power Set Power set P(S) of a set S is the set of all subsets of S. For example S = {a, b, c} then P(s) = {{}, {a},
{b}, {c}, {a,b}, {a, c}, {b, c}, {a, b, c}}.
If S has n elements in it then P(s) will have 2^n elements
Algorithm:
Input: Set[], set_size

1. Get the size of power set
powet_set_size = pow(2, set_size)
2 Loop for counter from 0 to pow_set_size
(a) Loop for i = 0 to set_size
(i) If ith bit in counter is set
Print ith element from set for this subset
(b) Print seperator for subsets i.e., newline

Example:
Set = [a,b,c]
power_set_size = pow(2, 3) = 8
Run for binary counter = 000 to 111
Value of Counter Subset

000 -> Empty set
001 -> a
011 -> ab
100 -> c
101 -> ac
110 -> bc
111 -> abc

Program:

#include <stdio.h>
#include <math.h>
void printPowerSet(char *set, int set_size)

{
/*set_size of power set of a set with set_size
n is (2**n -1)*/
unsigned int pow_set_size = pow(2, set_size);
int counter, j;
/*Run from counter 000..0 to 111..1*/

for(counter = 0; counter < pow_set_size; counter++)
{
for(j = 0; j < set_size; j++)
{
/* Check if jth bit in the counter is set
If set then pront jth element from set */
if(counter & (1<<j))
printf("%c", set[j]);
}
printf("\n");
}
}
/*Driver program to test printPowerSet*/

int main()
{
char set[] = {'a','b','c'};
printPowerSet(set, 3);
getchar();
return 0;
}

Time Complexity: O(n2^n)
There are more efficient ways of doing this. Will update here soon with more efficient method.
References:
http://en.wikipedia.org/wiki/Power_set
Tree Traversals
Unlike linear data structures (Array, Linked List, Queues, Stacks, etc) which have only one logical way to
traverse them, trees can be traversed in different ways. Following are the generally used ways for traversing
trees.
Example Tree
Depth First Traversals:

(a) Inorder
(b) Preorder
(c) Postorder
Breadth First or Level Order Traversal

Please see this post for Breadth First Traversal.
Inorder Traversal:
Algorithm Inorder(tree)
1. Traverse the left subtree, i.e., call Inorder(left-subtree)
2. Visit the root.
3. Traverse the right subtree, i.e., call Inorder(right-subtree)

Uses of Inorder
In case of binary search trees (BST), Inorder traversal gives nodes in non-decreasing order. To get nodes of
BST in non-increasing order, a variation of Inorder traversal where Inorder itraversal s reversed, can be
used.
Example: Inorder traversal for the above given figure is 4 2 5 1 3.
Preorder Traversal:
Algorithm Preorder(tree)
1. Visit the root.
2. Traverse the left subtree, i.e., call Preorder(left-subtree)
3. Traverse the right subtree, i.e., call Preorder(right-subtree)

Uses of Preorder
Preorder traversal is used to create a copy of the tree. Preorder traversal is also used to get prefix expression
on of an expression tree. Please see http://en.wikipedia.org/wiki/Polish_notation to know why prefix
expressions are useful.
Example: Preorder traversal for the above given figure is 1 2 4 5 3.
Postorder Traversal:
Algorithm Postorder(tree)
1. Traverse the left subtree, i.e., call Postorder(left-subtree)
2. Traverse the right subtree, i.e., call Postorder(right-subtree)
3. Visit the root.

Uses of Postorder
Postorder traversal is used to delete the tree. Please see the question for deletion of tree for details.
Postorder traversal is also useful to get the postfix expression of an expression tree. Please see
http://en.wikipedia.org/wiki/Reverse_Polish_notation to for the usage of postfix expression.
Example: Postorder traversal for the above given figure is 4 5 2 3 1.
#include <stdio.h>
#include <stdlib.h>
/* A binary tree node has data, pointer to left child

and a pointer to right child */
struct node
{
int data;
struct node* left;
struct node* right;
};
/* Helper function that allocates a new node with the

given data and NULL left and right pointers. */
struct node* newNode(int data)
{
struct node* node = (struct node*)
malloc(sizeof(struct node));
node->data = data;
node->left = NULL;
node->right = NULL;
return(node);
}
/* Given a binary tree, print its nodes according to the

"bottom-up" postorder traversal. */
void printPostorder(struct node* node)
{
if (node == NULL)
return;
// first recur on left subtree

printPostorder(node->left);
// then recur on right subtree

printPostorder(node->right);
// now deal with the node

printf("%d ", node->data);
}
/* Given a binary tree, print its nodes in inorder*/
void printInorder(struct node* node)
{
if (node == NULL)
return;
/* first recur on left child */

printInorder(node->left);
/* then print the data of node */

/* now recur on right child */

printInorder(node->right);
}
/* Given a binary tree, print its nodes in preorder*/

void printPreorder(struct node* node)
{
if (node == NULL)
return;
/* first print data of node */

/* then recur on left sutree */

printPreorder(node->left);
/* now recur on right subtree */

printPreorder(node->right);
}
/* Driver program to test above functions*/

int main()
{
struct node *root = newNode(1);
root->left = newNode(2);
root->right = newNode(3);
root->left->left = newNode(4);
root->left->right = newNode(5);
printf("\n Preorder traversal of binary tree is \n");

printPreorder(root);
printf("\n Inorder traversal of binary tree is \n");

printInorder(root);
printf("\n Postorder traversal of binary tree is \n");

printPostorder(root);
getchar();
return 0;
}


Let us prove it:
Complexity function T(n) — for all problem where tree traversal is involved — can be defined as:
T(n) = T(k) + T(n – k – 1) + c
Where k is the number of nodes on one side of root and n-k-1 on the other side.
Let’s do analysis of boundary conditions
Case 1: Skewed tree (One of the subtrees is empty and other subtree is non-empty )
k is 0 in this case.
T(n) = T(0) + T(n-1) + c
T(n) = 2T(0) + T(n-2) + 2c
T(n) = 3T(0) + T(n-3) + 3c
T(n) = 4T(0) + T(n-4) + 4c
…………………………………………
………………………………………….
T(n) = (n-1)T(0) + T(1) + (n-1)c
T(n) = nT(0) + (n)c
Value of T(0) will be some constant say d. (traversing a empty tree will take some constants time)
T(n) = n(c+d)
T(n) = (-)(n) (Theta of n)
Case 2: Both left and right subtrees have equal number of nodes.
T(n) = 2T(|_n/2_|) + c
This recursive function is in the standard form (T(n) = aT(n/b) + (-)(n) ) for master method
http://en.wikipedia.org/wiki/Master_theorem. If we solve it by master method we get (-)(n)
Auxiliary Space : If we don’t consider size of stack for function calls then O(1) otherwise O(n).
Write a C program to Calculate Size of a tree
Size of a tree is the number of elements present in the tree. Size of the below tree is 5.
Example Tree
Size() function recursively calculates the size of a tree. It works as follows:
Size of a tree = Size of left subtree + 1 + Size of right subtree
Algorithm:
size(tree)
1. If tree is empty then return 0
2. Else
(a) Get the size of left subtree recursively i.e., call
size( tree->left-subtree)
(a) Get the size of right subtree recursively i.e., call
size( tree->right-subtree)
(c) Calculate size of the tree as following:
tree_size = size(left-subtree) + size(right-
subtree) + 1
(d) Return tree_size

#include <stdio.h>
#include <stdlib.h>

struct node
{
int data;
struct node* left;
struct node* right;
};

{
node->data = data;
node->left = NULL;
node->right = NULL;

return(node);
}
/* Computes the number of nodes in a tree. */

int size(struct node* node)
{
if (node==NULL)
return 0;
else
return(size(node->left) + 1 + size(node->right));
}
/* Driver program to test size function*/

int main()
{
printf("Size of the tree is %d", size(root));

getchar();
return 0;
}

Time & Space Complexities: Since this program is similar to traversal of tree, time and space
complexities will be same as Tree traversal (Please see our Tree Traversal post for details)
Write C Code to Determine if Two Trees are Identical
Two trees are identical when they have same data and arrangement of data is also same.
To identify if two trees are identical, we need to traverse both trees simultaneously, and while traversing we
need to compare data and children of the trees.
Algorithm:
sameTree(tree1, tree2)
1. If both trees are empty then return 1.
2. Else If both trees are non -empty
(a) Check data of the root nodes (tree1->data == tree2->data)
(b) Check left subtrees recursively i.e., call sameTree(
tree1->left_subtree, tree2->left_subtree)
(c) Check right subtrees recursively i.e., call sameTree(
tree1->right_subtree, tree2->right_subtree)
(d) If a,b and c are true then return 1.
3 Else return 0 (one is empty and other is not)

#include <stdio.h>
#include <stdlib.h>

struct node
{
int data;
struct node* left;
struct node* right;
};

{
node->data = data;
node->left = NULL;
node->right = NULL;
return(node);
}
/* Given two trees, return true if they are

structurally identical */
int identicalTrees(struct node* a, struct node* b)
{
/*1. both empty */
if (a==NULL && b==NULL)
return 1;
/* 2. both non-empty -> compare them */

if (a!=NULL && b!=NULL)
{
return
return
(
a->data == b->data &&
identicalTrees(a->left, b->left) &&
identicalTrees(a->right, b->right)
);
}

/* 3. one empty, one not -> false */
return 0;
}
/* Driver program to test identicalTrees function*/

int main()
{
struct node *root1 = newNode(1);
root1->left = newNode(2);
root1->right = newNode(3);
root1->left->left = newNode(4);
root1->left->right = newNode(5);
if(identicalTrees(root1, root2))
printf("Both tree are identical.");
else
printf("Trees are not identical.");
getchar();
return 0;
}
Time Complexity:
Complexity of the identicalTree() will be according to the tree with lesser number of nodes. Let number of
nodes in two trees be m and n then complexity of sameTree() is O(m) where m
Write a C program to Delete a Tree.
To delete a tree we must traverse all the nodes of the tree and delete them one by one. So which traversal we
should use – Inorder or Preorder or Postorder. Answer is simple – Postorder, because before deleting the
parent node we should delete its children nodes first
We can delete tree with other traversals also with extra space complexity but why should we go for other
traversals if we have Postorder available which does the work without storing anything in same time
complexity.
For the following tree nodes are deleted in order – 4, 5, 2, 3, 1
Example Tree
Program

#include<stdio.h>
#include<stdlib.h>

struct node
{
int data;
struct node* left;
struct node* right;
};

{
node->data = data;
node->left = NULL;
node->right = NULL;
return(node);
}
/* This function traverses tree in post order to

to delete each and every node of the tree */
void deleteTree(struct node* node)
{
if (node == NULL) return;
/* first delete both subtrees */

deleteTree(node->left);
deleteTree(node->right);

/* then delete the node */
printf("\n Deleting node: %d", node->data);
free(node);
}
/* Driver program to test deleteTree function*/

int main()
{

deleteTree(root);
root = NULL;
printf("\n Tree deleted ");

getchar();
return 0;
}

The above deleteTree() function deletes the tree, but doesn’t change root to NULL which may cause
problems if the user of deleteTree() doesn’t change root to NULL and tires to access values using root
pointer. We can modify the deleteTree() function to take reference to the root node so that this problem
doesn’t occur. See the following code.
#include<stdio.h>
#include<stdlib.h>

struct node
{
int data;
struct node* left;
struct node* right;
};

{
node->data = data;
node->left = NULL;
node->right = NULL;
return(node);
}
/* This function is same as deleteTree() in the previous program */

void _deleteTree(struct node* node)
{
/* first delete both subtrees */

_deleteTree(node->left);
_deleteTree(node->right);
/* then delete the node */

printf("\n Deleting node: %d", node->data);
free(node);
}
/* Deletes a tree and sets the root as NULL */

void deleteTree(struct node** node_ref)
{
_deleteTree(*node_ref);
*node_ref = NULL;
}
/* Driver program to test deleteTree function*/

int main()
{
// Note that we pass the address of root here

// Note that we pass the address of root here
deleteTree(&root);
printf("\n Tree deleted ");
getchar();
return 0;
}


Space Complexity: If we don’t consider size of stack for function calls then O(1) otherwise O(n)
Write a C Program to Find the Maximum Depth or Height of a Tree
Maximum depth or height of the below tree is 3.
Example Tree
Recursively calculate height of left and right subtrees of a node and assign height to the node as max of the
heights of two children plus 1. See below pseudo code and program for details.
Algorithm:

maxDepth()
1. If tree is empty then return 0
2. Else
(a) Get the max depth of left subtree recursively i.e.,
call maxDepth( tree->left-subtree)
(a) Get the max depth of right subtree recursively i.e.,
call maxDepth( tree->right-subtree)
(c) Get the max of max depths of left and right
subtrees and add 1 to it for the current node.
max_depth = max(max dept of left subtree,
max depth of right subtree)
+ 1
(d) Return max_depth

See the below diagram for more clarity about execution of the recursive function maxDepth()
for above example tree.
maxDepth('1') = max(maxDepth('2'), maxDepth('3')) + 1

= 2 + 1
/ \
/ \
/ \
/ \
/ \
maxDepth('1') maxDepth('3') = 1
= max(maxDepth('4'), maxDepth('5')) + 1
= 1 + 1 = 2
/ \
/ \
/ \
/ \
/ \
maxDepth('4') = 1 maxDepth('5') = 1

Implementation:
#include<stdio.h>
#include<stdlib.h>

struct node
{
int data;
struct node* left;
struct node* right;
};
/* Compute the "maxDepth" of a tree -- the number of

nodes along the longest path from the root node
down to the farthest leaf node.*/
int maxDepth(struct node* node)
{
if (node==NULL)
return 0;
else
{
/* compute the depth of each subtree */
int lDepth = maxDepth(node->left);
int rDepth = maxDepth(node->right);
/* use the larger one */

if (lDepth > rDepth)
return(lDepth+1);
else return(rDepth+1);
}
}

{
node->data = data;
node->left = NULL;
node->right = NULL;

return(node);
}

int main()
{

printf("Hight of tree is %d", maxDepth(root));

getchar();
return 0;
}

Time Complexity: O(n) (Please see our post Tree Traversal for details)
References:
http://cslibrary.stanford.edu/110/BinaryTrees.html
Write an Efficient C Function to Convert a Binary Tree into its Mirror Tree
Mirror of a Tree: Mirror of a Binary Tree T is another Binary Tree M(T) with left and right children of all
non-leaf nodes interchanged.
Trees in the below figure are mirror of each other
Algorithm – Mirror(tree):
(1) Call Mirror for left-subtree i.e., Mirror(left-subtree)

(2) Call Mirror for right-subtree i.e., Mirror(left-subtree)
(3) Swap left and right subtrees.
temp = left-subtree
left-subtree = right-subtree
right-subtree = temp

Program:
#include<stdio.h>
#include<stdlib.h>

struct node
{
int data;
struct node* left;
struct node* right;
};

{
node->data = data;
node->left = NULL;
node->right = NULL;

return(node);
}
/* Change a tree so that the roles of the left and
right pointers are swapped at every node.
So the tree...
4
/ \
2 5
/ \
1 3
is changed to...
4
/ \
5 2
/ \
3 1
*/
void mirror(struct node* node)
{
if (node==NULL)
return;
else
{
struct node* temp;

/* do the subtrees */
mirror(node->left);
mirror(node->right);
/* swap the pointers in this node */

temp = node->left;
node->left = node->right;
node->right = temp;
}
}
/* Helper function to test mirror(). Given a binary

search tree, print out its data elements in
increasing sorted order.*/
void inOrder(struct node* node)
{
if (node == NULL)
return;

inOrder(node->left);
inOrder(node->right);
}
/* Driver program to test mirror() */

int main()
{

/* Print inorder traversal of the input tree */
printf("\n Inorder traversal of the constructed tree is \n");
inOrder(root);

/* Convert tree to its mirror */
mirror(root);

/* Print inorder traversal of the mirror tree */
printf("\n Inorder traversal of the mirror tree is \n");
inOrder(root);

getchar();
return 0;
}

Time & Space Complexities: This program is similar to traversal of tree space and time complexities will
be same as Tree traversal (Please see our Tree Traversal post for details)
Output of C Programs | Set 1
Predict the output of below programs.
Question 1
#include<stdio.h>
int main()
{
int n;
for(n = 7; n!=0; n--)
printf("n = %d", n--);
getchar();
return 0;
}

Output:Above program goes in infinite loop because n is never zero when loop condition (n != 0) is checked.
Question 2
#include<stdio.h>
int main()
{
printf("%x", -1<<1);
getchar();
return 0;
}

Output is dependent on the compiler. For 32 bit compiler it would be fffffffe and for 16 bit it would be fffe.
Question 3
# include <stdio.h>
# define scanf "%s Geeks For Geeks "
main()
{
printf(scanf, scanf);
getchar();
return 0;
}

Output: %s Geeks For Geeks Geeks For Geeks

Explanation: After pre-processing phase of compilation, printf statement will become.

printf("%s Geeks For Geeks ", "%s Geeks For Geeks ");

Now you can easily guess why output is %s Geeks For Geeks Geeks For Geeks.
Question 4
#include <stdlib.h>
#include <stdio.h>
enum {false, true};
int main()
{
int i = 1;
do
{
printf("%d\n", i);
i++;
if (i < 15)
continue;
} while (false);
getchar();
return 0;
}

Output: 1
Explanation: The do wile loop checks condition after each iteration. So after continue statement, control
transfers to the statement while(false). Since the condition is false ‘i’ is printed only once.
Now try below program.
#include <stdlib.h>
#include <stdio.h>
enum {false, true};
int main()
{
int i = 1;
do
{
printf("%d\n", i);
i++;
if (i < 15)
break;
} while (true);
getchar();
return 0;
}

Question 5

char *getString()
{
char *str = "Nice test for strings";
return str;
}
int main()
{
printf("%s", getString());
getchar();
return 0;
}

Output: “Nice test for strings”

The above program works because string constants are stored in Data Section (not in Stack Section). So,
when getString returns *str is not lost.
Check for Integer Overflow
Write a “C” function, int addOvf(int* result, int a, int b) If there is no overflow, the function places the
resultant = sum a+b in “result” and returns 0. Otherwise it returns -1. The solution of casting to long and
adding to find detecting the overflow is not allowed.
Method 1
There can be overflow only if signs of two numbers are same, and sign of sum is opposite to the signs of
numbers.
1) Calculate sum
2) If both numbers are positive and sum is negative then return -1
Else
If both numbers are negative and sum is positive then return -1
Else return 0

#include<stdio.h>
#include<stdlib.h>
/* Takes pointer to result and two numbers as

arguments. If there is no overflow, the function
places the resultant = sum a+b in “result” and
returns 0, otherwise it returns -1 */
int addOvf(int* result, int a, int b)
{
*result = a + b;
if(a > 0 && b > 0 && *result < 0)
return -1;
if(a < 0 && b < 0 && *result > 0)
return -1;
return 0;
}
int main()
{
int *res = (int *)malloc(sizeof(int));
int x = 2147483640;
int y = 10;
printf("%d", addOvf(res, x, y));
printf("\n %d", *res);

getchar();
return 0;
}

Time Complexity : O(1)

Method 2
Thanks to Himanshu Aggarwal for adding this method. This method doesn’t modify *result if there us an
overflow.

#include<stdio.h>
#include<limits.h>
#include<stdlib.h>
int addOvf(int* result, int a, int b)

{
if( a > INT_MAX - b)
return -1;
else
{
*result = a + b;
return 0;
}
}
int main()
{
int *res = (int *)malloc(sizeof(int));
int x = 2147483640;
int y = 10;
printf("%d", addOvf(res, x, y));

printf("\n %d", *res);
getchar();
return 0;
}

Time Complexity : O(1)

Please write comments if you find any bug in above codes/algorithms, or find other ways to solve the same
problem
Predict the output of the below program.
Question 1
#include <stdio.h>
int main()
{
printf("%d", main);
getchar();
return 0;
}

Output: Address of function main.

Explanation: Name of the function is actually a pointer variable to the function and prints the address of the
function. Symbol table is implemented like this.
struct
{
char *name;
int (*funcptr)();
}
symtab[] = {
"func", func,
"anotherfunc", anotherfunc,
};

Question 2
#include <stdio.h>
int main()
{
printf("\new_c_question\by");
printf("\rgeeksforgeeks");
getchar();
return 0;
}

Output: geeksforgeeksl
Explanation: First printf prints “ew_c_questioy”. Second printf has \r in it so it goes back to start of the line
and starts printing characters.
Now try to print following without using any of the escape characters.

new c questions by
geeksforgeeks

Question 3
# include<stdio.h>
# include<stdlib.h>
void fun(int *a)

{
a = (int*)malloc(sizeof(int));
}
int main()
{
int *p;
fun(p);
*p = 6;
printf("%d\n",*p);

getchar();
return(0);
}

It does not work. Try replacing “int *p;” with “int *p = NULL;” and it will try to dereference a null pointer.
This is because fun() makes a copy of the pointer, so when malloc() is called, it is setting the copied pointer
to the memory location, not p. p is pointing to random memory before and after the call to fun(), and when
you dereference it, it will crash.
If you want to add memory to a pointer from a function, you need to pass the address of the pointer (ie.
double pointer).
Thanks to John Doe for providing the correct solution.
Question 4
#include <stdio.h>
int main()
{
int i;
i = 1, 2, 3;
printf("i = %d\n", i);
getchar();
return 0;
}

Output: 1
The above program prints 1. Associativity of comma operator is from left to right, but = operator has higher
precedence than comma operator.
Therefore the statement i = 1, 2, 3 is treated as (i = 1), 2, 3 by the compiler.
Now it should be easy to tell output of below program.
#include <stdio.h>
int main()
{
int i;
i = (1, 2, 3);
printf("i = %d\n", i);
getchar();
return 0;
}

Question 5
#include <stdio.h>
int main()
{
int first = 50, second = 60, third;
third = first /* Will this comment work? */ + second;
printf("%d /* And this? */ \n", third);

getchar();
return 0;
}

Output: 110 /* And this? */

Explanation: Compiler removes everything between “/*” and “*/” if they are not present inside double
quotes (“”).
Question 1
char *getString()
{
char str[] = "Will I be printed?";
return str;
}
int main()
{
getchar();
}

Output: Some garbage value

The above program doesn’t work because array variables are stored in Stack Section. So, when getString
returns values at str are deleted and str becomes dangling pointer.
Question 2
int main()
{
static int i=5;
if(--i){
main();
printf("%d ",i);
}
}

Output: 0 0 0 0
Explanation: Since i is a static variable and is stored in Data Section, all calls to main share same i.
Question 3
int main()
{
static int var = 5;
printf("%d ",var--);
if(var)
main();
}

Output: 5 4 3 2 1
Explanation: Same as previous question. The only difference here is, sequence of calling main and printf is
changed, therefore different output.
Question 4
int main()
{
int x;
printf("%d",scanf("%d",&x));
/* Suppose that input value given
for above scanf is 20 */
return 1;
}

Output: 1
scanf returns the no. of inputs it has successfully read.
Question 5
# include <stdio.h>
int main()
{
int i=0;
for(i=0; i<20; i++)
{
switch(i)
{
case 0:
i+=5;
case 1:
i+=2;
case 5:
i+=5;
default:
i+=4;
break;
}
printf("%d ", i);
}
getchar();
return 0;
}

Output: 16 21
Explanation:
Initially i = 0. Since case 0 is true i becomes 5, and since there is no break statement till last statement of
switch block, i becomes 16. Now in next iteration no case is true, so execution goes to default and i becomes
21.
In C, if one case is true switch block is executed until it finds break statement. If no break statement is
present all cases are executed after the true case. If you want to know why switch is implemented like this,
well this implementation is useful for situations like below.

switch (c)
{
case 'a':
case 'e':
case 'i' :
case 'o':
case 'u':
printf(" Vowel character");
break;
default :
printf("Not a Vowel character");; break;
}

Predict the output of below programs
Question 1
#include‹stdio.h›
int main()
{
struct site
{
char name[] = "GeeksforGeeks";
int no_of_pages = 200;
};
struct site *ptr;
printf("%d",ptr->no_of_pages);
printf("%s",ptr->name);
getchar();
return 0;
}

Output:
Compiler error
Explanation:
Note the difference between structure/union declaration and variable declaration. When you declare a
structure, you actually declare a new data type suitable for your purpose. So you cannot initialize values as it
is not a variable declaration but a data type declaration.
Reference:
http://www.lix.polytechnique.fr/~liberti/public/computing/prog/c/C/SYNTAX/struct.html
Question 2
int main()
{
char a[2][3][3] = {'g','e','e','k','s','f','o',
'r','g','e','e','k','s'};
printf("%s ", **a);
getchar();
return 0;
}

Output:
geeksforgeeks
Explanation:
We have created a 3D array that should have 2*3*3 (= 18) elements, but we are initializing only 13 of them.
In C when we initialize less no of elements in an array all uninitialized elements become ‘\0′ in case of char
and 0 in case of integers.
Question 3

int main()
{
char str[]= "geeks\nforgeeks";
char *ptr1, *ptr2;

ptr1 = &str[3];
ptr2 = str + 5;
printf("%c", ++*str - --*ptr1 + *ptr2 + 2);
printf("%s", str);

getchar();
return 0;
}

Output:
heejs
forgeeks
Explanation:
Initially ptr1 points to ‘k’ and ptr2 points to ‘\n’ in “geeks\nforgeeks”. In print statement value at str is
incremented by 1 and value at ptr1 is decremented by 1. So string becomes “heejs\nforgeeks” .
First print statement becomes

printf(“%c”, ‘h’ – ‘j’ + ‘n’ + 2)
‘h’ – ‘j’ + ‘\n’ + 2 = -2 + ‘\n’ + 2 = ‘\n’
First print statements newline character. and next print statement prints “heejs\nforgeeks”.
Question 4

#include <stdio.h>
int fun(int n)
{
int i, j, sum = 0;
for(i = 1;i<=n;i++)
for(j=i;j<=i;j++)
sum=sum+j;
return(sum);
}
int main()
{
printf("%d", fun(15));
getchar();
return 0;
}

Output: 120
Explanation: fun(n) calculates sum of first n integers or we can say it returns n(n+1)/2.
Question 5

#include <stdio.h>
int main()
{
int c = 5, no = 1000;
do {
no /= c;
} while(c--);
printf ("%d\n", no);

return 0;
}

Output: Exception – Divide by zero
Explanation: There is a bug in the above program. It goes inside the do-while loop for c = 0 also. Be careful
when you are using do-while loop like this!!
Ugly Numbers
Ugly numbers are numbers whose only prime factors are 2, 3 or 5. The sequence
1, 2, 3, 4, 5, 6, 8, 9, 10, 12, 15, …
shows the first 11 ugly numbers. By convention, 1 is included.
Write a program to find and print the 150’th ugly number.
METHOD 1 (Simple)
Thanks to Nedylko Draganov for suggesting this solution.
Algorithm:
Loop for all positive integers until ugly number count is smaller than n, if an integer is ugly than increment
ugly number count.
To check if a number is ugly, divide the number by greatest divisible powers of 2, 3 and 5, if the number
becomes 1 then it is an ugly number otherwise not.
For example, let us see how to check for 300 is ugly or not. Greatest divisible power of 2 is 4, after dividing
300 by 4 we get 75. Greatest divisible power of 3 is 3, after dividing 75 by 3 we get 25. Greatest divisible
power of 5 is 25, after dividing 25 by 25 we get 1. Since we get 1 finally, 300 is ugly number.
Implementation:

# include<stdio.h>
# include<stdlib.h>
/*This function divides a by greatest divisible

power of b*/
int maxDivide(int a, int b)
{
while (a%b == 0)
a = a/b;
return a;
}
/* Function to check if a number is ugly or not */

int isUgly(int no)
{
no = maxDivide(no, 2);

return (no == 1)? 1 : 0;
}
/* Function to get the nth ugly number*/

int getNthUglyNo(int n)
{
int i = 1;
int count = 1; /* ugly number count */
/*Check for all integers untill ugly count

becomes n*/
while (n > count)
{
i++;
if (isUgly(i))
count++;
}
return i;
}
/* Driver program to test above functions */

int main()
{
unsigned no = getNthUglyNo(150);
printf("150th ugly no. is %d ", no);
getchar();
return 0;
}

This method is not time efficient as it checks for all integers until ugly number count becomes n, but space
complexity of this method is O(1)
METHOD 2 (Use Dynamic Programming)

Here is a time efficient solution with O(n) extra space. The ugly-number sequence is 1, 2, 3, 4, 5, 6, 8, 9, 10,
12, 15, …
because every number can only be divided by 2, 3, 5, one way to look at the sequence is to split the
sequence to three groups as below:
(1) 1×2, 2×2, 3×2, 4×2, 5×2, …
(2) 1×3, 2×3, 3×3, 4×3, 5×3, …
(3) 1×5, 2×5, 3×5, 4×5, 5×5, …
We can find that every subsequence is the ugly-sequence itself (1, 2, 3, 4, 5, …) multiply 2, 3, 5. Then we
use similar merge method as merge sort, to get every ugly number from the three subsequence. Every step
we choose the smallest one, and move one step after.
Algorithm:
1 Declare an array for ugly numbers: ugly[150]

2 Initialize first ugly no: ugly[0] = 1
3 Initialize three array index variables i2, i3, i5 to point to
1st element of the ugly array:
i2 = i3 = i5 =0;
4 Initialize 3 choices for the next ugly no:
next_mulitple_of_2 = ugly[i2]*2;
next_mulitple_of_3 = ugly[i3]*3
next_mulitple_of_5 = ugly[i5]*5;
5 Now go in a loop to fill all ugly numbers till 150:
For (i = 1; i
Example:
Let us see how it works

initialize
ugly[] = | 1 |
i2 = i3 = i5 = 0;
First iteration
ugly[1] = Min(ugly[i2]*2, ugly[i3]*3, ugly[i5]*5)
= Min(2, 3, 5)
= 2
ugly[] = | 1 | 2 |
i2 = 1, i3 = i5 = 0 (i2 got incremented )
Second iteration
= Min(4, 3, 5)
= 3
ugly[] = | 1 | 2 | 3 |
i2 = 1, i3 = 1, i5 = 0 (i3 got incremented )
Third iteration
= Min(4, 6, 5)
= 4
ugly[] = | 1 | 2 | 3 | 4 |
Fourth iteration
= Min(6, 6, 5)
= 5
ugly[] = | 1 | 2 | 3 | 4 | 5 |
Fifth iteration
= Min(6, 6, 10)
= 6
ugly[] = | 1 | 2 | 3 | 4 | 5 | 6 |
i2 = 3, i3 = 2, i5 = 1 (i2 and i3 got incremented )
Will continue same way till I

Program:

# include<stdio.h>
# include<stdlib.h>
# define bool int
/* Function to find minimum of 3 numbers */

unsigned min(unsigned , unsigned , unsigned );
/* Function to get the nth ugly number*/

unsigned getNthUglyNo(unsigned n)
{
unsigned *ugly =
(unsigned *)(malloc (sizeof(unsigned)*n));
unsigned i2 = 0, i3 = 0, i5 = 0;
unsigned i;
unsigned next_multiple_of_2 = 2;
unsigned next_ugly_no = 1;
*(ugly+0) = 1;
for(i=1; i<n; i++)

{
next_ugly_no = min(next_multiple_of_2,
next_multiple_of_3,
next_multiple_of_5);
*(ugly+i) = next_ugly_no;
if(next_ugly_no == next_multiple_of_2)
{
i2 = i2+1;
next_multiple_of_2 = *(ugly+i2)*2;
}
{
i3 = i3+1;
}
{
i5 = i5+1;
}
} /*End of for loop (i=1; i<n; i++) */
return next_ugly_no;
}
/* Function to find minimum of 3 numbers */

unsigned min(unsigned a, unsigned b, unsigned c)
{
if(a <= b)
{
if(a <= c)
return a;
else
return c;
}
if(b <= c)
return b;
else
return c;
}

int main()
{
unsigned no = getNthUglyNo(150);
printf("%dth ugly no. is %d ", 150, no);
getchar();
return 0;
}

Storage Complexity: O(n)
Please write comments if you find any bug in the above program or other ways to solve
the same problem.

Little and Big Endian Mystery
What are these?
Little and big endian are two ways of storing multibyte data-types ( int, float, etc). In little endian machines,
last byte of binary representation of the multibyte data-type is stored first. On the other hand, in big endian
machines, first byte of binary representation of the multibyte data-type is stored first.
Suppose integer is stored as 4 bytes (For those who are using DOS based compilers such as C++ 3.0 , integer
is 2 bytes) then a variable x with value 0x01234567 will be stored as following.
Memory representation of integer ox01234567 inside Big and little endian machines
How to see memory representation of multibyte data types on your machine?

Here is a sample C code that shows the byte representation of int, float and pointer.
#include <stdio.h>
/* function to show bytes in memory, from location start to start+n*/

void show_mem_rep(char *start, int n)
{
int i;
for (i = 0; i < n; i++)
printf(" %.2x", start[i]);
printf("\n");
}
/*Main function to call above function for 0x01234567*/

int main()
{
int i = 0x01234567;
show_mem_rep((char *)&i, sizeof(i));
getchar();
return 0;
}

When above program is run on little endian machine, gives “67 45 23 01″ as output , while if it is run on
endian machine, gives “01 23 45 67″ as output.
Is there a quick way to determine endianness of your machine?

There are n no. of ways for determining endianness of your machine. Here is one quick way of doing the
same.

#include <stdio.h>
int main()
{
unsigned int i = 1;
char *c = (char*)&i;
if (*c)
printf("Little endian");
else
printf("Big endian");
getchar();
return 0;
}

In the above program, a character pointer c is pointing to an integer i. Since size of character is 1 byte when
the character pointer is de-referenced it will contain only first byte of integer. If machine is little endian then
*c will be 1 (because last byte is stored first) and if machine is big endian then *c will be 0.
Does endianness matter for programmers?

Most of the times compiler takes care of endianness, however, endianness becomes an issue in following
cases.
It matters in network programming: Suppose you write integers to file on a little endian machine and you
transfer this file to a big endian machine. Unless there is little andian to big endian transformation, big
endian machine will read the file in reverse order. You can find such a practical example here.
Standard byte order for networks is big endian, also known as network byte order. Before transferring data
on network, data is first converted to network byte order (big endian).
Sometimes it matters when you are using type casting, below program is an example.
#include <stdio.h>
int main()
{
unsigned char arr[2] = {0x01, 0x00};
unsigned short int x = *(unsigned short int *) arr;
printf("%d", x);
getchar();
return 0;
}

In the above program, a char array is typecasted to an unsigned short integer type. When I run above
program on little endian machine, I get 1 as output, while if I run it on a big endian machine I get 256. To
make programs endianness independent, above programming style should be avoided.
What are bi-endians?

Bi-endian processors can run in both modes little and big endian.
What are the examples of little, big endian and bi-endian machines ?
Intel based processors are little endians. ARM processors were little endians. Current generation ARM
processors are bi-endian.
Motorola 68K processors are big endians. PowerPC (by Motorola) and SPARK (by Sun) processors were big
endian. Current version of these processors are bi-endians.
Does endianness effects file formats?

File formats which have 1 byte as a basic unit are independent of endianness e..g., ASCII files . Other file
formats use some fixed endianness forrmat e.g, JPEG files are stored in big endian format.
Which one is better — little endian or big endian

The term little and big endian came from Gulliver’s Travels by Jonathan Swift. Two groups could not agree
by which end a egg should be opened -a-the little or the big. Just like the egg issue, there is no technological
reason to choose one byte ordering convention over the other, hence the arguments degenerate into
bickering about sociopolitical issues. As long as one of the conventions is selected and adhered to
consistently, the choice is arbitrary.
Write a C function to print the middle of a given linked list
Method 1:
Traverse the whole linked list and count the no. of nodes. Now traverse the list again till count/2 and return
the node at count/2.
Method 2:
Traverse linked list using two pointers. Move one pointer by one and other pointer by two. When the fast
pointer reaches end slow pointer will reach middle of the linked list.
#include<stdio.h>
#include<stdlib.h>

struct node
{
int data;
struct node* next;
};
/* Function to get the middle of the linked list*/

void printMiddle(struct node *head)
{
struct node *slow_ptr = head;
struct node *fast_ptr = head;
if (head!=NULL)
{
while (fast_ptr != NULL && fast_ptr->next != NULL)
{
fast_ptr = fast_ptr->next->next;
slow_ptr = slow_ptr->next;
}
printf("The middle element is [%d]\n\n", slow_ptr->data);
}
}

{
/* allocate node */



}
// A utility function to print a given linked list

void printList(struct node *ptr)
{
while (ptr != NULL)
{
printf("%d->", ptr->data);
ptr = ptr->next;
}
}
printf("NULL\n");
}

int main()
{
int i;
for (i=5; i>0; i--)

{
push(&head, i);
printList(head);
printMiddle(head);
}
return 0;
}

Output:

5->NULL
The middle element is [5]
4->5->NULL
3->4->5->NULL
2->3->4->5->NULL
1->2->3->4->5->NULL

Method 3:
Initialize mid element as head and initialize a counter as 0. Traverse the list from head, while traversing
increment the counter and change mid to mid->next whenever the counter is odd. So the mid will move only
half of the total length of the list.
Thanks to Narendra Kangralkar for suggesting this method.
#include<stdio.h>
#include<stdlib.h>

struct node
{
int data;
struct node* next;
};
/* Function to get the middle of the linked list*/

{
int count = 0;
struct node *mid = head;
while (head != NULL)

{
/* update mid, when 'count' is odd number */
if (count & 1)
mid = mid->next;
++count;
head = head->next;
}
/* if empty list is provided */

if (mid != NULL)
printf("The middle element is [%d]\n\n", mid->data);
}

{
/* allocate node */



}

{
while (ptr != NULL)
{
printf("%d->", ptr->data);
ptr = ptr->next;
}
printf("NULL\n");
}

int main()
{
int i;
for (i=5; i>0; i--)

{
push(&head, i);
printList(head);
printMiddle(head);
}
return 0;
}

Output:
5->NULL
4->5->NULL
3->4->5->NULL
2->3->4->5->NULL
1->2->3->4->5->NULL

discussed above.
Nth node from the end of a Linked List
Given a Linked List and a number n, write a function that returns the value at the nth node from end of the
Linked List.
Method 1 (Use length of linked list)

1) Calculate the length of Linked List. Let the length be len.
2) Print the (len – n + 1)th node from the begining of the Linked List.
#include<stdio.h>
#include<stdlib.h>

struct node
{
int data;
struct node* next;
};
/* Function to get the nth node from the last of a linked list*/
void printNthFromLast(struct node* head, int n)
{
int len = 0, i;
// 1) count the number of nodes in Linked List

while (temp != NULL)
{
temp = temp->next;
len++;
}
// check if value of n is not more than length of the linked list

if (len < n)
return;
temp = head;
// 2) get the (n-len+1)th node from the begining

for (i = 1; i < len-n+1; i++)
temp = temp->next;
printf ("%d", temp->data);
return;
}

{
/* allocate node */



}

int main()
{
// create linked 35->15->4->20

push(&head, 20);
push(&head, 4);
push(&head, 15);
push(&head, 35);
printNthFromLast(head, 5);
getchar();
return 0;
}

Following is a recursive C code for the same method. Thanks to Anuj Bansal for providing following code.
void printNthFromLast(struct node* head, int n)

{
static int i = 0;
if(head == NULL)
return;
printNthFromLast(head->next, n);
if(++i == n)
printf("%d", head->data);
}

Time Complexity: O(n) where n is the length of linked list.
Method 2 (Use two pointers)

Maintain two pointers – reference pointer and main pointer. Initialize both reference and main pointers to
head. First move reference pointer to n nodes from head. Now move both pointers one by one until
reference pointer reaches end. Now main pointer will point to nth node from the end. Return main pointer.
Implementation:
#include<stdio.h>
#include<stdlib.h>

struct node
{
int data;
struct node* next;
};
/* Function to get the nth node from the last of a linked list*/
void printNthFromLast(struct node *head, int n)
{
{
struct node *main_ptr = head;
struct node *ref_ptr = head;
int count = 0;
if(head != NULL)
{
while( count < n )
{
if(ref_ptr == NULL)
{
printf("%d is greater than the no. of "
"nodes in list", n);
return;
}
ref_ptr = ref_ptr->next;
count++;
} /* End of while*/
while(ref_ptr != NULL)
{
main_ptr = main_ptr->next;
ref_ptr = ref_ptr->next;
}
printf("Node no. %d from last is %d ",
n, main_ptr->data);
}
}

{
/* allocate node */



}

int main()
{
push(&head, 20);
push(&head, 4);
push(&head, 15);
printNthFromLast(head, 3);
getchar();
}

Time Complexity: O(n) where n is the length of linked list.
Please write comments if you find the above codes/algorithms incorrect, or find other ways to solve the
same problem.
Write a function to delete a Linked List
Algorithm: Iterate through the linked list and delete all the nodes one by one. Main point here is not to
access next of the current pointer if current pointer is deleted.
Implementation:
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

struct node
{
int data;
struct node* next;
};
/* Function to delete the entire linked list */

void deleteList(struct node** head_ref)
{
/* deref head_ref to get the real head */
struct node* current = *head_ref;
struct node* next;

{
next = current->next;
free(current);
current = next;
}

/* deref head_ref to affect the real head back
in the caller. */
*head_ref = NULL;
}

of the list. */
{
/* allocate node */



}
/* Drier program to test count function*/

int main()
{

1->12->1->4->1 */
push(&head, 1);
push(&head, 4);
push(&head, 1);
push(&head, 12);
push(&head, 1);

printf("\n Deleting linked list");
deleteList(&head);

printf("\n Linked list deleted");
getchar();
}


Understanding “extern” keyword in C
I’m sure that this post will be as interesting and informative to C virgins (i.e. beginners) as it will be to those
who are well versed in C. So let me start with saying that extern keyword applies to C variables (data objects)
and C functions. Basically extern keyword extends the visibility of the C variables and C functions. Probably
that’s is the reason why it was named as extern.
Though (almost) everyone knows the meaning of declaration and definition of a variable/function yet for the
sake of completeness of this post, I would like to clarify them. Declaration of a variable/function simply
declares that the variable/function exists somewhere in the program but the memory is not allocated for
them. But the declaration of a variable/function serves an important role. And that is the type of the
variable/function. Therefore, when a variable is declared, the program knows the data type of that variable.
In case of function declaration, the program knows what are the arguments to that functions, their data
types, the order of arguments and the return type of the function. So that’s all about declaration. Coming to
the definition, when we define a variable/function, apart from the role of declaration, it also allocates
memory for that variable/function. Therefore, we can think of definition as a super set of declaration. (or
declaration as a subset of definition). From this explanation, it should be obvious that a variable/function can
be declared any number of times but it can be defined only once. (Remember the basic principle that you
can’t have two locations of the same variable/function). So that’s all about declaration and definition.
Now coming back to our main objective: Understanding “extern” keyword in C. I’ve explained the role of
declaration/definition because it’s mandatory to understand them to understand the “extern” keyword. Let
us first take the easy case. Use of extern with C functions. By default, the declaration and definition of a C
function have “extern” prepended with them. It means even though we don’t use extern with the
declaration/definition of C functions, it is present there. For example, when we write.
int foo(int arg1, char arg2);

There’s an extern present in the beginning which is hidden and the compiler treats it as below.
extern int foo(int arg1, char arg2);

Same is the case with the definition of a C function (Definition of a C function means writing the body of the
function). Therefore whenever we define a C function, an extern is present there in the beginning of the
function definition. Since the declaration can be done any number of times and definition can be done only
once, we can notice that declaration of a function can be added in several C/H files or in a single C/H file
several times. But we notice the actual definition of the function only once (i.e. in one file only). And as the
extern extends the visibility to the whole program, the functions can be used (called) anywhere in any of the
files of the whole program provided the declaration of the function is known. (By knowing the declaration of
the function, C compiler knows that the definition of the function exists and it goes ahead to compile the
program). So that’s all about extern with C functions.
Now let us the take the second and final case i.e. use of extern with C variables. I feel that it more interesting
and information than the previous case where extern is present by default with C functions. So let me ask
the question, how would you declare a C variable without defining it? Many of you would see it trivial but it’s
important question to understand extern with C variables. The answer goes as follows.

extern int var;

Here, an integer type variable called var has been declared (remember no definition i.e. no memory
allocation for var so far). And we can do this declaration as many times as needed. (remember that
declaration can be done any number of times) So far so good.
Now how would you define a variable. Now I agree that it is the most trivial question in programming and
the answer is as follows.
int var;

Here, an integer type variable called var has been declared as well as defined. (remember that definition is
the super set of declaration). Here the memory for var is also allocated. Now here comes the surprise, when
we declared/defined a C function, we saw that an extern was present by default. While defining a function,
we can prepend it with extern without any issues. But it is not the case with C variables. If we put the
presence of extern in variable as default then the memory for them will not be allocated ever, they will be
declared only. Therefore, we put extern explicitly for C variables when we want to declare them without
defining them. Also, as the extern extends the visibility to the whole program, by externing a variable we can
use the variables anywhere in the program provided we know the declaration of them and the variable is
defined somewhere.
Now let us try to understand extern with examples.
Example 1:
int var;
int main(void)
{
var = 10;
return 0;
}

Analysis: This program is compiled successfully. Here var is defined (and declared implicitly) globally.
Example 2:

extern int var;

int main(void)
{
return 0;
}

Analysis: This program is compiled successfully. Here var is declared only. Notice var is never used so no
problems.
Example 3:
extern int var;

int main(void)
{
var = 10;
return 0;
}

Analysis: This program throws error in compilation. Because var is declared but not defined anywhere.
Essentially, the var isn’t allocated any memory. And the program is trying to change the value to 10 of a
variable that doesn’t exist at all.
Example 4:
#include "somefile.h"
extern int var;
int main(void)
{
var = 10;
return 0;
}

Analysis: Supposing that somefile.h has the definition of var. This program will be compiled successfully.
Example 5:
extern int var = 0;

int main(void)
{
var = 10;
return 0;
}

Analysis: Guess this program will work? Well, here comes another surprise from C standards. They say
that..if a variable is only declared and an initializer is also provided with that declaration, then the memory
for that variable will be allocated i.e. that variable will be considered as defined. Therefore, as per the C
standard, this program will compile successfully and work.
So that was a preliminary look at “extern” keyword in C.
I’m sure that you want to have some take away from the reading of this post. And I would not disappoint
you.
In short, we can say
1. Declaration can be done any number of times but definition only once.
2. “extern” keyword is used to extend the visibility of variables/functions().
3. Since functions are visible through out the program by default. The use of extern is not needed in function
declaration/definition. Its use is redundant.
4. When extern is used with a variable, it’s only declared not defined.
5. As an exception, when an extern variable is declared with initialization, it is taken as definition of the
variable as well.
Write a function that counts the number of times a given int occurs in a
Linked List
Here is a solution.
Algorithm:
1. Initialize count as zero.

2. Loop through each element of linked list:
a) If element data is equal to the passed number then
increment the count.
3. Return count.

Implementation:
#include<stdio.h>
#include<stdlib.h>

struct node
{
int data;
struct node* next;
};

of the list. */
{
/* allocate node */



}
/* Counts the no. of occurences of a node

(search_for) in a linked list (head)*/
int count(struct node* head, int search_for)
{
int count = 0;
{
if (current->data == search_for)
count++;
}
return count;
return count;
}

int main()
{

1->2->1->3->1 */
push(&head, 1);
push(&head, 3);
push(&head, 1);
push(&head, 2);
push(&head, 1);

/* Check the count function */
printf("count of 1 is %d", count(head, 1));
getchar();
}


Auxiliary Space: O(1)
Question 1
int main()
{
while(1){
if(printf("%d",printf("%d")))
break;
else
continue;
}
return 0;
}

Output:
Can’t be predicted
Explanation:
The condition in while loop is 1 so at first shot it looks infinite loop. Then there are break and continue in the
body of the while loop, so it may not be infinite loop. The break statement will be executed if the condition
under if is met, otherwise continue will be executed. Since there’s no other statements after continue in the
while loop, continue doesn’t serve any purpose. In fact it is extraneous. So let us see the if condition. If we
look carefully, we will notice that the condition of the if will be met always, so break will be executed at the
first iteration itself and we will come out of while loop. The reason why the condition of if will be met is
printf function. Function printf always returns the no. of bytes it has output. For example, the return value of
printf(“geeks”) will be 5 because printf will output 5 characters here. In our case, the inner printf will be
executed first but this printf doesn’t have argument for format specifier i.e. %d. It means this printf will
print any arbitrary value. But notice that even for any arbirary value, the no. of bytes output by inner printf
would be non-zero. And those no. of bytes will work as argument to outer printf. The outer printf will print
that many no. of bytes and return non-zero value always. So the condition for if is also true always.
Therefore, the while loop be executed only once. As a side note, even without outer printf also, the condition
for if is always true.
Question 2
int main()
{
unsigned int i=10;
while(i-- >= 0)
printf("%u ",i);
return 0;
}

Output:
9 8 7 6 5 4 3 2 1 0 4294967295 4294967294 …… (on a machine where int is 4 bytes long)
9 8 7 6 5 4 3 2 1 0 65535 65534 …. (on a machine where int is 2 bytes long)

Explanation:
Let us examine the condition of while loop. It is obvious that as far as the condition of while loop is met,
printf will be executed. There are two operators in the condition of while loop: post-decrement operator and
comparison operator. From operator precedence, we know that unary operator post-decrement has higher
priority than comparison operator. But due to post-decrement property, the value of i will be decremented
only after it had been used for comparison. So at the first iteration, the condition is true because 10>=0 and
then i is decremented. Therefore 9 will be printed. Similarly the loop continues and the value of i keeps on
decrementing. Let us see what what happen when condition of while loop becomes 0 >= 0. At this time,
condition is met and i is decremented. Since i is unsigned integer, the roll-over happens and i takes the value
of the highest +ve value an unsigned int can take. So i is never negative. Therefore, it becomes infinite while
loop.
As a side note, if i was signed int, the while loop would have been terminated after printing the highest
negative value.
Question 3
int main()
{
int x,y=2,z,a;
if ( x = y%2)
z =2;
a=2;
printf("%d %d ",z,x);
return 0;
}

Output:
< some garbage value of z > 0
Explanation:
This question has some stuff for operator precedence. If the condition of if is met, then z will be initialized to
2 otherwise z will contain garbage value. But the condition of if has two operators: assignment operator and
modulus operator. The precedence of modulus is higher than assignment. So y%2 is zero and it’ll be
assigned to x. So the value of x becomes zero which is also the effective condition for if. And therefore,
condition of if is false.
Question 4

int main()
{
int a[10];
printf("%d",*a+1-*a+3);
return 0;
}

Output: 4
Explanation:
From operator precedence, de-reference operator has higher priority than addition/subtraction operator. So
de-reference will be applied first. Here, a is an array which is not initialized. If we use a, then it will point to
the first element of the array. Therefore *a will be the first element of the array. Suppose first element of
array is x, then the argument inside printf becomes as follows. It’s effective value is 4.
x + 1 – x + 3 = 4
Question 5
#define prod(a,b) a*b

int main()
{
int x=3,y=4;
printf("%d",prod(x+2,y-1));
return 0;
}

Output:
10
Explanation:
This program deals with macros, their side effects and operator precedence. Here prod is a macro which
multiplies its two arguments a and b. Let us take a closer look.
prod(a, b) = a*b
prod(x+2, y-1) = x+2*y-1 = 3+2*4-1 = 3+8-1=10
If the programmer really wanted to multiply x+2 and y-1, he should have put parenthesis around a and b as
follows.
prod(a,b) = (a)*(b)
This type of mistake in macro definition is called – macro side-effects.

Question 1
int main()
{
unsigned int i=65000;
while ( i++ != 0 );
printf("%d",i);
return 0;
}

Output:
1
Explanation:
It should be noticed that there’s a semi-colon in the body of while loop. So even though, nothing is done as
part of while body, the control will come out of while only if while condition isn’t met. In other words, as
soon as i inside the condition becomes 0, the condition will become false and while loop would be over. But
also notice the post-increment operator in the condition of while. So first i will be compared with 0 and i will
be incremented no matter whether condition is met or not. Since i is initialized to 65000, it will keep on
incrementing till it reaches highest positive value. After that roll over happens, and the value of i becomes
zero. The condition is not met, but i would be incremented i.e. to 1. Then printf will print 1.
Question 2
int main()
{
int i=0;
while ( +(+i--) != 0)
i-=i++;
printf("%d",i);
return 0;
}

Output:
-1
Explanation:
Let us first take the condition of while loop. There are several operator there. Unary + operator doesn’t do
anything. So the simplified condition becomes (i–) != 0. So i will be compared with 0 and then decremented
no matter whether condition is true or false. Since i is initialized to 0, the condition of while will be false at
the first iteration itself but i will be decremented to -1. The body of while loop will not be executed. And
printf will print -1.
So it wasn’t that scary as it seemed to be!
Question 3

int main()
{
float f=5,g=10;
enum{i=10,j=20,k=50};
printf("%d\n",++k);
printf("%f\n",f<<2);
printf("%lf\n",f%g);
printf("%lf\n",fmod(f,g));
return 0;
}

Output:
Program will not compile and give 3 errors
Explanation:
Here, i, j and k are inside the enum and therefore, they are like constants. In other words, if want to us 10
anywhere in the program , we can use i instead. In the first printf, the value of i is being modified which is
not allowed because it’s enum constant. In the second printf, left-shift operator is being applied on a float
which is also not allowed. Similarly, in the third printf, modulus operator is being applied on float f and g
which is also not allowed.
Question 4

int main()
{
int i=10;
void pascal f(int,int,int);
f(i++, i++, i++);
printf(" %d",i);
return 0;
}
void pascal f(integer :i,integer:j,integer :k)
{
write(i,j,k);
}

Output:
Program will give compile-time error
Explanation:
Compiler specific question. Not all compilers support this.
Otherwise, pascal enforces left to right processing of arguments. So even though, the argument processing
order can be changed by the use of pascal, we can’t use Pascal language routines such as write inside C
program.
Question 5

void pascal f(int i,int j,int k)

{
printf("%d %d %d",i, j, k);
}
void cdecl f(int i,int j,int k)

{
printf("%d %d %d",i, j, k);
}
main()
{
int i=10;
f(i++,i++,i++);
printf(" %d\n",i);
i=10;
f(i++,i++,i++);
printf(" %d",i);
}

Output:
Compiler specific question. Not all the compilers allow this.
Explanation:
This question deals with the argument passing mechanism. If we call a function, the order in which the
arguments of the function are processed is not governed by C Standard. So one compiler can process the
arguments from left to right while the other compiler can process them right to left. Usually, the programs
are not affected with this because the arguments of the programs are different. For example if we call funtion
fun as fun(i,j), then no matter in which order the arguments are processed, the value of i and j will be
consistent.
But in this case, we are passing the arguments to function f using the same variable. So the order in which
arguments are processed by the function will determine the value of those arguments. cdecl enforces right to
left processing of arguments while pascal enforces left to right processing of arguments.
So the value of i, j and k inside the first function f will be 10, 11 and 12 respectively while the value of i, j and k
inside the second function f will be 12, 11 and 10 respectively.
Let’s experiment with Networking
Most of us have studied Computer Networks in a very abstract manner. In other words, not many of us know
how the abstract concepts of layers and packets translate in real life networks such as the Internet. Therefore
let us do an experiment and see whether these layers, packets etc. exist in any real network also. So get, set
and ready to delve into this wonderful world of practical and experimental Networking!
The outline of our experiment is as follows. We will capture some live packets, and to understand what is
inside those packets, we will analyze those packets by dissecting them. Sounds surgical? Yup, it is. J
To start with, we need to have a PC running Windows XP and connected to the Internet. If you are reading
this article online, the chances are high that you have everything ready to experiment. Now let’s recall some
of the theory stuff that we read in Networking Books. The first thing that almost every book tells us –
networking architecture is layered; remember that 7 layer OSI protocol stack! So where are these protocol
layers? In our experiment, we will use 5 layer Internet Protocol stack so that we can solve the mystery of
these layers.
We start our experiment by installing Wireshark (earlier known as Ethereal). Wireshark is a Network
Protocol Analyzer that can capture and analyze the packets transmitted/received via a Network Interface
Card (NIC). [You need to bear with me this acronym because Networking is full of acronymsJ] We install
Wireshark from http://www.wireshark.org/download.html (at the time of this writing, the latest Wireshark
version is 1.0.3). While installing Wireshark, leave the default settings/options as it is. Now our experimental
setup is ready. Run Wireshark and click on the first icon (List the available capture interfaces …). Now we
see a pop up window that shows Capture Interfaces. See the snapshots as follows.
The number and types of interfaces shown in Capture Interfaces window can be different for you depending
on your PC’s configuration. For me it shows two interfaces and my Internet connection is through Broadcom
Gigabit Interface. So choose the interface through which your Internet connection is available to you. Now
let’s click on the Options button of this interface. Now we see a new window named Capture Options. In this
window, type “port 80” in text field named Capture Filter. See the following snapshot for clarification.
Now we are ready to capture the packets passing through our NIC. By setting the filter to “port 80”, we have
instructed Wireshark to capture only those packets that are because of http traffic (remember that we were
always told that the default http port is 80!). Now click on the Start button on Capture Options window. You
may see some packets in Wireshark if any program in your PC is accessing http traffic in the background;
let’s not focus on that. Now open your browser and try to access http://google.com and now you should be
seeing lot many packets getting captured in Wireshark. See the snapshot as follows.
Let’s start analyzing the captured packets. First of all, find the first instance of http packet that has GET /
HTTP/1.1 in its Info field. In the above snapshot, it’s shown in blue. If we take a closer look, we see that this
packet has the headers of the all the 5 layers of the Internet Protocol stack.
Layer 1 – It is the Physical layer. Here Frames are shown at the physical layer.
Layer 2 – It is the Data Link layer. In this packet, we can see that Ethernet II is used as data link layer
protocol. We can find the MAC address of the source and destination in this header.
Layer 3 – It is the Network layer. In this packet, we see that IP is used as Network layer protocol. We can see
the source and destination IP in this header.
Layer 4 – It is the Transport layer. In this packet, TCP is used as Transport layer protocol. We can find the
source and destination ports in this header.
Layer 5 – It is the Application layer. In this packet, HTTP is used as Application layer protocol.
Let’s explore one of the layers. Other layers can be explored further in the similar fashion. If we expand the
Layer 5 i.e. HTTP header, it looks as follows.
Here we see that Host is mentioned as google.com that is what we tried to access from browser. User Agent
field of the HTTP header shows the browser details. In my case, it is Mozilla Firefox as evidenced from this
header. Destination IP 64.233.187.99 should be one of the IP addresses assigned to Google server where the
web server is hosted. It can be verified using a very handy utility command “nslookup”. The details of the
other fields can be explored in the headers of the HTTP, TCP, IP, Ethernet II protocols. Some of the
interesting fields are – Differentiated Services Field (also known as QoS field) in IP header, Window size in
TCP header etc.
So we have seen that all those rhetorical concepts of layers etc. do exist in real networks also. And it sounds
interesting when you dissect all the packets that pass through your interface card. By doing so, you can get to
know what goes/comes through your PC!
The idea of this experiment is to provide a conducive platform so that you can explore your own the exciting
world of Networking. So welcome aboard!
Write a C program to print all permutations of a given string
A permutation, also called an “arrangement number” or “order,” is a rearrangement of the elements of an
ordered list S into a one-to-one correspondence with S itself. A string of length n has n! permutation.
Source: Mathword(http://mathworld.wolfram.com/Permutation.html)
Below are the permutations of string ABC.

ABC, ACB, BAC, BCA, CAB, CBA
Here is a solution using backtracking.

// C program to print all permutations with duplicates allowed

#include <stdio.h>
#include <string.h>
/* Function to swap values at two pointers */

void swap(char *x, char *y)
{
char temp;
temp = *x;
*x = *y;
*y = temp;
}
/* Function to print permutations of string

This function takes three parameters:
1. String
2. Starting index of the string
3. Ending index of the string. */
void permute(char *a, int l, int r)
{
int i;
if (l == r)
printf("%s\n", a);
else
{
for (i = l; i <= r; i++)
{
swap((a+l), (a+i));
permute(a, l+1, r);
swap((a+l), (a+i)); //backtrack
}
}
}

int main()
{
char str[] = "ABC";
int n = strlen(str);
permute(str, 0, n-1);
return 0;
}

Output:

ABC
ACB
BAC
BCA
CBA
CAB

Algorithm Paradigm: Backtracking

Time Complexity: O(n*n!)
same problem.
Write an Efficient C Program to Reverse Bits of a Number
Method1 – Simple
Loop through all the bits of an integer. If a bit at ith position is set in the i/p no. then set the bit at
(NO_OF_BITS – 1) – i in o/p. Where NO_OF_BITS is number of bits present in the given number.
/* Function to reverse bits of num */

unsigned int reverseBits(unsigned int num)
{
unsigned int NO_OF_BITS = sizeof(num) * 8;
unsigned int reverse_num = 0, i, temp;
for (i = 0; i < NO_OF_BITS; i++)

{
temp = (num & (1 << i));
if(temp)
reverse_num |= (1 << ((NO_OF_BITS - 1) - i));
}

return reverse_num;
}
/* Driver function to test above function */

int main()
{
unsigned int x = 2;
printf("%u", reverseBits(x));
getchar();
}

Above program can be optimized by removing the use of variable temp. See below the modified code.

{
unsigned int NO_OF_BITS = sizeof(num) * 8;
unsigned int reverse_num = 0;
int i;
for (i = 0; i < NO_OF_BITS; i++)
{
if((num & (1 << i)))
reverse_num |= 1 << ((NO_OF_BITS - 1) - i);
}
return reverse_num;
}

Time Complexity: O(log n)

Method 2 – Standard
The idea is to keep putting set bits of the num in reverse_num until num becomes zero. After num becomes
zero, shift the remaining bits of reverse_num.
Let num is stored using 8 bits and num be 00000110. After the loop you will get reverse_num as 00000011.
Now you need to left shift reverse_num 5 more times and you get the exact reverse 01100000.

{
unsigned int count = sizeof(num) * 8 - 1;
unsigned int reverse_num = num;

num >>= 1;
while(num)
{
reverse_num <<= 1;
reverse_num |= num & 1;
num >>= 1;
count--;
}
reverse_num <<= count;
return reverse_num;
}
int main()
{
unsigned int x = 1;
printf("%u", reverseBits(x));
getchar();
}

Time Complexity: O(log n)

Method 3 – Lookup Table:

We can reverse the bits of a number in O(1) if we know the size of the number. We can implement it using
look up table. Go through the below link for details. You will find some more interesting bit related stuff
there.
http://www-graphics.stanford.edu/~seander/bithacks.html#BitReverseTable
Write a C function to detect loop in a linked list
Below diagram shows a linked list with a loop
Following are different ways of doing this

Use Hashing:
Traverse the list one by one and keep putting the node addresses in a Hash Table. At any point, if NULL is
reached then return false and if next of current node points to any of the previously stored nodes in Hash
then return true.
Mark Visited Nodes:

This solution requires modifications to basic linked list data structure. Have a visited flag with each node.
Traverse the linked list and keep marking visited nodes. If you see a visited node again then there is a loop.
This solution works in O(n) but requires additional information with each node.
A variation of this solution that doesn’t require modification to basic data structure can be implemented
using hash. Just store the addresses of visited nodes in a hash and if you see an address that already exists
in hash then there is a loop.
Floyd’s Cycle-Finding Algorithm:

This is the fastest method. Traverse linked list using two pointers. Move one pointer by one and other
pointer by two. If these pointers meet at some node then there is a loop. If pointers do not meet then linked
list doesn’t have loop.
Implementation of Floyd’s Cycle-Finding Algorithm:
#include<stdio.h>
#include<stdlib.h>

struct node
{
int data;
struct node* next;
};

{
/* allocate node */



}
int detectloop(struct node *list)

{
struct node *slow_p = list, *fast_p = list;
while(slow_p && fast_p &&

fast_p->next )
{
slow_p = slow_p->next;
fast_p = fast_p->next->next;
if (slow_p == fast_p)
{
printf("Found Loop");
return 1;
}
}
return 0;
}

int main()
{
push(&head, 20);
push(&head, 4);
push(&head, 15);
push(&head, 10);
/* Create a loop for testing */

head->next->next->next->next = head;
detectloop(head);
getchar();
}


References:
http://en.wikipedia.org/wiki/Cycle_detection
http://ostermiller.org/find_loop_singly_linked_list.html
Write a function to reverse a linked list
Iterative Method
Iterate trough the linked list. In loop, change next to prev, prev to current and current to next.
Implementation of Iterative Method
#include<stdio.h>
#include<stdlib.h>

struct node
{
int data;
struct node* next;
};
/* Function to reverse the linked list */

static void reverse(struct node** head_ref)
{
struct node* prev = NULL;
struct node* next;
{
current->next = prev;
prev = current;
current = next;
}
*head_ref = prev;
}
/* Function to push a node */

{
/* allocate node */



}
/* Function to print linked list */

{
while(temp != NULL)
{
temp = temp->next;
}
}
int main()
{

push(&head, 20);
push(&head, 4);
push(&head, 15);
push(&head, 85);

printList(head);
reverse(&head);
printf("\n Reversed Linked list \n");
printList(head);
getchar();
}


Recursive Method:
1) Divide the list in two parts - first node and rest of the linked list.
2) Call reverse for the rest of the linked list.
3) Link rest to first.
4) Fix head pointer

void recursiveReverse(struct node** head_ref)

{
struct node* first;
struct node* rest;

/* empty list */
if (*head_ref == NULL)
return;
/* suppose first = {1, 2, 3}, rest = {2, 3} */

first = *head_ref;
rest = first->next;
/* List has only one node */

if (rest == NULL)
return;
/* reverse the rest list and put the first element at the end */
recursiveReverse(&rest);
first->next->next = first;

/* tricky step -- see the diagram */
first->next = NULL;
/* fix the head pointer */

*head_ref = rest;
}


A Simpler and Tail Recursive Method

Below is C++ implementation of this method.
// A simple and tail recursive C++ program to reverse

// a linked list
#include<bits/stdc++.h>
using namespace std;
struct node
{
int data;
struct node *next;
};
void reverseUtil(node *curr, node *prev, node **head);
// This function mainly calls reverseUtil()

// with prev as NULL
void reverse(node **head)
{
if (!head)
return;
reverseUtil(*head, NULL, head);
}
// A simple and tail recursive function to reverse
// a linked list. prev is passed as NULL initially.
void reverseUtil(node *curr, node *prev, node **head)
{
/* If last node mark it head*/
if (!curr->next)
{
*head = curr;
/* Update next to prev node */

curr->next = prev;
return;
}
/* Save curr->next node for recursive call */

node *next = curr->next;
/* and update next ..*/

curr->next = prev;
reverseUtil(next, curr, head);

}
// A utility function to create a new node

node *newNode(int key)
{
node *temp = new node;
temp->data = key;
temp->next = NULL;
return temp;
}
// A utility function to print a linked list

void printlist(node *head)
{
while(head != NULL)
{
cout << head->data << " ";
head = head->next;
}
cout << endl;
}
// Driver program to test above functions

int main()
{
node *head1 = newNode(1);
head1->next = newNode(2);
head1->next->next = newNode(2);
head1->next->next->next = newNode(4);
head1->next->next->next->next = newNode(5);
head1->next->next->next->next->next = newNode(6);
head1->next->next->next->next->next->next = newNode(7);
head1->next->next->next->next->next->next->next = newNode(8);
cout << "Given linked list\n";
printlist(head1);
reverse(&head1);
cout << "\nReversed linked list\n";
printlist(head1);
return 0;
}

Output:

Given linked list
1 2 2 4 5 6 7 8
Reversed linked list

8 7 6 5 4 2 2 1

Thanks to Gaurav Ahirwar for suggesting this solution.
References:
http://cslibrary.stanford.edu/105/LinkedListProblems.pdf
If you are given two traversal sequences, can you construct the binary tree?
It depends on what traversals are given. If one of the traversal methods is Inorder then the tree can be
constructed, otherwise not.
Therefore, following combination can uniquely identify a tree.
Inorder and Preorder.

Inorder and Postorder.
Inorder and Level-order.
And following do not.

Postorder and Preorder.
Preorder and Level-order.
Postorder and Level-order.
For example, Preorder, Level-order and Postorder traversals are same for the trees given in above diagram.
Preorder Traversal = AB
Postorder Traversal = BA
Level-Order Traversal = AB
So, even if three of them (Pre, Post and Level) are given, the tree can not be constructed.
Given only a pointer to a node to be deleted in a singly linked list, how do
you delete it?
A simple solution is to traverse the linked list until you find the node you want to delete. But this solution
requires pointer to the head node which contradicts the problem statement.
Fast solution is to copy the data from the next node to the node to be deleted and delete the next node.
Something like following.

free(temp);

Program:
#include<stdio.h>
#include<assert.h>
#include<stdlib.h>

struct node
{
int data;
struct node* next;
};

of the list. */
{
/* allocate node */



}

{
while(temp != NULL)
{
temp = temp->next;
}
}
void deleteNode(struct node *node_ptr)
{
free(temp);
}

int main()
{

1->12->1->4->1 */
push(&head, 1);
push(&head, 4);
push(&head, 1);
push(&head, 12);
push(&head, 1);
printf("\n Before deleting \n");

printList(head);
/* I m deleting the head itself.

You can check for more cases */
deleteNode(head);
printf("\n After deleting \n");

printList(head);
getchar();
}

This solution doesn’t work if the node to be deleted is the last node of the list. To make this
solution work we can mark the end node as a dummy node. But the programs/functions that are using this
function should also be modified.
Try this problem for doubly linked list.

Lucky Numbers
Lucky numbers are subset of integers. Rather than going into much theory, let us see the process of arriving
at lucky numbers,
Take the set of integers

1,2,3,4,5,6,7,8,9,10,11,12,14,15,16,17,18,19,……
First, delete every second number, we get following reduced set.

1,3,5,7,9,11,13,15,17,19,…………
Now, delete every third number, we get

1, 3, 7, 9, 13, 15, 19,….….
Continue this process indefinitely……

Any number that does NOT get deleted due to above process is called “lucky”.
Therefore, set of lucky numbers is 1, 3, 7, 13,………
Now, given an integer ‘n’, write a function to say whether this number is lucky or not.
bool isLucky(int n)

Algorithm:
Before every iteration, if we calculate position of the given no, then in a given iteration, we can determine if
the no will be deleted. Suppose calculated position for the given no. is P before some iteration, and each Ith
no. is going to be removed in this iteration, if P Recursive Way:

#include <stdio.h>
#define bool int
/* Returns 1 if n is a lucky no. ohterwise returns 0*/

bool isLucky(int n)
{
static int counter = 2;
/*variable next_position is just for readability of

the program we can remove it and use n only */
int next_position = n;
if(counter > n)
return 1;
if(n%counter == 0)
return 0;
/*calculate next position of input no*/

next_position -= next_position/counter;

counter++;
return isLucky(next_position);
}
/*Driver function to test above function*/

int main()
{
int x = 5;
if( isLucky(x) )
printf("%d is a lucky no.", x);
else
printf("%d is not a lucky no.", x);
getchar();
}

Example:
Let’s us take an example of 19
1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,15,17,18,19,20,21,……
1,3,5,7,9,11,13,15,17,19,…..
1,3,7,9,13,15,19,……….
1,3,7,13,15,19,………
1,3,7,13,19,………
In next step every 6th no .in sequence will be deleted. 19 will not be deleted after this step because position of
19 is 5th after this step. Therefore, 19 is lucky. Let’s see how above C code finds out:
Current function Position after this Counter for next Next Call
call call call
isLucky(19 ) 10 3 isLucky(10)
isLucky(10) 7 4 isLucky(7)
When isLucky(6) is called, it returns 1 (because counter > n).
Iterative Way:
Please see this comment for another simple and elegant implementation of the above algorithm.
Please write comments if you find any bug in the given programs or other ways to solve the same problem.
Write a program to add two numbers in base 14
Asked by Anshya.
Below are the different ways to add base 14 numbers.
Method 1
Thanks to Raj for suggesting this method.
1. Convert both i/p base 14 numbers to base 10.

2. Add numbers.
3. Convert the result back to base 14.

Method 2
Just add the numbers in base 14 in same way we add in base 10. Add numerals of both numbers one by one
from right to left. If there is a carry while adding two numerals, consider the carry for adding next numerals.
Let us consider the presentation of base 14 numbers same as hexadecimal numbers
A --> 10
B --> 11
C --> 12
D --> 13

Example:
num1 = 1 2 A
num2 = C D 3
1. Add A and 3, we get 13(D). Since 13 is smaller than

14, carry becomes 0 and resultant numeral becomes D
2. Add 2, D and carry(0). we get 15. Since 15 is greater

than 13, carry becomes 1 and resultant numeral is 15 - 14 = 1
3. Add 1, C and carry(1). we get 14. Since 14 is greater

than 13, carry becomes 1 and resultant numeral is 14 - 14 = 0
Finally, there is a carry, so 1 is added as leftmost numeral and the result becomes
101D

Implementation of Method 2
# include <stdio.h>
# define bool int
int getNumeralValue(char );
int getNumeralValue(char );
char getNumeral(int );
/* Function to add two numbers in base 14 */

char *sumBase14(char *num1, char *num2)
{
int l1 = strlen(num1);
int l2 = strlen(num2);
char *res;
int i;
int nml1, nml2, res_nml;
bool carry = 0;

if(l1 != l2)
{
printf("Function doesn't support numbers of different"
" lengths. If you want to add such numbers then"
" prefix smaller number with required no. of zeroes");
getchar();
assert(0);
}
/* Note the size of the allocated memory is one

more than i/p lenghts for the cases where we
have carry at the last like adding D1 and A1 */
res = (char *)malloc(sizeof(char)*(l1 + 1));

/* Add all numerals from right to left */
for(i = l1-1; i >= 0; i--)
{
/* Get decimal values of the numerals of
i/p numbers*/
nml1 = getNumeralValue(num1[i]);
nml2 = getNumeralValue(num2[i]);

/* Add decimal values of numerals and carry */
res_nml = carry + nml1 + nml2;

/* Check if we have carry for next addition
of numerals */
if(res_nml >= 14)
{
carry = 1;
res_nml -= 14;
}
else
{
carry = 0;
}
res[i+1] = getNumeral(res_nml);
}

/* if there is no carry after last iteration
then result should not include 0th character
of the resultant string */
if(carry == 0)
return (res + 1);
/* if we have carry after last iteration then

result should include 0th character */
res[0] = '1';
return res;
}
/* Function to get value of a numeral
For example it returns 10 for input 'A'
1 for '1', etc */
int getNumeralValue(char num)
{
if( num >= '0' && num <= '9')
return (num - '0');
if( num >= 'A' && num <= 'D')
return (num - 'A' + 10);

/* If we reach this line caller is giving
invalid character so we assert and fail*/
assert(0);
}
/* Function to get numeral for a value.

For example it returns 'A' for input 10
'1' for 1, etc */
char getNumeral(int val)
{
if( val >= 0 && val <= 9)
return (val + '0');
if( val >= 10 && val <= 14)
return (val + 'A' - 10);

/* If we reach this line caller is giving
invalid no. so we assert and fail*/
assert(0);
}
/*Driver program to test above functions*/

int main()
{
char *num1 = "DC2";
char *num2 = "0A3";
printf("Result is %s", sumBase14(num1, num2));

getchar();
return 0;
}

Notes:
Above approach can be used to add numbers in any base. We don’t have to do string operations if base is
smaller than 10.
You can try extending the above program for numbers of different lengths.
Please comment if you find any bug in the program or a better approach to do the same.
Given a binary tree, print out all of its root-to-leaf paths one per line.
Asked by Varun Bhatia
Here is the solution.
Algorithm:
initialize: pathlen = 0, path[1000]

/*1000 is some max limit for paths, it can change*/
/*printPathsRecur traverses nodes of tree in preorder */

printPathsRecur(tree, path[], pathlen)
1) If node is not NULL then
a) push data to path array:
path[pathlen] = node->data.
b) increment pathlen
pathlen++
2) If node is a leaf node then print the path array.
3) Else
a) Call printPathsRecur for left subtree
printPathsRecur(node->left, path, pathLen)
b) Call printPathsRecur for right subtree.
printPathsRecur(node->right, path, pathLen)

Example:
Example Tree
Output for the above example will be
1 2 4
1 2 5
1 3

Implementation:
/*program to print all of its root-to-leaf paths for a tree*/

#include <stdio.h>
#include <stdlib.h>

struct node
{
int data;
struct node* left;
struct node* right;
};
void printArray(int [], int);

void printPathsRecur(struct node*, int [], int);
struct node* newNode(int );
void printPaths(struct node*);
/* Given a binary tree, print out all of its root-to-leaf

paths, one per line. Uses a recursive helper to do the work.*/
void printPaths(struct node* node)
{
int path[1000];
printPathsRecur(node, path, 0);
}
/* Recursive helper function -- given a node, and an array containing

the path from the root node up to but not including this node,
print out all the root-leaf paths. */
void printPathsRecur(struct node* node, int path[], int pathLen)
{
if (node==NULL) return;
/* append this node to the path array */

path[pathLen] = node->data;
pathLen++;
/* it's a leaf, so print the path that led to here */

if (node->left==NULL && node->right==NULL)
{
printArray(path, pathLen);
}
else
{
/* otherwise try both subtrees */
printPathsRecur(node->left, path, pathLen);
printPathsRecur(node->right, path, pathLen);
}
}

{
node->data = data;
node->left = NULL;
node->right = NULL;
return(node);
}
/* Utility that prints out an array on a line */

void printArray(int ints[], int len)
{
int i;
for (i=0; i<len; i++) {
printf("%d ", ints[i]);
}
}
printf("\n");
}

int main()
{
/* Print all root-to-leaf paths of the input tree */

printPaths(root);
getchar();
return 0;
}

References:
Lowest Common Ancestor in a Binary Search Tree.
Given values of two nodes in a Binary Search Tree, write a c program to find the Lowest Common Ancestor
(LCA). You may assume that both the values exist in the tree.
The function prototype should be as follows:
struct node *lca(node* root, int n1, int n2)

n1 and n2 are two given values in the tree with given root.

For example, consider the BST in diagram, LCA of 10 and 14 is 12 and LCA of 8 and 14 is 8.
Following is definition of LCA from Wikipedia:

Let T be a rooted tree. The lowest common ancestor between two nodes n1 and n2 is defined as the lowest
node in T that has both n1 and n2 as descendants (where we allow a node to be a descendant of itself).
The LCA of n1 and n2 in T is the shared ancestor of n1 and n2 that is located farthest from the root.
Computation of lowest common ancestors may be useful, for instance, as part of a procedure for determining
the distance between pairs of nodes in a tree: the distance from n1 to n2 can be computed as the distance
from the root to n1, plus the distance from the root to n2, minus twice the distance from the root to their
lowest common ancestor. (Source Wiki)
Solutions:
If we are given a BST where every node has parent pointer, then LCA can be easily determined by
traversing up using parent pointer and printing the first intersecting node.
We can solve this problem using BST properties. We can recursively traverse the BST from root. The
main idea of the solution is, while traversing from top to bottom, the first node n we encounter with value
between n1 and n2, i.e., n1 // A recursive C program to find LCA of two nodes n1 and n2. #include <stdio.h>
#include <stdlib.h> struct node { int data; struct node* left, *right; }; /* Function to find LCA of n1 and n2.
The function assumes that both n1 and n2 are present in BST */ struct node *lca(struct node* root, int n1,
int n2) { if (root == NULL) return NULL; // If both n1 and n2 are smaller than root, then LCA lies in left if
(root->data > n1 && root->data > n2) return lca(root->left, n1, n2); // If both n1 and n2 are greater than
root, then LCA lies in right if (root->data < n1 && root->data < n2) return lca(root->right, n1, n2); return
root; } /* Helper function that allocates a new node with the given data.*/ struct node* newNode(int data) {
struct node* node = (struct node*)malloc(sizeof(struct node)); node->data = data; node->left = node->right
= NULL; return(node); } /* Driver program to test mirror() */ int main() { // Let us construct the BST
shown in the above figure struct node *root = newNode(20); root->left = newNode(8); root->right =
newNode(22); root->left->left = newNode(4); root->left->right = newNode(12); root->left->right->left =
newNode(10); root->left->right->right = newNode(14); int n1 = 10, n2 = 14; struct node *t = lca(root, n1,
n2); printf("LCA of %d and %d is %d \n", n1, n2, t->data); n1 = 14, n2 = 8; t = lca(root, n1, n2); printf("LCA
of %d and %d is %d \n", n1, n2, t->data); n1 = 10, n2 = 22; t = lca(root, n1, n2); printf("LCA of %d and %d is
%d \n", n1, n2, t->data); getchar(); return 0; }
Output:
LCA of 10 and 14 is 12

Time complexity of above solution is O(h) where h is height of tree. Also, the above solution requires O(h)
extra space in function call stack for recursive function calls. We can avoid extra space using iterative
solution.
/* Function to find LCA of n1 and n2. The function assumes that both
n1 and n2 are present in BST */
struct node *lca(struct node* root, int n1, int n2)
{
while (root != NULL)
{
// If both n1 and n2 are smaller than root, then LCA lies in left
if (root->data > n1 && root->data > n2)
root = root->left;
// If both n1 and n2 are greater than root, then LCA lies in right
else if (root->data < n1 && root->data < n2)
root = root->right;
else break;
}
return root;
}

See this for complete program.
You may like to see Lowest Common Ancestor in a Binary Tree also.
Exercise
The above functions assume that n1 and n2 both are in BST. If n1 and n2 are not present, then they may
return incorrect result. Extend the above solutions to return NULL if n1 or n2 or both not present in BST.
discussed above.
Function to check if a singly linked list is palindrome
Given a singly linked list of characters, write a function that returns true if the given list is palindrome, else
false.
METHOD 1 (Use a Stack)

A simple solution is to use a stack of list nodes. This mainly involves three steps.
1) Traverse the given list from head to tail and push every visited node to stack.
2) Traverse the list again. For every visited node, pop a node from stack and compare data of popped node
with currently visited node.
3) If all nodes matched, then return true, else false.
Time complexity of above method is O(n), but it requires O(n) extra space. Following methods solve this
with constant extra space.
METHOD 2 (By reversing the list)

This method takes O(n) time and O(1) extra space.
1) Get the middle of the linked list.
2) Reverse the second half of the linked list.
3) Check if the first half and second half are identical.
4) Construct the original linked list by reversing the second half again and attaching it back to the first half
To divide the list in two halves, method 2 of this post is used.

When number of nodes are even, the first and second half contain exactly half nodes. The challenging thing
in this method is to handle the case when number of nodes are odd. We don’t want the middle node as part
of any of the lists as we are going to compare them for equality. For odd case, we use a separate variable
‘midnode’.
/* Program to check if a linked list is palindrome */

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>

struct node
{
char data;
struct node* next;
};
void reverse(struct node**);

bool compareLists(struct node*, struct node *);
/* Function to check if given linked list is

palindrome or not */
bool isPalindrome(struct node *head)
{
{
struct node *slow_ptr = head, *fast_ptr = head;
struct node *second_half, *prev_of_slow_ptr = head;
struct node *midnode = NULL; // To handle odd size list
bool res = true; // initialize result
if (head!=NULL && head->next!=NULL)

{
/* Get the middle of the list. Move slow_ptr by 1
and fast_ptrr by 2, slow_ptr will have the middle
node */
while (fast_ptr != NULL && fast_ptr->next != NULL)
{
/*We need previous of the slow_ptr for

linked lists with odd elements */
prev_of_slow_ptr = slow_ptr;
}
/* fast_ptr would become NULL when there are even elements in list.
And not NULL for odd elements. We need to skip the middle node
for odd case and store it somewhere so that we can restore the
original list*/
if (fast_ptr != NULL)
{
midnode = slow_ptr;
}
// Now reverse the second half and compare it with first half
second_half = slow_ptr;
prev_of_slow_ptr->next = NULL; // NULL terminate first half
reverse(&second_half); // Reverse the second half
res = compareLists(head, second_half); // compare
/* Construct the original list back */

reverse(&second_half); // Reverse the second half again
if (midnode != NULL) // If there was a mid node (odd size case) which
// was not part of either first half or second half.

{
prev_of_slow_ptr->next = midnode;
midnode->next = second_half;
}
else prev_of_slow_ptr->next = second_half;
}
return res;
}
/* Function to reverse the linked list Note that this

function may change the head */
void reverse(struct node** head_ref)
{
struct node* next;
{
prev = current;
current = next;
current = next;
}
*head_ref = prev;
}
/* Function to check if two input lists have same data*/

bool compareLists(struct node* head1, struct node *head2)
{
struct node* temp1 = head1;
struct node* temp2 = head2;
while (temp1 && temp2)

{
if (temp1->data == temp2->data)
{
temp1 = temp1->next;
temp2 = temp2->next;
}
else return 0;
}
/* Both are empty reurn 1*/

if (temp1 == NULL && temp2 == NULL)
return 1;
/* Will reach here when one is NULL

and other is not */
return 0;
}
/* Push a node to linked list. Note that this function

changes the head */
void push(struct node** head_ref, char new_data)
{
/* allocate node */


/* move the head to pochar to the new node */

}

{
while (ptr != NULL)
{
printf("%c->", ptr->data);
ptr = ptr->next;
}
printf("NULL\n");
}

int main()
{
char str[] = "abacaba";
int i;
for (i = 0; str[i] != '\0'; i++)

{
push(&head, str[i]);
printList(head);
isPalindrome(head)? printf("Is Palindrome\n\n"):
printf("Not Palindrome\n\n");
}
return 0;
}

Output:

a->NULL
Palindrome
b->a->NULL
Not Palindrome
a->b->a->NULL
Is Palindrome
c->a->b->a->NULL
Not Palindrome
a->c->a->b->a->NULL
Not Palindrome
b->a->c->a->b->a->NULL
Not Palindrome
a->b->a->c->a->b->a->NULL
Is Palindrome

Time Complexity O(n)

METHOD 3 (Using Recursion)

Use two pointers left and right. Move right and left using recursion and check for following in each recursive
call.
1) Sub-list is palindrome.
2) Value at current left and right are matching.
If both above conditions are true then return true.
The idea is to use function call stack as container. Recursively traverse till the end of list. When we return
from last NULL, we will be at last node. The last node to be compared with first node of list.
In order to access first node of list, we need list head to be available in the last call of recursion. Hence we
pass head also to the recursive function. If they both match we need to compare (2, n-2) nodes. Again when
recursion falls back to (n-2)nd node, we need reference to 2nd node from head. We advance the head pointer
in previous call, to refer to next node in the list.
However, the trick in identifying double pointer. Passing single pointer is as good as pass-by-value, and we
will pass the same pointer again and again. We need to pass the address of head pointer for reflecting the
changes in parent recursive calls.
Thanks to Sharad Chandra for suggesting this approach.
// Recursive program to check if a given linked list is palindrome

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

struct node
{
char data;
struct node* next;
};
// Initial parameters to this function are &head and head

bool isPalindromeUtil(struct node **left, struct node *right)
{
/* stop recursion when right becomes NULL */
if (right == NULL)
return true;
/* If sub-list is not palindrome then no need to

check for current left and right, return false */
bool isp = isPalindromeUtil(left, right->next);
if (isp == false)
return false;
/* Check values at current left and right */

bool isp1 = (right->data == (*left)->data);
/* Move left to next node */

*left = (*left)->next;
return isp1;
}
// A wrapper over isPalindromeUtil()

bool isPalindrome(struct node *head)
{
isPalindromeUtil(&head, head);
}

changes the head */
{
/* allocate node */


}

{
while (ptr != NULL)
{
printf("%c->", ptr->data);
ptr = ptr->next;
}
printf("NULL\n");
}

int main()
{
char str[] = "abacaba";
int i;
for (i = 0; str[i] != '\0'; i++)

{
push(&head, str[i]);
printList(head);
isPalindrome(head)? printf("Is Palindrome\n\n"):
printf("Not Palindrome\n\n");
}
return 0;
}

Output:

a->NULL
Not Palindrome
b->a->NULL
Not Palindrome
a->b->a->NULL
Is Palindrome
c->a->b->a->NULL
Not Palindrome
a->c->a->b->a->NULL
Not Palindrome
b->a->c->a->b->a->NULL
Not Palindrome
a->b->a->c->a->b->a->NULL
Is Palindrome

Auxiliary Space: O(n) if Function Call Stack size is considered, otherwise O(1).
Please comment if you find any bug in the programs/algorithms or a better way to do the same.
Search an element in a sorted and pivoted array
Question:
An element in a sorted array can be found in O(log n) time via binary search. But suppose I rotate the sorted
array at some pivot unknown to you beforehand. So for instance, 1 2 3 4 5 might become 3 4 5 1 2. Devise a
way to find an element in the rotated array in O(log n) time.
Solution:
Thanks to Ajay Mishra for initial solution.
Algorithm:
Find the pivot point, divide the array in two sub-arrays and call binary search.
The main idea for finding pivot is – for a sorted (in increasing order) and pivoted array, pivot element is the
only only element for which next element to it is smaller than it.
Using above criteria and binary search methodology we can get pivot element in O(logn) time
Input arr[] = {3, 4, 5, 1, 2}

Element to Search = 1
1) Find out pivot point and divide the array in two
sub-arrays. (pivot = 2) /*Index of 5*/
2) Now call binary search for one of the two sub-arrays.
(a) If element is greater than 0th element then
search in left array
(b) Else Search in right array
(1 will go in else as 1 If element is found in selected sub-array then return i
ndex
Else return -1.

Implementation:
/* Program to search an element in a sorted and pivoted array*/

#include <stdio.h>
int findPivot(int[], int, int);

int binarySearch(int[], int, int, int);
/* Searches an element no in a pivoted sorted array arrp[]

of size arr_size */
int pivotedBinarySearch(int arr[], int arr_size, int no)
{
int pivot = findPivot(arr, 0, arr_size-1);
// If we didn't find a pivot, then array is not rotated at all

if (pivot == -1)
return binarySearch(arr, 0, arr_size-1, no);
// If we found a pivot, then first compare with pivot and then

// If we found a pivot, then first compare with pivot and then
// search in two subarrays around pivot
if (arr[pivot] == no)
return pivot;
if (arr[0] <= no)
return binarySearch(arr, 0, pivot-1, no);
else
return binarySearch(arr, pivot+1, arr_size-1, no);
}
/* Function to get pivot. For array 3, 4, 5, 6, 1, 2 it will

return 3. If array is not rotated at all, then it returns -1 */
int findPivot(int arr[], int low, int high)
{
// base cases
if (high < low) return -1;
if (high == low) return low;
int mid = (low + high)/2; /*low + (high - low)/2;*/

if (mid < high && arr[mid] > arr[mid + 1])
return mid;
if (mid > low && arr[mid] < arr[mid - 1])
return (mid-1);
if (arr[low] >= arr[mid])
return findPivot(arr, low, mid-1);
else
return findPivot(arr, mid + 1, high);
}
/* Standard Binary Search function*/

int binarySearch(int arr[], int low, int high, int no)
{
if (high < low)
return -1;
if (no == arr[mid])
return mid;
if (no > arr[mid])
return binarySearch(arr, (mid + 1), high, no);
else
return binarySearch(arr, low, (mid -1), no);
}
/* Driver program to check above functions */

int main()
{
// Let us search 3 in below array
int arr1[] = {5, 6, 7, 8, 9, 10, 1, 2, 3};
int arr_size = sizeof(arr1)/sizeof(arr1[0]);
int no = 3;
printf("Index of the element is %d\n", pivotedBinarySearch(arr1, arr_size, no));

int arr2[] = {3, 4, 5, 1, 2};
arr_size = sizeof(arr2)/sizeof(arr2[0]);
// Let us search for 4 in above array

no = 4;

int arr3[] = {1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1};
no = 0;

int arr4[] = {2, 3, 0, 2, 2, 2, 2, 2, 2, 2};
no = 3;
// Let us search 2 in above array

no = 2;

int arr5[] = {1, 2, 3, 4};
no = 3;
return 0;
}

Output:

Index of the element is 8

Please note that the solution may not work for cases where the input array has duplicates.
Time Complexity O(logn)
problem.
The Great Tree-List Recursion Problem.
Asked by Varun Bhatia.
Question:
Write a recursive function treeToList(Node root) that takes an ordered binary tree and rearranges the
internal pointers to make a circular doubly linked list out of the tree nodes. The”previous” pointers should be
stored in the “small” field and the “next” pointers should be stored in the “large” field. The list should be
arranged so that the nodes are in increasing order. Return the head pointer to the new list.
This is very well explained and implemented at http://cslibrary.stanford.edu/109/TreeListRecursion.html

Count set bits in an integer
Write an efficient program to count number of 1s in binary representation of an integer.
1. Simple Method Loop through all bits in an integer, check if a bit is set and if it is then increment the set
bit count. See below program.
/* Function to get no of set bits in binary

representation of passed binary no. */
int countSetBits(unsigned int n)
{
unsigned int count = 0;
while(n)
{
count += n & 1;
n >>= 1;
}
return count;
}
/* Program to test function countSetBits */

int main()
{
int i = 9;
printf("%d", countSetBits(i));
getchar();
return 0;
}

Time Complexity: (-)(logn) (Theta of logn)
2. Brian Kernighan’s Algorithm:

Subtraction of 1 from a number toggles all the bits (from right to left) till the rightmost set bit(including the
righmost set bit). So if we subtract a number by 1 and do bitwise & with itself (n & (n-1)), we unset the
righmost set bit. If we do n & (n-1) in a loop and count the no of times loop executes we get the set bit count.
Beauty of the this solution is number of times it loops is equal to the number of set bits in a given integer.

1 Initialize count: = 0
2 If integer n is not zero
(a) Do bitwise & with (n-1) and assign the value back to n
n: = n&(n-1)
(b) Increment count by 1
(c) go to step 2
3 Else return count

Implementation of Brian Kernighan’s Algorithm:

#include<stdio.h>
/* Function to get no of set bits in binary

representation of passed binary no. */
int countSetBits(int n)
{
unsigned int count = 0;
while (n)
{
n &= (n-1) ;
count++;
}
return count;
}
/* Program to test function countSetBits */

int main()
{
int i = 9;
printf("%d", countSetBits(i));
getchar();
return 0;
}

Example for Brian Kernighan’s Algorithm:
n = 9 (1001)
count = 0
Since 9 > 0, subtract by 1 and do bitwise & with (9-1)

n = 9&8 (1001 & 1000)
n = 8
count = 1
Since 8 > 0, subtract by 1 and do bitwise & with (8-1)

n = 8&7 (1000 & 0111)
n = 0
count = 2
Since n = 0, return count which is 2 now.

3. Using Lookup table: We can count bits in O(1) time using lookup table. Please see
http://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetTable for details.
You can find one use of counting set bits at http://geeksforgeeks.org/?p=1465

References:
http://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetNaive
Memory efficient doubly linked list
Asked by Varun Bhatia.
Question:
Write a code for implementation of doubly linked list with use of single pointer in each node.
Solution:
This question is solved and very well explained at http://www.linuxjournal.com/article/6828.
We also recommend to read http://en.wikipedia.org/wiki/XOR_linked_list

Clone a linked list with next and random pointer | Set 1
You are given a Double Link List with one pointer of each node pointing to the next node just like in a single
link list. The second pointer however CAN point to any node in the list and not just the previous node. Now
write a program in O(n) time to duplicate this list. That is, write a program which will create a copy of this
list.
Let us call the second pointer as arbit pointer as it can point to any arbitrary node in the linked list.
Arbitrary pointers are shown in red and next pointers in black
Figure 1
Method 1 (Uses O(n) extra space)

This method stores the next and arbitrary mappings (of original list) in an array first, then modifies the
original Linked List (to create copy), creates a copy. And finally restores the original list.
1) Create all nodes in copy linked list using next pointers.

3) Store the node and its next pointer mappings of original linked list.
3) Change next pointer of all nodes in original linked list to point to the corresponding node in copy linked
list.
Following diagram shows status of both Linked Lists after above 3 steps. The red arrow shows arbit pointers
and black arrow shows next pointers.
Figure 2
4) Change the arbit pointer of all nodes in copy linked list to point to corresponding node in original linked
list.
5) Now construct the arbit pointer in copy linked list as below and restore the next pointer of nodes in the
original linked list.

copy_list_node->arbit =
copy_list_node->arbit->arbit->next;
copy_list_node = copy_list_node->next;

6) Restore the next pointers in original linked list from the stored mappings(in step 2).

Method 2 (Uses Constant Extra Space)

Thanks to Saravanan Mani for providing this solution. This solution works using constant space.
1) Create the copy of node 1 and insert it between node 1 & node 2 in original Linked List, create the copy of 2
and insert it between 2 & 3.. Continue in this fashion, add the copy of N afte the Nth node
2) Now copy the arbitrary link in this fashion
original->next->arbitrary = original->arbitrary->next; /*TRAVERSE

TWO NODES*/

This works because original->next is nothing but copy of original and Original->arbitrary->next is nothing
but copy of arbitrary.
3) Now restore the original and copy linked lists in this fashion in a single loop.
original->next = original->next->next;
copy->next = copy->next->next;

4) Make sure that last element of original->next is NULL.

Refer Following Post for Hashing based Implementation.

Asked by Varun Bhatia. Please write comments if you find anything incorrect, or you want to share more
information about the topic discussed above.
Find the node with minimum value in a Binary Search Tree
This is quite simple. Just traverse the node from root to left recursively until left is NULL. The node whose
left is NULL is the node with minimum value.
For the above tree, we start with 20, then we move left 8, we keep on moving to left until we see NULL. Since
left of 4 is NULL, 4 is the node with minimum value.
#include <stdio.h>
#include<stdlib.h>

struct node
{
int data;
struct node* left;
struct node* right;
};
/* Helper function that allocates a new node

with the given data and NULL left and right
pointers. */
{
node->data = data;
node->left = NULL;
node->right = NULL;

return(node);
}
/* Give a binary search tree and a number,

inserts a new node with the given number in
the correct place in the tree. Returns the new
root pointer which the caller should then use
(the standard trick to avoid using reference
parameters). */
struct node* insert(struct node* node, int data)
{
/* 1. If the tree is empty, return a new,
single node */
if (node == NULL)
return(newNode(data));
else
else
{
/* 2. Otherwise, recur down the tree */
if (data <= node->data)
node->left = insert(node->left, data);
else
node->right = insert(node->right, data);

/* return the (unchanged) node pointer */
return node;
}
}
/* Given a non-empty binary search tree,

return the minimum data value found in that
tree. Note that the entire tree does not need
to be searched. */
int minValue(struct node* node) {
struct node* current = node;
/* loop down to find the leftmost leaf */

while (current->left != NULL) {
current = current->left;
}
}
/* Driver program to test sameTree function*/

int main()
{
struct node* root = NULL;
root = insert(root, 4);
insert(root, 2);
insert(root, 1);
insert(root, 3);
insert(root, 6);
insert(root, 5);
printf("\n Minimum value in BST is %d", minValue(root));

getchar();
return 0;
}

Time Complexity: O(n) Worst case happens for left skewed trees.
Similarly we can get the maximum value by recursively traversing the right node of a binary search tree.
References:
Count number of bits to be flipped to convert A to B
Suggested by Dheeraj
Question: You are given two numbers A and B. Write a program to count number of bits needed to be
flipped to convert A to B.
Solution:
1. Calculate XOR of A and B.

a_xor_b = A ^ B
2. Count the set bits in the above calculated XOR result.
countSetBits(a_xor_b)

XOR of two number will have set bits only at those places where A differs from B.
Example:
A = 1001001
B = 0010101
a_xor_b = 1011100
No of bits need to flipped = set bit count in a_xor_b i.e. 4

To get the set bit count please see another post on this portal http://geeksforgeeks.org/?p=1176
Merge an array of size n into another array of size m+n
Asked by Binod
Question:
There are two sorted arrays. First one is of size m+n containing only m elements. Another one is of size n
and contains n elements. Merge these two arrays into the first array of size m+n such that the output is
sorted.
Input: array with m+n elements (mPlusN[]).
NA => Value is not filled/available in array mPlusN[]. There should be n such array blocks.
Input: array with n elements (N[]).
Output: N[] merged into mPlusN[] (Modified mPlusN[])
Algorithm:
Let first array be mPlusN[] and other array be N[]

1) Move m elements of mPlusN[] to end.
2) Start from nth element of mPlusN[] and 0th element of N[] and merge them
into mPlusN[].

Implementation:
#include <stdio.h>
/* Assuming -1 is filled for the places where element

is not available */
#define NA -1
/* Function to move m elements at the end of array mPlusN[] */

void moveToEnd(int mPlusN[], int size)
{
int i = 0, j = size - 1;
for (i = size-1; i >= 0; i--)
if (mPlusN[i] != NA)
{
mPlusN[j] = mPlusN[i];
j--;
}
}
/* Merges array N[] of size n into array mPlusN[]

of size m+n*/
of size m+n*/
int merge(int mPlusN[], int N[], int m, int n)
{
int i = n; /* Current index of i/p part of mPlusN[]*/
int j = 0; /* Current index of N[]*/
int k = 0; /* Current index of of output mPlusN[]*/
while (k < (m+n))
{
/* Take an element from mPlusN[] if
a) value of the picked element is smaller and we have
not reached end of it
b) We have reached end of N[] */
if ((i < (m+n) && mPlusN[i] <= N[j]) || (j == n))
{
mPlusN[k] = mPlusN[i];
k++;
i++;
}
else // Otherwise take emenet from N[]
{
mPlusN[k] = N[j];
k++;
j++;
}
}
}

void printArray(int arr[], int size)
{
int i;
for (i=0; i < size; i++)
printf("%d ", arr[i]);
printf("\n");
}

int main()
{
/* Initialize arrays */
int mPlusN[] = {2, 8, NA, NA, NA, 13, NA, 15, 20};
int N[] = {5, 7, 9, 25};
int n = sizeof(N)/sizeof(N[0]);
int m = sizeof(mPlusN)/sizeof(mPlusN[0]) - n;
/*Move the m elements at the end of mPlusN*/

moveToEnd(mPlusN, m+n);
/*Merge N[] into mPlusN[] */

merge(mPlusN, N, m, n);
/* Print the resultant mPlusN */

printArray(mPlusN, m+n);
return 0;
}

Output:

2 5 7 8 9 13 15 20 25

Time Complexity: O(m+n)
Please write comment if you find any bug in the above program or a better way to solve the same problem.
Divide a string in N equal parts
Difficulty Level: Rookie
Question:
Write a program to print N equal parts of a given string.
Solution:
1) Get the size of the string using string function strlen() (present in string.h)
2) Get size of a part.

part_size = string_length/n

3) Loop through the input string. In loop, if index becomes multiple of part_size then put a part
separator(“\n”)
Implementation:

#include<stdio.h>
#include<string.h>
/* Function to print n equal parts of str*/

void divideString(char *str, int n)
{
int str_size = strlen(str);
int i;
int part_size;
/*Check if string can be divided in n equal parts */

if(str_size%n != 0)
{
printf("Invalid Input: String size is not divisible by n");
return;
}
/* Calculate the size of parts to find the division points*/

part_size = str_size/n;
for(i = 0; i< str_size; i++)
{
if(i%part_size == 0)
printf("\n"); /* newline separator for different parts */
printf("%c", str[i]);
}
}
int main()
{
/*length od string is 28*/
char *str = "a_simple_divide_string_quest";
/*Print 4 equal parts of the string */

divideString(str, 4);
getchar();
return 0;
}

In above solution, we are simply printing the N equal parts of the string. If we want individual parts to be
stored then we need to allocate part_size + 1 memory for all N parts (1 extra for string termination character
‘\0′), and store the addresses of the parts in an array of character pointers.
Asked by Jason.
Question 1
int main()
{
int i = 0;
while (i <= 4)
{
printf("%d", i);
if (i > 3)
goto inside_foo;
i++;
}
getchar();
return 0;
}
void foo()
{
inside_foo:
printf("PP");
}

Output: Compiler error: Label “inside_foo” used but not defined.
Explanation: Scope of a label is within a function. We cannot goto a label from other function.
Question 2
#define a 10
int main()
{
#define a 50
printf("%d",a);

getchar();
return 0;
}

Output: 50
Preprocessor doesn’t give any error if we redefine a preprocessor directive. It may give warning though.
Preprocessor takes the most recent value before use of and put it in place of a.
Now try following

#define a 10
int main()
{
printf("%d ",a);
#define a 50
printf("%d ",a);

getchar();
return 0;
}

Question 3
int main()
{
char *s1 = str, *s2 = str;
int i;

for(i = 0; i < 7; i++)
{
printf(" %c ", *str);
++s1;
}

for(i = 0; i < 6; i++)
{
printf(" %c ", *s2);
++s2;
}

getchar();
return 0;
}

Output
g g g g g g g g e e k s f
Explanation
Both s1 and s2 are initialized to str. In first loop str is being printed and s1 is being incremented, so first loop
will print only g. In second loop s2 is incremented and s2 is printed so second loop will print “g e e k s f ”
Question 4

int main()
{
int i;
for(i=0; str[i]; i++)
printf("\n%c%c%c%c", str[i], *(str+i), *(i+str), i[str]);

getchar();
return 0;
}

Output:
gggg
eeee
eeee
kkkk
ssss
ffff
oooo
rrrr
gggg
eeee
eeee
kkkk
ssss
Explanaition:
Following are different ways of indexing both array and string.
arr[i]
*(arr + i)
*(i + arr)
i[arr]
So all of them print same character.
Question 5
int main()
{
char *p;
printf("%d %d ", sizeof(*p), sizeof(p));

getchar();
return 0;
}

Output: Compiler dependent. I got output as “1 4″
Explanation:
Output of the above program depends on compiler. sizeof(*p) gives size of character. If characters are stored
as 1 byte then sizeof(*p) gives 1.
sizeof(p) gives the size of pointer variable. If pointer variables are stored as 4 bytes then it gives 4.
Given a string, find its first non-repeating character
Given a string, find the first non-repeating character in it. For example, if the input string is
“GeeksforGeeks”, then output should be ‘f’ and if input string is “GeeksQuiz”, then output should be ‘G’.
We can use string characters as index and build a count array. Following is the algorithm.
1) Scan the string from left to right and construct the count array.
2) Again, scan the string from left to right and check for count of each
character, if you find an element who's count is 1, return it.

Example:
Input string: str = geeksforgeeks

....
count['e'] = 4
count['f'] = 1
count['g'] = 2
count['k'] = 2
……
2: Get the first character who's count is 1 ('f').
Implementation:

#include<stdlib.h>
#include<stdio.h>

{
int *count = (int *)calloc(sizeof(int), NO_OF_CHARS);
int i;
for (i = 0; *(str+i); i++)
count[*(str+i)]++;
return count;
}
/* The function returns index of first non-repeating

character in a string. If all characters are repeating
then returns -1 */
int firstNonRepeating(char *str)
{
int *count = getCharCountArray(str);
int index = -1, i;
for (i = 0; *(str+i); i++)

{
if (count[*(str+i)] == 1)
{
index = i;
break;
}
}

free(count); // To avoid memory leak
return index;
}

int main()
{
int index = firstNonRepeating(str);
if (index == -1)
printf("Either all characters are repeating or string is empty");
else
printf("First non-repeating character is %c", str[index]);
getchar();
return 0;
}

Output:

First non-repeating character is f

Can we do it by traversing the string only once?

The above approach takes O(n) time, but in practice it can be improved. The first part of the algorithm runs
through the string to construct the count array (in O(n) time). This is reasonable. But the second part about
running through the string again just to find the first non-repeater is not good in practice. In real situations,
your string is expected to be much larger than your alphabet. Take DNA sequences for example: they could
be millions of letters long with an alphabet of just 4 letters. What happens if the non-repeater is at the end of
the string? Then we would have to scan for a long time (again).
We can augment the count array by storing not just counts but also the index of the first time you
encountered the character e.g. (3, 26) for ‘a’ meaning that ‘a’ got counted 3 times and the first time it was
seen is at position 26. So when it comes to finding the first non-repeater, we just have to scan the count
array, instead of the string. Thanks to Ben for suggesting this approach.
Following is C implementation of the extended approach that traverses the input string only once.
#include <stdlib.h>
#include <stdio.h>
#include <limits.h>
// Structure to store count of a character and index of the first

// occurrence in the input string
struct countIndex {
int count;
int index;
};
/* Returns an array of above structure type. The size of

array is NO_OF_CHARS */
struct countIndex *getCharCountArray(char *str)
{
struct countIndex *count =
(struct countIndex *)calloc(sizeof(countIndex), NO_OF_CHARS);
int i;
for (i = 0; *(str+i); i++)
{
(count[*(str+i)].count)++;
// If it's first occurrence, then store the index

if (count[*(str+i)].count == 1)
count[*(str+i)].index = i;
}
return count;
}
/* The function returns index of the first non-repeating

character in a string. If all characters are repeating
then reurns INT_MAX */
int firstNonRepeating(char *str)
{
struct countIndex *count = getCharCountArray(str);
int result = INT_MAX, i;

{
// If this character occurs only once and appears
// before the current result, then update the result
if (count[i].count == 1 && result > count[i].index)
result = count[i].index;
}
free(count); // To avoid memory leak

return result;
return result;
}

int main()
{
int index = firstNonRepeating(str);
if (index == INT_MAX)
printf("Either all characters are repeating or string is empty");
else
printf("First non-repeating character is %c", str[index]);
getchar();
return 0;
}

Output:

First non-repeating character is f

discussed above.
Given a linked list which is sorted, how will you insert in sorted way
Algorithm:
Let input linked list is sorted in increasing order.
1) If Linked list is empty then make the node as head and return it.
2) If value of the node to be inserted is smaller than value of head node
then insert the node at start and make it head.
3) In a loop, find the appropriate node after which the input node (let 9) is
to be inserted. To find the appropriate node start from head, keep moving
until you reach a node GN (10 in the below diagram) who's value is
greater than the input node. The node just before GN is the appropriate
node (7).
4) Insert the node (9) after the appropriate node (7) found in step 3.

Initial Linked List
Linked List after insertion of 9
Implementation:
/* Program to insert in a sorted list */

#include<stdio.h>
#include<stdlib.h>

struct node
{
int data;
struct node* next;
};
/* function to insert a new_node in a list. Note that this

function expects a pointer to head_ref as this can modify the
head of the input linked list (similar to push())*/
void sortedInsert(struct node** head_ref, struct node* new_node)
{
struct node* current;
/* Special case for the head end */
if (*head_ref == NULL || (*head_ref)->data >= new_node->data)
{
new_node->next = *head_ref;
*head_ref = new_node;
}
else
{
/* Locate the node before the point of insertion */
current = *head_ref;
while (current->next!=NULL &&
current->next->data < new_node->data)
{
}
new_node->next = current->next;
current->next = new_node;
}
}
/* BELOW FUNCTIONS ARE JUST UTILITY TO TEST sortedInsert */
/* A utility function to create a new node */

struct node *newNode(int new_data)
{
/* allocate node */

new_node->next = NULL;
return new_node;
}

{
while(temp != NULL)
{
temp = temp->next;
}
}

int main()
{
struct node *new_node = newNode(5);
sortedInsert(&head, new_node);
new_node = newNode(10);
printf("\n Created Linked List\n");
printList(head);
getchar();
return 0;
}

Shorter Implementation using double pointers

Thanks to Murat M Ozturk for providing this solution. Please see Murat M Ozturk’s comment below for
complete function. The code uses double pointer to keep track of the next pointer of the previous node (after
which new node is being inserted).
Note that below line in code changes current to have address of next pointer in a node.
current = &((*current)->next);

Also, note below comments.
new_node->next = *current; /* Copies the value-at-address current to new_node's next

pointer*/
*current = new_node; /* Fix next pointer of the node (using it's address) after
which new_node is being inserted */

References:
Median of two sorted arrays
Question: There are 2 sorted arrays A and B of size n each. Write an algorithm to find the median of the
array obtained after merging the above 2 arrays(i.e. array of length 2n). The complexity should be O(log(n))
Median: In probability theory and statistics, a median is described as the number separating the higher half
of a sample, a population, or a probability distribution, from the lower half.
The median of a finite list of numbers can be found by arranging all the numbers from lowest value to
highest value and picking the middle one.
For getting the median of input array { 12, 11, 15, 10, 20 }, first sort the array. We get { 10, 11, 12, 15, 20 }
after sorting. Median is the middle element of the sorted array which is 12.
There are different conventions to take median of an array with even number of elements, one can take the
mean of the two middle values, or first middle value, or second middle value.
Let us see different methods to get the median of two sorted arrays of size n each. Since size of the set for
which we are looking for median is even (2n), we are taking average of middle two numbers in all below
solutions.
Method 1 (Simply count while Merging)

Use merge procedure of merge sort. Keep track of count while comparing elements of two arrays. If count
becomes n(For 2n elements), we have reached the median. Take the average of the elements at indexes n-1
and n in the merged array. See the below implementation.
Implementation:
#include <stdio.h>
/* This function returns median of ar1[] and ar2[].

Assumptions in this function:
Both ar1[] and ar2[] are sorted arrays
Both have n elements */
int getMedian(int ar1[], int ar2[], int n)
{
int i = 0; /* Current index of i/p array ar1[] */
int j = 0; /* Current index of i/p array ar2[] */
int count;
int m1 = -1, m2 = -1;
/* Since there are 2n elements, median will be average

of elements at index n-1 and n in the array obtained after
merging ar1 and ar2 */
for (count = 0; count <= n; count++)
{
/*Below is to handle case where all elements of ar1[] are
smaller than smallest(or first) element of ar2[]*/
if (i == n)
{
m1 = m2;
m2 = ar2[0];
break;
}
/*Below is to handle case where all elements of ar2[] are

smaller than smallest(or first) element of ar1[]*/
else if (j == n)
{
m1 = m2;
m1 = m2;
m2 = ar1[0];
break;
}
if (ar1[i] < ar2[j])

{
m1 = m2; /* Store the prev median */
m2 = ar1[i];
i++;
}
else
{
m1 = m2; /* Store the prev median */
m2 = ar2[j];
j++;
}
}
return (m1 + m2)/2;

}

int main()
{
int ar1[] = {1, 12, 15, 26, 38};
int ar2[] = {2, 13, 17, 30, 45};
int n1 = sizeof(ar1)/sizeof(ar1[0]);
if (n1 == n2)
printf("Median is %d", getMedian(ar1, ar2, n1));
else
printf("Doesn't work for arrays of unequal size");
getchar();
return 0;
}

Method 2 (By comparing the medians of two arrays)

This method works by first getting medians of the two sorted arrays and then comparing them.
Let ar1 and ar2 be the input arrays.
Algorithm:

1) Calculate the medians m1 and m2 of the input arrays ar1[]

and ar2[] respectively.
2) If m1 and m2 both are equal then we are done.
return m1 (or m2)
3) If m1 is greater than m2, then median is present in one
of the below two subarrays.
a) From first element of ar1 to m1 (ar1[0...|_n/2_|])
b) From m2 to last element of ar2 (ar2[|_n/2_|...n-1])
4) If m2 is greater than m1, then median is present in one
of the below two subarrays.
a) From m1 to last element of ar1 (ar1[|_n/2_|...n-1])
b) From first element of ar2 to m2 (ar2[0...|_n/2_|])
5) Repeat the above process until size of both the subarrays
becomes 2.
6) If size of the two arrays is 2 then use below formula to get
the median.
Median = (max(ar1[0], ar2[0]) + min(ar1[1], ar2[1]))/2

Example:
ar1[] = {1, 12, 15, 26, 38}

ar2[] = {2, 13, 17, 30, 45}

For above two arrays m1 = 15 and m2 = 17
For the above ar1[] and ar2[], m1 is smaller than m2. So median is present in one of the following two
subarrays.
[15, 26, 38] and [2, 13, 17]

Let us repeat the process for above two subarrays:
m1 = 26 m2 = 13.

m1 is greater than m2. So the subarrays become
[15, 26] and [13, 17]

Now size is 2, so median = (max(ar1[0], ar2[0]) + min(ar1[1], ar2[1]))/2
= (max(15, 13) + min(26, 17))/2
= (15 + 17)/2
= 16

Implementation:
#include<stdio.h>
int max(int, int); /* to get maximum of two integers */

int min(int, int); /* to get minimum of two integeres */
int median(int [], int); /* to get median of a sorted array */

{
int m1; /* For median of ar1 */
int m2; /* For median of ar2 */
/* return -1 for invalid input */

if (n <= 0)
return -1;
if (n == 1)
return (ar1[0] + ar2[0])/2;
if (n == 2)
return (max(ar1[0], ar2[0]) + min(ar1[1], ar2[1])) / 2;
m1 = median(ar1, n); /* get the median of the first array */

m2 = median(ar2, n); /* get the median of the second array */
/* If medians are equal then return either m1 or m2 */

if (m1 == m2)
return m1;
/* if m1 < m2 then median must exist in ar1[m1....] and ar2[....m2] */

if (m1 < m2)
{
if (n % 2 == 0)
return getMedian(ar1 + n/2 - 1, ar2, n - n/2 +1);
else
return getMedian(ar1 + n/2, ar2, n - n/2);
}
/* if m1 > m2 then median must exist in ar1[....m1] and ar2[m2...] */

else
{
if (n % 2 == 0)
return getMedian(ar2 + n/2 - 1, ar1, n - n/2 + 1);
else
return getMedian(ar2 + n/2, ar1, n - n/2);
}
}
/* Function to get median of a sorted array */

int median(int arr[], int n)
{
if (n%2 == 0)
return (arr[n/2] + arr[n/2-1])/2;
else
return arr[n/2];
}
int main()
{
int ar1[] = {1, 2, 3, 6};
int ar2[] = {4, 6, 8, 10};
if (n1 == n2)
else
getchar();
return 0;
}
/* Utility functions */
{
return x > y? x : y;
}
int min(int x, int y)

{
return x > y? y : x;
}


Algorithmic Paradigm: Divide and Conquer
Method 3 (By doing binary search for the median):

The basic idea is that if you are given two arrays ar1[] and ar2[] and know the length of each, you can check
whether an element ar1[i] is the median in constant time. Suppose that the median is ar1[i]. Since the array
is sorted, it is greater than exactly i values in array ar1[]. Then if it is the median, it is also greater than
exactly j = n – i – 1 elements in ar2[].
It requires constant time to check if ar2[j] 1) Get the middle element of ar1[] using array indexes left and
right. Let index of the middle element be i. 2) Calculate the corresponding index j of ar2[] j = n – i – 1 3) If
ar1[i] >= ar2[j] and ar1[i]
Example:
ar1[] = {1, 5, 7, 10, 13}

ar2[] = {11, 15, 23, 30, 45}

Middle element of ar1[] is 7. Let us compare 7 with 23 and 30, since 7 smaller than both 23 and 30, move to
right in ar1[]. Do binary search in {10, 13}, this step will pick 10. Now compare 10 with 15 and 23. Since 10 is
smaller than both 15 and 23, again move to right. Only 13 is there in right side now. Since 13 is greater than
11 and smaller than 15, terminate here. We have got the median as 12 (average of 11 and 13)
Implementation:

#include<stdio.h>
int getMedianRec(int ar1[], int ar2[], int left, int right, int n);

{
return getMedianRec(ar1, ar2, 0, n-1, n);
}
/* A recursive function to get the median of ar1[] and ar2[]

using binary search */
int getMedianRec(int ar1[], int ar2[], int left, int right, int n)
{
int i, j;
/* We have reached at the end (left or right) of ar1[] */

if (left > right)
i = (left + right)/2;
j = n - i - 1; /* Index of ar2[] */
/* Recursion terminates here.*/

if (ar1[i] > ar2[j] && (j == n-1 || ar1[i] <= ar2[j+1]))
{
/* ar1[i] is decided as median 2, now select the median 1
(element just before ar1[i] in merged array) to get the
average of both*/
if (i == 0 || ar2[j] > ar1[i-1])
return (ar1[i] + ar2[j])/2;
else
return (ar1[i] + ar1[i-1])/2;
}
/*Search in left half of ar1[]*/

else if (ar1[i] > ar2[j] && j != n-1 && ar1[i] > ar2[j+1])
return getMedianRec(ar1, ar2, left, i-1, n);
/*Search in right half of ar1[]*/

else /* ar1[i] is smaller than both ar2[j] and ar2[j+1]*/
return getMedianRec(ar1, ar2, i+1, right, n);
}

int main()
{
int ar1[] = {1, 12, 15, 26, 38};
int ar2[] = {2, 13, 17, 30, 45};
if (n1 == n2)
else
getchar();
return 0;
}


The above solutions can be optimized for the cases when all elements of one array are smaller than all
elements of other array. For example, in method 3, we can change the getMedian() function to following so
that these cases can be handled in O(1) time. Thanks to nutcracker for suggesting this optimization.

{
// If all elements of array 1 are smaller then
// median is average of last element of ar1 and
// first element of ar2
if (ar1[n-1] < ar2[0])
return (ar1[n-1]+ar2[0])/2;
// If all elements of array 1 are smaller then

// median is average of first element of ar1 and
// last element of ar2
if (ar2[n-1] < ar1[0])
return (ar2[n-1]+ar1[0])/2;

}

References:
http://en.wikipedia.org/wiki/Median
http://ocw.alfaisal.edu/NR/rdonlyres/Electrical-Engineering-and-Computer-Science/6-046JFall-
2005/30C68118-E436-4FE3-8C79-6BAFBB07D935/0/ps9sol.pdf ds3etph5wn
Asked by Snehal
same problem.
Write a function to get the intersection point of two Linked Lists.
There are two singly linked lists in a system. By some programming error the end node of one of the linked
list got linked into the second list, forming a inverted Y shaped list. Write a program to get the point where
two linked list merge.
Above diagram shows an example with two linked list having 15 as intersection point.
Method 1(Simply use two loops)

Use 2 nested for loops. Outer loop will be for each node of the 1st list and inner loop will be for 2nd list. In
the inner loop, check if any of nodes of 2nd list is same as the current node of first linked list. Time
complexity of this method will be O(mn) where m and n are the number of nodes in two lists.
Method 2 (Mark Visited Nodes)

This solution requires modifications to basic linked list data structure. Have a visited flag with each node.
Traverse the first linked list and keep marking visited nodes. Now traverse second linked list, If you see a
visited node again then there is an intersection point, return the intersecting node. This solution works in
O(m+n) but requires additional information with each node. A variation of this solution that doesn’t require
modification to basic data structure can be implemented using hash. Traverse the first linked list and store
the addresses of visited nodes in a hash. Now traverse the second linked list and if you see an address that
already exists in hash then return the intersecting node.
Method 3(Using difference of node counts)

1) Get count of the nodes in first list, let count be c1.
2) Get count of the nodes in second list, let count be c2.
3) Get the difference of counts d = abs(c1 – c2)
4) Now traverse the bigger list from the first node till d nodes so that from here onwards both the lists have
equal no of nodes.
5) Then we can traverse both the lists in parallel till we come across a common node. (Note that getting a
common node is done by comparing the address of the nodes)
#include<stdio.h>
#include<stdlib.h>

struct node
{
{
int data;
struct node* next;
};
/* Function to get the counts of node in a linked list */

int getCount(struct node* head);
/* function to get the intersection point of two linked

lists head1 and head2 where head1 has d more nodes than
head2 */
int _getIntesectionNode(int d, struct node* head1, struct node* head2);

lists head1 and head2 */
int getIntesectionNode(struct node* head1, struct node* head2)
{
int c1 = getCount(head1);
int c2 = getCount(head2);
int d;
if(c1 > c2)

{
d = c1 - c2;
return _getIntesectionNode(d, head1, head2);
}
else
{
d = c2 - c1;
return _getIntesectionNode(d, head2, head1);
}
}

lists head1 and head2 where head1 has d more nodes than
head2 */
int _getIntesectionNode(int d, struct node* head1, struct node* head2)
{
int i;
struct node* current1 = head1;
struct node* current2 = head2;
for(i = 0; i < d; i++)

{
if(current1 == NULL)
{ return -1; }
current1 = current1->next;
}
while(current1 != NULL && current2 != NULL)

{
if(current1 == current2)
return current1->data;
current1= current1->next;
current2= current2->next;
}
return -1;
}
/* Takes head pointer of the linked list and

returns the count of nodes in the list */
int getCount(struct node* head)
{
int count = 0;

{
count++;
}
return count;
}
/* IGNORE THE BELOW LINES OF CODE. THESE LINES

ARE JUST TO QUICKLY TEST THE ABOVE FUNCTION */
int main()
{
/*
Create two linked lists
1st 3->6->9->15->30
2nd 10->15->30
15 is the intersection point

*/
struct node* newNode;

struct node* head1 =
head1->data = 10;
struct node* head2 =

head2->data = 3;
newNode = (struct node*) malloc (sizeof(struct node));

newNode->data = 6;
head2->next = newNode;

newNode->data = 9;
head2->next->next = newNode;

newNode->data = 15;
head1->next = newNode;
head2->next->next->next = newNode;

newNode->data = 30;
head1->next->next= newNode;
head1->next->next->next = NULL;
printf("\n The node of intersection is %d \n",

getIntesectionNode(head1, head2));
getchar();
}


Method 4(Make circle in first list)
Thanks to Saravanan Man for providing below solution.
1. Traverse the first linked list(count the elements) and make a circular linked list. (Remember last node so
that we can break the circle later on).
2. Now view the problem as find the loop in the second linked list. So the problem is solved.
3. Since we already know the length of the loop(size of first linked list) we can traverse those many number
of nodes in second list, and then start another pointer from the beginning of second list. we have to traverse
until they are equal, and that is the required intersection point.
4. remove the circle from the linked list.

Method 5 (Reverse the first list and make equations)

Thanks to Saravanan Mani for providing this method.
1) Let X be the length of the first linked list until intersection point.
Let Y be the length of the second linked list until the intersection point.
Let Z be the length of the linked list from intersection point to End of
the linked list including the intersection node.
We Have
X + Z = C1;
Y + Z = C2;
2) Reverse first linked list.
3) Traverse Second linked list. Let C3 be the length of second list - 1.
Now we have
X + Y = C3
We have 3 linear equations. By solving them, we get
X = (C1 + C3 – C2)/2;
Y = (C2 + C3 – C1)/2;
Z = (C1 + C2 – C3)/2;
WE GOT THE INTERSECTION POINT.
4) Reverse first linked list.

Advantage: No Comparison of pointers.

Disadvantage : Modifying linked list(Reversing list).
Time complexity: O(m+n)

Method 6 (Traverse both lists and compare addresses of last nodes) This method is only to detect
if there is an intersection point or not. (Thanks to NeoTheSaviour for suggesting this)
1) Traverse the list 1, store the last node address

2) Traverse the list 2, store the last node address.
3) If nodes stored in 1 and 2 are same then they are intersecting.

Time complexity of this method is O(m+n) and used Auxiliary space is O(1)
Please write comments if you find any bug in the above algorithm or a better way to solve the same problem.
Find the two non-repeating elements in an array of repeating elements
Asked by SG
Given an array in which all numbers except two are repeated once. (i.e. we have 2n+2 numbers and n
numbers are occurring twice and remaining two have occurred once). Find those two numbers in the most
efficient way.
Method 1(Use Sorting)

First sort all the elements. In the sorted array, by comparing adjacent elements we can easily get the non-
repeating elements. Time complexity of this method is O(nLogn)
Method 2(Use XOR)

Let x and y be the non-repeating elements we are looking for and arr[] be the input array. First calculate the
XOR of all the array elements.
xor = arr[0]ârr[1]ârr[2].....arr[n-1]

All the bits that are set in xor will be set in one non-repeating element (x or y) and not in other. So if we take
any set bit of xor and divide the elements of the array in two sets – one set of elements with same bit set and
other set with same bit not set. By doing so, we will get x in one set and y in another set. Now if we do XOR
of all the elements in first set, we will get first non-repeating element, and by doing same in other set we will
get the second non-repeating element.
Let us see an example.

arr[] = {2, 4, 7, 9, 2, 4}
1) Get the XOR of all the elements.
xor = 2^4^7^9^2^4 = 14 (1110)
2) Get a number which has only one set bit of the xor.
Since we can easily get the rightmost set bit, let us use it.
set_bit_no = xor & ~(xor-1) = (1110) & ~(1101) = 0010
Now set_bit_no will have only set as rightmost set bit of xor.
3) Now divide the elements in two sets and do xor of
elements in each set, and we get the non-repeating
elements 7 and 9. Please see implementation for this
step.

Implementation:

#include <stdio.h>
#include <stdlib.h>
/* This finction sets the values of *x and *y to nonr-epeating

elements in an array arr[] of size n*/
void get2NonRepeatingNos(int arr[], int n, int *x, int *y)
{
int xor = arr[0]; /* Will hold xor of all elements */
int set_bit_no; /* Will have only single set bit of xor */
int i;
*x = 0;
*y = 0;
/* Get the xor of all elements */

for(i = 1; i < n; i++)
xor ^= arr[i];
/* Get the rightmost set bit in set_bit_no */

set_bit_no = xor & ~(xor-1);
/* Now divide elements in two sets by comparing rightmost set

bit of xor with bit at same position in each element. */
for(i = 0; i < n; i++)
{
if(arr[i] & set_bit_no)
*x = *x ^ arr[i]; /*XOR of first set */
else
*y = *y ^ arr[i]; /*XOR of second set*/
}
}

int main()
{
int arr[] = {2, 3, 7, 9, 11, 2, 3, 11};
int *x = (int *)malloc(sizeof(int));
int *y = (int *)malloc(sizeof(int));
get2NonRepeatingNos(arr, 8, x, y);
printf("The non-repeating elements are %d and %d", *x, *y);
getchar();
}


Write a program to reverse an array
Iterative way:
1) Initialize start and end indexes.
start = 0, end = n-1
2) In a loop, swap arr[start] with arr[end] and change start and end as follows.
start = start +1; end = end – 1
/* Function to reverse arr[] from start to end*/

void rvereseArray(int arr[], int start, int end)
{
int temp;
while(start < end)
{
temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
start++;
end--;
}
}

{
int i;
printf("\n");
}

int main()
{
int arr[] = {1, 2, 3, 4, 5, 6};
printArray(arr, 6);
rvereseArray(arr, 0, 5);
printf("Reversed array is \n");
printArray(arr, 6);
getchar();
return 0;
}

Recursive Way:
1) Initialize start and end indexes
start = 0, end = n-1
2) Swap arr[start] with arr[end]
3) Recursively call reverse for rest of the array.

/* Function to reverse arr[] from start to end*/

{
int temp;
if(start >= end)
return;
temp = arr[start];
arr[end] = temp;
rvereseArray(arr, start+1, end-1);
}

{
int i;
printf("\n");
}

int main()
{
int arr[] = {1, 2, 3, 4, 5};
printArray(arr, 5);
rvereseArray(arr, 0, 4);
printf("Reversed array is \n");
printArray(arr, 5);
getchar();
return 0;
}

Please write comments if you find any bug in the above programs or other ways to solve the same problem.
Rotate bits of a number
Bit Rotation: A rotation (or circular shift) is an operation similar to shift except that the bits that fall off at
one end are put back to the other end.
In left rotation, the bits that fall off at left end are put back at right end.
In right rotation, the bits that fall off at right end are put back at left end.
Example:
Let n is stored using 8 bits. Left rotation of n = 11100101 by 3 makes n = 00101111 (Left shifted by 3 and first
3 bits are put back in last ). If n is stored using 16 bits or 32 bits then left rotation of n (000…11100101)
becomes 00..0011100101000.
Right rotation of n = 11100101 by 3 makes n = 10111100 (Right shifted by 3 and last 3 bits are put back in
first ) if n is stored using 8 bits. If n is stored using 16 bits or 32 bits then right rotation of n (000…11100101)
by 3 becomes 101000..0011100.
#include<stdio.h>
#define INT_BITS 32
/*Function to left rotate n by d bits*/

int leftRotate(int n, unsigned int d)
{
/* In n<<d, last d bits are 0. To put first 3 bits of n at
last, do bitwise or of n<<d with n >>(INT_BITS - d) */
return (n << d)|(n >> (INT_BITS - d));
}
/*Function to right rotate n by d bits*/

int rightRotate(int n, unsigned int d)
{
/* In n>>d, first d bits are 0. To put last 3 bits of at
first, do bitwise or of n>>d with n <<(INT_BITS - d) */
return (n >> d)|(n << (INT_BITS - d));
}

int main()
{
int n = 16;
int d = 2;
printf("Left Rotation of %d by %d is ", n, d);
printf("%d", leftRotate(n, d));
printf("\nRight Rotation of %d by %d is ", n, d);
printf("%d", rightRotate(n, d));
getchar();
}

Please write comments if you find any bug in the above program or other ways to solve the same problem.
Compute the minimum or maximum of two integers without branching
On some rare machines where branching is expensive, the below obvious approach to find minimum can be
slow as it uses branching.
/* The obvious approach to find minimum (involves branching) */

{
return (x < y) ? x : y
}

Below are the methods to get minimum(or maximum) without using branching. Typically, the obvious
approach is best, though.
Method 1(Use XOR and comparison operator)
Minimum of x and y will be

y ^ ((x ^ y) & -(x
It works because if x = y, then -(x x ^ ((x ^ y) & -(x

#include<stdio.h>
/*Function to find minimum of x and y*/

{
return y ^ ((x ^ y) & -(x < y));
}
/*Function to find maximum of x and y*/

{
return x ^ ((x ^ y) & -(x < y));
}

int main()
{
int x = 15;
int y = 6;
printf("Minimum of %d and %d is ", x, y);
printf("%d", min(x, y));
printf("\nMaximum of %d and %d is ", x, y);
printf("%d", max(x, y));
getchar();
}

Method 2(Use subtraction and shift)
If we know that
INT_MIN
, then we can use the following, which are faster because (x - y) only needs to be eva
luated once.
luated once.
Minimum of x and y will be
y + ((x - y) & ((x - y) >>(sizeof(int) * CHAR_BIT - 1)))
This method shifts the subtraction of x and y by 31 (if size of integer is 32). If (x
-y) is smaller than 0, then (x -y)>>31 will be 1. If (x-y) is greater than or equal to
0, then (x -y)>>31 will be 0.
So if x >= y, we get minimum as y + (x-y)&0 which is y.
If x x - ((x - y) & ((x - y) >> (sizeof(int) * CHAR_BIT - 1)))

#include<stdio.h>
#define CHAR_BIT 8

{
return y + ((x - y) & ((x - y) >>
(sizeof(int) * CHAR_BIT - 1)));
}
/*Function to find maximum of x and y*/

{
return x - ((x - y) & ((x - y) >>
}

int main()
{
int x = 15;
int y = 6;
printf("Minimum of %d and %d is ", x, y);
printf("%d", min(x, y));
printf("\nMaximum of %d and %d is ", x, y);
printf("%d", max(x, y));
getchar();
}

Note that the 1989 ANSI C specification doesn't specify the result of signed right-shift
, so above method is not portable. If exceptions are thrown on overflows, then the value
s of x and y should be unsigned or cast to unsigned for the subtractions to avoid unnece
ssarily throwing an exception, however the right-shift needs a signed operand to produce
all one bits when negative, so cast to signed there.
Source:
http://graphics.stanford.edu/~seander/bithacks.html#IntegerMinOrMax

Level Order Tree Traversal
Level order traversal of a tree is breadth first traversal for the tree.
Example Tree
Level order traversal of the above tree is 1 2 3 4 5
METHOD 1 (Use function to print a given level)
Algorithm:
There are basically two functions in this method. One is to print all nodes at a given level (printGivenLevel),
and other is to print level order traversal of the tree (printLevelorder). printLevelorder makes use of
printGivenLevel to print nodes at all levels one by one starting from root.

/*Function to print level order traversal of tree*/
printLevelorder(tree)
for d = 1 to height(tree)
printGivenLevel(tree, d);
/*Function to print all nodes at a given level*/

printGivenLevel(tree, level)
if tree is NULL then return;
if level is 1, then
print(tree->data);
else if level greater than 1, then
printGivenLevel(tree->left, level-1);
printGivenLevel(tree->right, level-1);

Implementation:
#include <stdio.h>
#include <stdlib.h>

struct node
{
int data;
struct node* left;
struct node* right;
};
/*Function protoypes*/
void printGivenLevel(struct node* root, int level);
int height(struct node* node);
struct node* newNode(int data);
/* Function to print level order traversal a tree*/
void printLevelOrder(struct node* root)
{
int h = height(root);
int i;
for(i=1; i<=h; i++)
printGivenLevel(root, i);
}
/* Print nodes at a given level */

void printGivenLevel(struct node* root, int level)
{
if(root == NULL)
return;
if(level == 1)
printf("%d ", root->data);
else if (level > 1)
{
printGivenLevel(root->left, level-1);
printGivenLevel(root->right, level-1);
}
}
/* Compute the "height" of a tree -- the number of

int height(struct node* node)
{
if (node==NULL)
return 0;
else
{
/* compute the height of each subtree */
int lheight = height(node->left);
int rheight = height(node->right);

if (lheight > rheight)
return(lheight+1);
else return(rheight+1);
}
}

{
node->data = data;
node->left = NULL;
node->right = NULL;
return(node);
}

int main()
{
printf("Level Order traversal of binary tree is \n");

printLevelOrder(root);
getchar();
return 0;
}

Time Complexity: O(n^2) in worst case. For a skewed tree, printGivenLevel() takes O(n) time where n is the
number of nodes in the skewed tree. So time complexity of printLevelOrder() is O(n) + O(n-1) + O(n-2) + .. +
O(1) which is O(n^2).
METHOD 2 (Use Queue)
Algorithm:
For each node, first the node is visited and then it’s child nodes are put in a FIFO queue.

printLevelorder(tree)
1) Create an empty queue q
2) temp_node = root /*start from root*/
3) Loop while temp_node is not NULL
a) print temp_node->data.
b) Enqueue temp_node’s children (first left then right children) to q
c) Dequeue a node from q and assign it’s value to temp_node

Implementation:
Here is a simple implementation of the above algorithm. Queue is implemented using an array with
maximum size of 500. We can implement queue as linked list also.
#include <stdio.h>
#include <stdlib.h>
#define MAX_Q_SIZE 500

struct node
{
int data;
struct node* left;
struct node* right;
};
/* frunction prototypes */
struct node** createQueue(int *, int *);
void enQueue(struct node **, int *, struct node *);
struct node *deQueue(struct node **, int *);
/* Given a binary tree, print its nodes in level order

using array for implementing queue */
void printLevelOrder(struct node* root)
{
int rear, front;
struct node **queue = createQueue(&front, &rear);
struct node *temp_node = root;
while(temp_node)
{
printf("%d ", temp_node->data);
/*Enqueue left child */

if(temp_node->left)
enQueue(queue, &rear, temp_node->left);
/*Enqueue right child */

if(temp_node->right)
enQueue(queue, &rear, temp_node->right);
/*Dequeue node and make it temp_node*/

temp_node = deQueue(queue, &front);
}
}
/*UTILITY FUNCTIONS*/
struct node** createQueue(int *front, int *rear)
{
struct node **queue =
(struct node **)malloc(sizeof(struct node*)*MAX_Q_SIZE);
*front = *rear = 0;
return queue;
}
void enQueue(struct node **queue, int *rear, struct node *new_node)

{
queue[*rear] = new_node;
(*rear)++;
}
struct node *deQueue(struct node **queue, int *front)

{
(*front)++;
return queue[*front - 1];
}

{
node->data = data;
node->left = NULL;
node->right = NULL;
return(node);
}

int main()
{

printLevelOrder(root);
getchar();
return 0;
}

Time Complexity: O(n) where n is number of nodes in the binary tree
References:
http://en.wikipedia.org/wiki/Breadth-first_traversal
Please write comments if you find any bug in the above programs/algorithms or other ways to solve the
same problem.
Program to count leaf nodes in a binary tree
A node is a leaf node if both left and right child nodes of it are NULL.
Here is an algorithm to get the leaf node count.
getLeafCount(node)
1) If node is NULL then return 0.
2) Else If left and right child nodes are NULL return 1.
3) Else recursively calculate leaf count of the tree using below formula.
Leaf count of a tree = Leaf count of left subtree +
Leaf count of right subtree

Example Tree
Leaf count for the above tree is 3.
Implementation:

#include <stdio.h>
#include <stdlib.h>

struct node
{
int data;
struct node* left;
struct node* right;
};
/* Function to get the count of leaf nodes in a binary tree*/

unsigned int getLeafCount(struct node* node)
{
if(node == NULL)
return 0;
if(node->left == NULL && node->right==NULL)
return 1;
else
return getLeafCount(node->left)+
getLeafCount(node->right);
}

{
node->data = data;
node->left = NULL;
node->right = NULL;

return(node);
}
/*Driver program to test above functions*/

int main()
{
/*create a tree*/

/*get leaf count of the above created tree*/
printf("Leaf count of the tree is %d", getLeafCount(root));

getchar();
return 0;
}

Time & Space Complexities: Since this program is similar to traversal of tree, time and space
complexities will be same as Tree traversal (Please see our Tree Traversal post for details)
same problem.
Program for array rotation
Write a function rotate(ar[], d, n) that rotates arr[] of size n by d elements.
Rotation of the above array by 2 will make array
METHOD 1 (Use temp array)

Input arr[] = [1, 2, 3, 4, 5, 6, 7], d = 2, n =7
1) Store d elements in a temp array
temp[] = [1, 2]
2) Shift rest of the arr[]
arr[] = [3, 4, 5, 6, 7, 6, 7]
3) Store back the d elements
arr[] = [3, 4, 5, 6, 7, 1, 2]

Time complexity O(n)

Auxiliary Space: O(d)
METHOD 2 (Rotate one by one)

leftRotate(arr[], d, n)
start
For i = 0 to i
To rotate by one, store arr[0] in a temporary variable temp, move arr[1] to arr[0], arr[
2] to arr[1] …and finally temp to arr[n-1]
Let us take the same example arr[] = [1, 2, 3, 4, 5, 6, 7], d = 2
Rotate arr[] by one 2 times
We get [2, 3, 4, 5, 6, 7, 1] after first rotation and [ 3, 4, 5, 6, 7, 1, 2] after second

rotation.

/*Function to left Rotate arr[] of size n by 1*/
void leftRotatebyOne(int arr[], int n);
/*Function to left rotate arr[] of size n by d*/

void leftRotate(int arr[], int d, int n)
{
int i;
for (i = 0; i < d; i++)
leftRotatebyOne(arr, n);
}
void leftRotatebyOne(int arr[], int n)

{
int i, temp;
temp = arr[0];
for (i = 0; i < n-1; i++)
arr[i] = arr[i+1];
arr[i] = temp;
}
/* utility function to print an array */

{
int i;
}

int main()
{
int arr[] = {1, 2, 3, 4, 5, 6, 7};
leftRotate(arr, 2, 7);
printArray(arr, 7);
getchar();
return 0;
}

Time complexity: O(n*d)
METHOD 3 (A Juggling Algorithm)
This is an extension of method 2. Instead of moving one by one, divide the array in diff
erent sets
where number of sets is equal to GCD of n and d and move the elements within sets.
If GCD is 1 as is for the above example array (n = 7 and d =2), then elements will be mov
ed within one set only, we just start with temp = arr[0] and keep moving arr[I+d] to arr
[I] and finally store temp at the right place.
Here is an example for n =12 and d = 3. GCD is 3 and
Let arr[] be {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}
a) Elements are first moved in first set – (See below diagram for this movement)
arr[] after this step --> {4 2 3 7 5 6 10 8 9 1 11 12}

b) Then in second set.
c) Finally in third set.


/* function to print an array */
void printArray(int arr[], int size);
/*Fuction to get gcd of a and b*/

int gcd(int a,int b);
/*Function to left rotate arr[] of siz n by d*/

{
int i, j, k, temp;
for (i = 0; i < gcd(d, n); i++)
{
/* move i-th values of blocks */
temp = arr[i];
j = i;
while(1)
{
k = j + d;
if (k >= n)
k = k - n;
if (k == i)
break;
arr[j] = arr[k];
j = k;
}
arr[j] = temp;
}
}
{
int i;
}
/*Fuction to get gcd of a and b*/

int gcd(int a,int b)
{
if(b==0)
return a;
else
return gcd(b, a%b);
}

int main()
{
int arr[] = {1, 2, 3, 4, 5, 6, 7};
printArray(arr, 7);
getchar();
getchar();
return 0;
}

Time complexity: O(n)
Please see following posts for other methods of array rotation:
Block swap algorithm for array rotation
Reversal algorithm for array rotation
References:
http://www.cs.bell-labs.com/cm/cs/pearls/s02b.pdf
Please write comments if you find any bug in above programs/algorithms.

Reversal algorithm for array rotation
Write a function rotate(arr[], d, n) that rotates arr[] of size n by d elements.
Method 4(The Reversal Algorithm)

Please read this for first three methods of array rotation.
Algorithm:

rotate(arr[], d, n)
reverse(arr[], 1, d) ;
reverse(arr[], d + 1, n);
reverse(arr[], l, n);

Let AB are the two parts of the input array where A = arr[0..d-1] and B = arr[d..n-1]. The idea of the
algorithm is:
Reverse A to get ArB. /* Ar is reverse of A */
Reverse B to get ArBr. /* Br is reverse of B */
Reverse all to get (ArBr) r = BA.
For arr[] = [1, 2, 3, 4, 5, 6, 7], d =2 and n = 7

A = [1, 2] and B = [3, 4, 5, 6, 7]
Reverse A, we get ArB = [2, 1, 3, 4, 5, 6, 7]
Reverse B, we get ArBr = [2, 1, 7, 6, 5, 4, 3]
Reverse all, we get (ArBr)r = [3, 4, 5, 6, 7, 1, 2]
Implementation:

/*Utility function to print an array */

/* Utility function to reverse arr[] from start to end */

void rvereseArray(int arr[], int start, int end);
/* Function to left rotate arr[] of size n by d */

{
rvereseArray(arr, 0, d-1);
rvereseArray(arr, d, n-1);
rvereseArray(arr, 0, n-1);
}
{
int i;
printf("%\n ");
}
/*Function to reverse arr[] from index start to end*/

{
int i;
int temp;
while(start < end)
{
temp = arr[start];
arr[end] = temp;
start++;
end--;
}
}

int main()
{
int arr[] = {1, 2, 3, 4, 5, 6, 7};
printArray(arr, 7);
getchar();
return 0;
}

References:
Block swap algorithm for array rotation
Write a function rotate(ar[], d, n) that rotates arr[] of size n by d elements.
Algorithm:
Initialize A = arr[0..d-1] and B = arr[d..n-1]

1) Do following until size of A is equal to size of B
a) If A is shorter, divide B into Bl and Br such that Br is of same

length as A. Swap A and Br to change ABlBr into BrBlA. Now A
is at its final place, so recur on pieces of B.
b) If A is longer, divide A into Al and Ar such that Al is of same

length as B Swap Al and B to change AlArB into BArAl. Now B
is at its final place, so recur on pieces of A.
2) Finally when A and B are of equal size, block swap them.

Recursive Implementation:
#include<stdio.h>
/*Prototype for utility functions */

void swap(int arr[], int fi, int si, int d);

{
/* Return If number of elements to be rotated is
zero or equal to array size */
if(d == 0 || d == n)
return;

/*If number of elements to be rotated is exactly
half of array size */
if(n-d == d)
{
swap(arr, 0, n-d, d);
return;
}

/* If A is shorter*/
if(d < n-d)
{
swap(arr, 0, n-d, d);
leftRotate(arr, d, n-d);
leftRotate(arr, d, n-d);
}
else /* If B is shorter*/
{
swap(arr, 0, d, n-d);
leftRotate(arr+n-d, 2*d-n, d); /*This is tricky*/
}
}
{
int i;
printf("%\n ");
}
/*This function swaps d elements starting at index fi

with d elements starting at index si */
void swap(int arr[], int fi, int si, int d)
{
int i, temp;
for(i = 0; i<d; i++)
{
temp = arr[fi + i];
arr[fi + i] = arr[si + i];
arr[si + i] = temp;
}
}

int main()
{
int arr[] = {1, 2, 3, 4, 5, 6, 7};
printArray(arr, 7);
getchar();
return 0;
}

Iterative Implementation:
Here is iterative implementation of the same algorithm. Same utility function swap() is used here.


{
int i, j;
if(d == 0 || d == n)
return;
i = d;
j = n - d;
while (i != j)
{
if(i < j) /*A is shorter*/
{
swap(arr, d-i, d+j-i, i);
j -= i;
}
else /*B is shorter*/
{
swap(arr, d-i, d, j);
i -= j;
}
// printArray(arr, 7);
}
/*Finally, block swap A and B*/
swap(arr, d-i, d, i);
}

Please see following posts for other methods of array rotation:

http://geeksforgeeks.org/?p=2398
http://geeksforgeeks.org/?p=2838
References:
Please write comments if you find any bug in the above programs/algorithms or want to share any
additional information about the block swap algorithm.
Output of C programs | Set 8
Predict the output of below C programs.
Question 1:
#include<stdio.h>
int main()
{
int x = 5, p = 10;
printf("%*d", x, p);
getchar();
return 0;
}

Output:
10

Explanation:
Please see standard printf function definition

int printf ( const char * format, ... );

format: String that contains the text to be written to stdout. It can optionally contain embedded format tags
that are substituted by the values specified in subsequent argument(s) and formatted as requested. The
number of arguments following the format parameters should at least be as much as the number of format
tags. The format tags follow this prototype:

%[flags][width][.precision][length]specifier

You can see details of all above parts here http://www.cplusplus.com/reference/clibrary/cstdio/printf/.
The main thing to note is below the line about precision

* (star): The precision is not specified in the format string, but as an additional integer value argument
preceding the argument that has to be formatted.
So, in the above example 5 is precision and 10 is the actual value to be printed. (Thanks to Ajay Mishra for
providing the solution)
Question 2

int main()
{
char arr[] = "geeksforgeeks";
char *ptr = arr;
while(*ptr != '\0')
++*ptr++;
printf("%s %s", arr, ptr);
getchar();
return 0;
}

Output: hffltgpshfflt
Explanation:
The crust of this question lies in expression ++*ptr++.
If one knows the precedence and associativity of the operators then there is nothing much left. Below is the
precedence of operators.

Postfixx ++ left-to-right
Prefix ++ right-to-left
Dereference * right-to-left

Therefore the expression ++*ptr++ has following effect

Value of *ptr is incremented
Value of ptr is incremented
Question 3
int main()
{
signed char i=0;
for(; i >= 0; i++);
printf("%d\n", i);
getchar();
return 0;
}

Output: -128
Explanation:
Here, the first thing to be noticed is the semi-colon in the end of for loop. So basically, there’s no body for the
for loop. And printf will print the value of i when control comes out of the for loop. Also, notice that the first
statement i.e. initializer in the for loop is not present. But i has been initialized at the declaration time. Since
i is a signed character, it can take value from -128 to 127. So in the for loop, i will keep incrementing and the
condition is met till roll over happens. At the roll over, i will become -128 after 127, in that case condition is
not met and control comes out of the for loop.
Question 4
#include <stdio.h>
void fun(const char **p) { }
int main(int argc, char **argv)
{
fun(argv);
getchar();
return 0;
}

Output: Compiler error.
Explanation:
Parameter passed to fun() and parameter expected in definition are of incompatible types. fun() expects
const char** while passed parameter is of type char **.
Now try following program, it will work.
void fun(const char **p) { }

int main(int argc, char **argv)
{
const char **temp;
fun(temp);
getchar();
return 0;
}

A program to check if a binary tree is BST or not
A binary search tree (BST) is a node based binary tree data structure which has the following properties.
• The left subtree of a node contains only nodes with keys less than the node’s key.
• The right subtree of a node contains only nodes with keys greater than the node’s key.
• Both the left and right subtrees must also be binary search trees.
From the above properties it naturally follows that:

• Each node (item in the tree) has a distinct key.
METHOD 1 (Simple but Wrong)

Following is a simple program. For each node, check if left node of it is smaller than the node and right node
of it is greater than the node.
int isBST(struct node* node)

{
if (node == NULL)
return 1;

/* false if left is > than node */
if (node->left != NULL && node->left->data > node->data)
return 0;

/* false if right is < than node */
if (node->right != NULL && node->right->data < node->data)
return 0;

/* false if, recursively, the left or right is not a BST */
if (!isBST(node->left) || !isBST(node->right))
return 0;

/* passing all that, it's a BST */
return 1;
}

This approach is wrong as this will return true for below binary tree (and below tree is not a
BST because 4 is in left subtree of 3)
METHOD 2 (Correct but not efficient)
For each node, check if max value in left subtree is smaller than the node and min value in right subtree
greater than the node.
/* Returns true if a binary tree is a binary search tree */

{
if (node == NULL)
return(true);

/* false if the max of the left is > than us */
if (node->left!=NULL && maxValue(node->left) > node->data)
return(false);

/* false if the min of the right is <= than us */
if (node->right!=NULL && minValue(node->right) < node->data)
return(false);

/* false if, recursively, the left or right is not a BST */
if (!isBST(node->left) || !isBST(node->right))
return(false);

/* passing all that, it's a BST */
return(true);
}

It is assumed that you have helper functions minValue() and maxValue() that return the min or max int
value from a non-empty tree
METHOD 3 (Correct and Efficient)

Method 2 above runs slowly since it traverses over some parts of the tree many times. A better solution looks
at each node only once. The trick is to write a utility helper function isBSTUtil(struct node* node, int min,
int max) that traverses down the tree keeping track of the narrowing min and max allowed values as it goes,
looking at each node only once. The initial values for min and max should be INT_MIN and INT_MAX —
they narrow from there.
/* Returns true if the given tree is a binary search tree

(efficient version). */
{
{
return(isBSTUtil(node, INT_MIN, INT_MAX));
}
/* Returns true if the given tree is a BST and its

values are >= min and
Implementation:

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

struct node
{
int data;
struct node* left;
struct node* right;
};
int isBSTUtil(struct node* node, int min, int max);
/* Returns true if the given tree is a binary search tree

{
return(isBSTUtil(node, INT_MIN, INT_MAX));
}
/* Returns true if the given tree is a BST and its

values are >= min and <= max. */
int isBSTUtil(struct node* node, int min, int max)
{
/* an empty tree is BST */

if (node==NULL)
return 1;

/* false if this node violates the min/max constraint */
if (node->data < min || node->data > max)
return 0;
/* otherwise check the subtrees recursively,

tightening the min or max constraint */
return
isBSTUtil(node->left, min, node->data-1) && // Allow only distinct values
isBSTUtil(node->right, node->data+1, max); // Allow only distinct values
}

{
node->data = data;
node->left = NULL;
node->right = NULL;
return(node);
}
int main()
{
if(isBST(root))
printf("Is BST");
else
printf("Not a BST");

getchar();
return 0;
}

Auxiliary Space : O(1) if Function Call Stack size is not considered, otherwise O(n)
METHOD 4(Using In-Order Traversal)
Thanks to LJW489 for suggesting this method.
1) Do In-Order Traversal of the given tree and store the result in a temp array.
3) Check if the temp array is sorted in ascending order, if it is, then the tree is BST.
We can avoid the use of Auxiliary Array. While doing In-Order traversal, we can keep tr
ack of previously visited node. If the value of the currently visited node is less than
the previous value, then tree is not BST. Thanks to ygos for this space optimization.

bool isBST(struct node* root)
{
static struct node *prev = NULL;

// traverse the tree in inorder fashion and keep track of prev node
if (root)
{
if (!isBST(root->left))
return false;
// Allows only distinct valued nodes

if (prev != NULL && root->data <= prev->data)
return false;
prev = root;
return isBST(root->right);
}
return true;
}
}

The use of static variable can also be avoided by using reference to prev node as a para
meter (Similar to this post).
Sources:
http://en.wikipedia.org/wiki/Binary_search_tree
Please write comments if you find any bug in the above programs/algorithms or other ways
to solve the same problem.

Compute modulus division by a power-of-2-number
Compute n modulo d without division(/) and modulo(%) operators, where d is a power of 2 number.
Let ith bit from right is set in d. For getting n modulus d, we just need to return 0 to
i-1 (from right) bits of n
as they are and other bits as 0.
For example if n = 6 (00..110) and d = 4(00..100). Last set bit in d is at position 3 (from right side). So we
need to return last two bits of n as they are and other bits as 0, i.e., 00..010.
Now doing it is so easy, guess it….
Yes, you have guessing it right. See the below program.
#include<stdio.h>
/* This function will return n % d.

d must be one of: 1, 2, 4, 8, 16, 32, … */
unsigned int getModulo(unsigned int n, unsigned int d)
{
return ( n & (d-1) );
}

int main()
{
unsigned int n = 6;
unsigned int d = 4; /*d must be a power of 2*/
printf("%u moduo %u is %u", n, d, getModulo(n, d));
getchar();
return 0;
}

References:
http://graphics.stanford.edu/~seander/bithacks.html#ModulusDivisionEasy
Please write comments if you find any bug in the above program/algorithm or other ways to solve the same
problem.
Maximum sum such that no two elements are adjacent
Question: Given an array of positive numbers, find the maximum sum of a subsequence with the constraint
that no 2 numbers in the sequence should be adjacent in the array. So 3 2 7 10 should return 13 (sum of 3
and 10) or 3 2 5 10 7 should return 15 (sum of 3, 5 and 7).Answer the question in most efficient way.
Algorithm:
Loop for all elements in arr[] and maintain two sums incl and excl where incl = Max sum including the
previous element and excl = Max sum excluding the previous element.
Max sum excluding the current element will be max(incl, excl) and max sum including the current element
will be excl + current element (Note that only excl is considered because elements cannot be adjacent).
At the end of the loop return max of incl and excl.
Example:
arr[] = {5, 5, 10, 40, 50, 35}
inc = 5
exc = 0
For i = 1 (current element is 5)

incl = (excl + arr[i]) = 5
excl = max(5, 0) = 5

excl = max(5, 5) = 5

excl = max(5, 15) = 15

excl = max(45, 15) = 45

excl = max(5, 15) = 65
And 35 is the last element. So, answer is max(incl, excl) = 80

Thanks to Debanjan for providing code.
Implementation:

#include<stdio.h>
/*Function to return max sum such that no two elements

are adjacent */
int FindMaxSum(int arr[], int n)
{
int incl = arr[0];
int excl = 0;
int excl_new;
int i;
for (i = 1; i < n; i++)

{
/* current max excluding i */
excl_new = (incl > excl)? incl: excl;
/* current max including i */

incl = excl + arr[i];
excl = excl_new;
}
/* return max of incl and excl */

return ((incl > excl)? incl : excl);
}

int main()
{
int arr[] = {5, 5, 10, 100, 10, 5};
printf("%d \n", FindMaxSum(arr, 6));
getchar();
return 0;
}

Now try the same problem for array with negative numbers also.
problem.
Predict the output of the below programs.
Question 1
int main()
{
int c=5;
printf("%d\n%d\n%d", c, c <<= 2, c >>= 2);
getchar();
}

Output: Compiler dependent

Evaluation order of parameters is not defined by C standard and is dependent on compiler implementation.
It is never safe to depend on the order of parameter evaluation. For example, a function call like above may
very well behave differently from one compiler to another.
References:
http://gcc.gnu.org/onlinedocs/gcc/Non_002dbugs.html
Question 2
int main()
{
char arr[] = {1, 2, 3};
char *p = arr;
if(&p == &arr)
printf("Same");
else
printf("Not same");
getchar();
}

Output: Not Same

&arr is an alias for &arr[0] and returns the address of the first element in array, but &p returns the address
of pointer p.
Now try below program

int main()
{
char arr[] = {1, 2, 3};
char *p = arr;
if(p == &arr)
printf("Same");
else
printf("Not same");
getchar();
}

Question 3
int main()
{
char arr[] = {1, 2, 3};
char *p = arr;
printf(" %d ", sizeof(p));
printf(" %d ", sizeof(arr));
getchar();
}

Output 4 3
sizeof(arr) returns the amount of memory used by all elements in array
and sizeof(p) returns the amount of memory used by the pointer variable itself.
Question 4
int x = 0;
int f()
{
return x;
}
int g()
{
int x = 1;
return f();
}
int main()
{
printf("%d", g());
printf("\n");
getchar();
}

Output: 0
In C, variables are always statically (or lexically) scoped. Binding of x inside f() to global variable x is defined
at compile time and not dependent on who is calling it. Hence, output for the above program will be 0.
On a side note, Perl supports both dynamic ans static scoping. Perl’s keyword “my” defines a statically
scoped local variable, while the keyword “local” defines dynamically scoped local variable. So in Perl, similar
(see below) program will print 1.
$x = 0;
sub f
{
return $x;
}
sub g
{
local $x = 1; return f();
}
print g()."\n";

Reference:
http://en.wikipedia.org/wiki/Scope_%28programming%29
Please write comments if you find any of the above answers/explanations incorrect.
Leaders in an array
Write a program to print all the LEADERS in the array. An element is leader if it is greater than all the
elements to its right side. And the rightmost element is always a leader. For example int the array {16, 17, 4,
3, 5, 2}, leaders are 17, 5 and 2.
Let the input array be arr[] and size of the array be size.
Method 1 (Simple)
Use two loops. The outer loop runs from 0 to size – 1 and one by one picks all elements from left to right. The
inner loop compares the picked element to all the elements to its right side. If the picked element is greater
than all the elements to its right side, then the picked element is the leader.
/*Function to print leaders in an array */

void printLeaders(int arr[], int size)
{
int i, j;
for (i = 0; i < size; i++)

{
for (j = i+1; j < size; j++)
{
if(arr[i] <= arr[j])
break;
}
if(j == size) // the loop didn't break
{
}
}
}

int main()
{
int arr[] = {16, 17, 4, 3, 5, 2};
printLeaders(arr, 6);
getchar();
}
// Output: 17 5 2

Time Complexity: O(n*n)
Method 2 (Scan from right)

Scan all the elements from right to left in array and keep track of maximum till now. When maximum
changes it’s value, print it.

/*Function to print leaders in an array */
void printLeaders(int arr[], int size)
{
int max_from_right = arr[size-1];
int i;
/* Rightmost element is always leader */

printf("%d ", max_from_right);

for(i = size-2; i >= 0; i--)
{
if(max_from_right < arr[i])
{
max_from_right = arr[i];
}
}
}

int main()
{
int arr[] = {16, 17, 4, 3, 5, 2};
printLeaders(arr, 6);
getchar();
}
// Output: 2 5 17

discussed above.
Write a recursive function to print reverse of a Linked List
Note that the question is only about printing the reverse. To reverse the list itself see this
Algorithm
printReverse(head)
1. call print reverse for hed->next
2. print head->data

Implementation:

#include<stdio.h>
#include<stdlib.h>

struct node
{
int data;
struct node* next;
};

/* Function to reverse the linked list */
void printReverse(struct node* head)
{
// Base case
if(head == NULL)
return;
// print the list after head node

printReverse(head->next);
// After everything else is printed, print head

printf("%d ", head->data);
}

changes the head */
{
/* allocate node */



}

int main()
{

push(&head, 1);
push(&head, 2);
push(&head, 3);
push(&head, 4);

printReverse(head);
getchar();
}


Babylonian method for square root
Algorithm:
This method can be derived from (but predates) Newton–Raphson method.
1 Start with an arbitrary positive start value x (the closer to the

root, the better).
2 Initialize y = 1.
3. Do following until desired approximation is achieved.
a) Get the next approximation for root using average of x and y
b) Set y = n/x

Implementation:
/*Returns the square root of n. Note that the function */

float squareRoot(float n)
{
/*We are using n itself as initial approximation
This can definitely be improved */
float x = n;
float y = 1;
float e = 0.000001; /* e decides the accuracy level*/
while(x - y > e)
{
x = (x + y)/2;
y = n/x;
}
return x;
}
/* Driver program to test above function*/

int main()
{
int n = 50;
printf ("Square root of %d is %f", n, squareRoot(n));
getchar();
}

Example:

n = 4 /*n itself is used for initial approximation*/

Initialize x = 4, y = 1
Next Approximation x = (x + y)/2 (= 2.500000),
y = n/x (=1.600000)
Next Approximation x = 2.050000,
y = 1.951220
y = 1.999390
y = 2.000000
Terminate as (x - y) > e now.

If we are sure that n is a perfect square, then we can use following method. The method can go in infinite
loop for non-perfect-square numbers. For example, for 3 the below while loop will never terminate.
/*Returns the square root of n. Note that the function

will not work for numbers which are not perfect squares*/
unsigned int squareRoot(int n)
{
int x = n;
int y = 1;
while(x > y)
{
x = (x + y)/2;
y = n/x;
}
return x;
}
/* Driver program to test above function*/

int main()
{
int n = 49;
printf (" root of %d is %d", n, squareRoot(n));
getchar();
}

References;
http://en.wikipedia.org/wiki/Square_root
http://en.wikipedia.org/wiki/Babylonian_method#Babylonian_method
Asked by Snehal
Please write comments if you find any bug in the above program/algorithm, or if you want to share more
information about Babylonian method.
Level order traversal in spiral form
Write a function to print spiral order traversal of a tree. For below tree, function should print 1, 2, 3, 4, 5, 6,
7.
Method 1 (Recursive)
This problem can bee seen as an extension of the level order traversal post.
To print the nodes in spiral order, nodes at different levels should be printed in alternating order. An
additional Boolean variable ltr is used to change printing order of levels. If ltr is 1 then printGivenLevel()
prints nodes from left to right else from right to left. Value of ltr is flipped in each iteration to change the
order.
Function to print level order traversal of tree
printSpiral(tree)
bool ltr = 0;
for d = 1 to height(tree)
printGivenLevel(tree, d, ltr);
ltr ~= ltr /*flip ltr*/

Function to print all nodes at a given level
printGivenLevel(tree, level, ltr)

if level is 1, then
print(tree->data);
if(ltr)
printGivenLevel(tree->left, level-1, ltr);
printGivenLevel(tree->right, level-1, ltr);
else
printGivenLevel(tree->right, level-1, ltr);
printGivenLevel(tree->left, level-1, ltr);

Following is C implementation of above algorithm.
#include <stdio.h>
#include <stdlib.h>

struct node
{
int data;
struct node* left;
struct node* right;
};
/* Function protoypes */
void printGivenLevel(struct node* root, int level, int ltr);
/* Function to print spiral traversal of a tree*/

void printSpiral(struct node* root)
{
int i;
/*ltr -> Left to Right. If this variable is set,

then the given level is traverseed from left to right. */
bool ltr = false;
for(i=1; i<=h; i++)
{
printGivenLevel(root, i, ltr);
/*Revert ltr to traverse next level in oppposite order*/

ltr = !ltr;
}
}

void printGivenLevel(struct node* root, int level, int ltr)
{
if(root == NULL)
return;
if(level == 1)
else if (level > 1)
{
if(ltr)
{
printGivenLevel(root->left, level-1, ltr);
printGivenLevel(root->right, level-1, ltr);
}
else
{
printGivenLevel(root->right, level-1, ltr);
printGivenLevel(root->left, level-1, ltr);
}
}
}

{
if (node==NULL)
return 0;
else
{
return(lheight+1);
}
}

{
node->data = data;
node->left = NULL;
node->right = NULL;
return(node);
}

int main()
{
root->right->left = newNode(5);
root->right->right = newNode(4);
printf("Spiral Order traversal of binary tree is \n");
printSpiral(root);
return 0;
}

Output:

Spiral Order traversal of binary tree is
1 2 3 4 5 6 7

Time Complexity: Worst case time complexity of the above method is O(n^2). Worst case occurs in case
of skewed trees.
Method 2 (Iterative)
We can print spiral order traversal in O(n) time and O(n) extra space. The idea is to use two stacks. We can
use one stack for printing from left to right and other stack for printing from right to left. In every iteration,
we have nodes of one level in one of the stacks. We print the nodes, and push nodes of next level in other
stack.
// C++ implementation of a O(n) time method for spiral order traversal

#include <iostream>
#include <stack>
#include <stack>
// Binary Tree node

struct node
{
int data;
struct node *left, *right;
};
void printSpiral(struct node *root)

{
if (root == NULL) return; // NULL check
// Create two stacks to store alternate levels

stack<struct node*> s1; // For levels to be printed from right to left
stack<struct node*> s2; // For levels to be printed from left to right
// Push first level to first stack 's1'

s1.push(root);
// Keep ptinting while any of the stacks has some nodes

while (!s1.empty() || !s2.empty())
{
// Print nodes of current level from s1 and push nodes of
// next level to s2
while (!s1.empty())
{
struct node *temp = s1.top();
s1.pop();
cout << temp->data << " ";
// Note that is right is pushed before left

if (temp->right)
s2.push(temp->right);
if (temp->left)
s2.push(temp->left);
}
// Print nodes of current level from s2 and push nodes of

// next level to s1
while (!s2.empty())
{
struct node *temp = s2.top();
s2.pop();
cout << temp->data << " ";
// Note that is left is pushed before right

if (temp->left)
s1.push(temp->left);
if (temp->right)
s1.push(temp->right);
}
}
}
// A utility functiont to create a new node

{
struct node* node = new struct node;
node->data = data;
node->left = NULL;
node->right = NULL;
return(node);
return(node);
}
int main()
{
cout << "Spiral Order traversal of binary tree is \n";
printSpiral(root);
return 0;
}

Output:

Spiral Order traversal of binary tree is
1 2 3 4 5 6 7

Please write comments if you find any bug in the above program/algorithm; or if you want to share more
information about spiral traversal.
Sort elements by frequency | Set 1
Asked By Binod
Question:
Print the elements of an array in the decreasing frequency if 2 numbers have same frequency then print the
one which came 1st
E.g. 2 5 2 8 5 6 8 8 output: 8 8 8 2 2 5 5 6.
1) Use a sorting algorithm to sort the elements O(nlogn)

2) Scan the sorted array and construct a 2D array of element and count O(n).
3) Sort the 2D array according to count O(nlogn).

Example:
Input 2 5 2 8 5 6 8 8
After sorting we get

2 2 5 5 6 8 8 8
Now construct the 2D array as

2, 2
5, 2
6, 1
8, 3
Sort by count
8, 3
2, 2
5, 2
6, 1
There is one issue with above approach (thanks to ankit for pointing this out). If we modify the input to 5 2 2
8 5 6 8 8, then we should get 8 8 8 5 5 2 2 6 and not 8 8 8 2 2 5 5 6 as will be the case.
To handle this, we should use indexes in step 3, if two counts are same then we should first process(or print)
the element with lower index. In step 1, we should store the indexes instead of elements.

Input 5 2 2 8 5 6 8 8
After sorting we get

Element 2 2 5 5 6 8 8 8
Index 1 2 0 4 5 3 6 7
Now construct the 2D array as

Index, Count
1, 2
0, 2
5, 1
3, 3
Sort by count (consider indexes in case of tie)

3, 3
0, 2
1, 2
5, 1

Print the elements using indexes in the above 2D array.

METHOD 2(Use BST and Sorting)

1. Insert elements in BST one by one and if an element is already present then increment the count of the
node. Node of the Binary Search Tree (used in this approach) will be as follows.
struct tree
{
int element;
int first_index /*To handle ties in counts*/
int count;
}BST;

2.Store the first indexes and corresponding counts of BST in a 2D array.

3 Sort the 2D array according to counts (and use indexes in case of tie).
Time Complexity: O(nlogn) if a Self Balancing Binary Search Tree is used.
METHOD 3(Use Hashing and Sorting)

Using a hashing mechanism, we can store the elements (also first index) and their counts in a hash. Finally,
sort the hash elements according to their counts.
These are just our thoughts about solving the problem and may not be the optimal way of solving. We are
open for better solutions.
Related Links
http://www.trunix.org/programlama/c/kandr2/krx604.html
http://drhanson.s3.amazonaws.com/storage/documents/common.pdf
http://www.cc.gatech.edu/classes/semantics/misc/pp2.pdf
Count Inversions in an array
Inversion Count for an array indicates – how far (or close) the array is from being sorted. If array is already
sorted then inversion count is 0. If array is sorted in reverse order that inversion count is the maximum.
Formally speaking, two elements a[i] and a[j] form an inversion if a[i] > a[j] and i Example:
The sequence 2, 4, 1, 3, 5 has three inversions (2, 1), (4, 1), (4, 3).
METHOD 1 (Simple)
For each element, count number of elements which are on right side of it and are smaller than it.
int getInvCount(int arr[], int n)

{
int inv_count = 0;
int i, j;
for(i = 0; i < n - 1; i++)

for(j = i+1; j < n; j++)
if(arr[i] > arr[j])
inv_count++;
return inv_count;
}
/* Driver progra to test above functions */

int main(int argv, char** args)
{
int arr[] = {1, 20, 6, 4, 5};
printf(" Number of inversions are %d \n", getInvCount(arr, 5));
getchar();
return 0;
}

Time Complexity: O(n^2)
METHOD 2(Enhance Merge Sort)

Suppose we know the number of inversions in the left half and right half of the array (let be inv1 and inv2),
what kinds of inversions are not accounted for in Inv1 + Inv2? The answer is – the inversions we have to
count during the merge step. Therefore, to get number of inversions, we need to add number of inversions in
left subarray, right subarray and merge().
How to get number of inversions in merge()?
In merge process, let i is used for indexing left sub-array and j for right sub-array. At any step in merge(), if
a[i] is greater than a[j], then there are (mid – i) inversions. because left and right subarrays are sorted, so all
the remaining elements in left-subarray (a[i+1], a[i+2] … a[mid]) will be greater than a[j]
The complete picture:
Implementation:
#include <stdio.h>
#include <stdlib.h>

int _mergeSort(int arr[], int temp[], int left, int right);
int merge(int arr[], int temp[], int left, int mid, int right);

/* This function sorts the input array and returns the
number of inversions in the array */
int mergeSort(int arr[], int array_size)
{
{
int *temp = (int *)malloc(sizeof(int)*array_size);
return _mergeSort(arr, temp, 0, array_size - 1);
}

/* An auxiliary recursive function that sorts the input array and
returns the number of inversions in the array. */
int _mergeSort(int arr[], int temp[], int left, int right)
{
int mid, inv_count = 0;
if (right > left)
{
/* Divide the array into two parts and call _mergeSortAndCountInv()
for each of the parts */
mid = (right + left)/2;

/* Inversion count will be sum of inversions in left-part, right-part
and number of inversions in merging */
inv_count = _mergeSort(arr, temp, left, mid);
inv_count += _mergeSort(arr, temp, mid+1, right);

/*Merge the two parts*/
inv_count += merge(arr, temp, left, mid+1, right);
}
return inv_count;
}

/* This funt merges two sorted arrays and returns inversion count in
the arrays.*/
int merge(int arr[], int temp[], int left, int mid, int right)
{
int i, j, k;
int inv_count = 0;

i = left; /* i is index for left subarray*/
j = mid; /* i is index for right subarray*/
k = left; /* i is index for resultant merged subarray*/
while ((i <= mid - 1) && (j <= right))
{
if (arr[i] <= arr[j])
{
temp[k++] = arr[i++];
}
else
{
temp[k++] = arr[j++];

/*this is tricky -- see above explanation/diagram for merge()*/
inv_count = inv_count + (mid - i);
}
}

/* Copy the remaining elements of left subarray
(if there are any) to temp*/
while (i <= mid - 1)
temp[k++] = arr[i++];

/* Copy the remaining elements of right subarray
(if there are any) to temp*/
while (j <= right)
temp[k++] = arr[j++];

/*Copy back the merged elements to original array*/
for (i=left; i <= right; i++)
arr[i] = temp[i];
arr[i] = temp[i];

return inv_count;
}

int main(int argv, char** args)
{
int arr[] = {1, 20, 6, 4, 5};
printf(" Number of inversions are %d \n", mergeSort(arr, 5));
getchar();
return 0;
}

Note that above code modifies (or sorts) the input array. If we want to count only inversions then we need to
create a copy of original array and call mergeSort() on copy.
Time Complexity: O(nlogn)

References:
http://www.cs.umd.edu/class/fall2009/cmsc451/lectures/Lec08-inversions.pdf
http://www.cp.eng.chula.ac.th/~piak/teaching/algo/algo2008/count-inv.htm
problem.
Two elements whose sum is closest to zero
Question: An Array of integers is given, both +ve and -ve. You need to find the two elements such that their
sum is closest to zero.
For the below array, program should print -80 and 85.
METHOD 1 (Simple)
For each element, find the sum of it with every other element in the array and compare sums. Finally, return
the minimum sum.
Implementation

# include <stdio.h>
# include <stdlib.h> /* for abs() */
# include <math.h>
void minAbsSumPair(int arr[], int arr_size)
{
int inv_count = 0;
int l, r, min_sum, sum, min_l, min_r;
/* Array should have at least two elements*/

if(arr_size < 2)
{
printf("Invalid Input");
return;
}
/* Initialization of values */
min_l = 0;
min_r = 1;
min_sum = arr[0] + arr[1];
for(l = 0; l < arr_size - 1; l++)

{
for(r = l+1; r < arr_size; r++)
{
sum = arr[l] + arr[r];
if(abs(min_sum) > abs(sum))
{
min_sum = sum;
min_l = l;
min_r = r;
}
}
}
printf(" The two elements whose sum is minimum are %d and %d",
arr[min_l], arr[min_r]);
}

int main()
{
int arr[] = {1, 60, -10, 70, -80, 85};
minAbsSumPair(arr, 6);
getchar();
return 0;
}

Time complexity: O(n^2)

Thanks to baskin for suggesting this approach. We recommend to read this post for background of this
approach.
Algorithm
1) Sort all the elements of the input array.
2) Use two index variables l and r to traverse from left and right ends respectively. Initialize l as 0 and r as n-
1.
3) sum = a[l] + a[r]
4) If sum is -ve, then l++
5) If sum is +ve, then r–
6) Keep track of abs min sum.
7) Repeat steps 3, 4, 5 and 6 while l Implementation
# include <stdio.h>
# include <math.h>
# include <limits.h>
/* Function to print pair of elements having minimum sum */

void minAbsSumPair(int arr[], int n)
{
// Variables to keep track of current sum and minimum sum
int sum, min_sum = INT_MAX;
// left and right index variables

int l = 0, r = n-1;
// variable to keep track of the left and right pair for min_sum
int min_l = l, min_r = n-1;
/* Array should have at least two elements*/

if(n < 2)
{
return;
}

quickSort(arr, l, r);
while(l < r)
{
sum = arr[l] + arr[r];
/*If abs(sum) is less then update the result items*/

if(abs(sum) < abs(min_sum))
{
min_sum = sum;
min_l = l;
min_r = r;
}
if(sum < 0)
l++;
else
r--;
}
printf(" The two elements whose sum is minimum are %d and %d",
arr[min_l], arr[min_r]);
}

int main()
{
int arr[] = {1, 60, -10, 70, -80, 85};
int n = sizeof(arr)/sizeof(arr[0]);
minAbsSumPair(arr, n);
getchar();
return 0;
}

PURPOSE */
{
int temp;
temp = *a;
*a = *b;
*b = temp;
}
int partition(int arr[], int si, int ei)

{
int x = arr[ei];
int i = (si - 1);
int j;
for (j = si; j <= ei - 1; j++)

{
if(arr[j] <= x)
{
i++;
exchange(&arr[i], &arr[j]);
}
}
exchange (&arr[i + 1], &arr[ei]);

return (i + 1);
}

arr[] --> Array to be sorted
ei --> Ending index
*/
void quickSort(int arr[], int si, int ei)
{
if(si < ei)
{
pi = partition(arr, si, ei);
quickSort(arr, si, pi - 1);
quickSort(arr, pi + 1, ei);
}
}

Time Complexity: complexity to sort + complexity of finding the optimum pair = O(nlogn) + O(n) =
O(nlogn)
Asked by Vineet
problem.
Find the smallest and second smallest element in an array
Question: Write an efficient C program to find smallest and second smallest element in an array.
Algorithm:

1) Initialize both first and second smallest as INT_MAX
first = second = INT_MAX
2) Loop through all the elements.
a) If the current element is smaller than first, then update first
and second.
b) Else if the current element is smaller than second then update
second

Implementation:

#include <stdio.h>
#include <limits.h> /* For INT_MAX */
/* Function to print first smallest and second smallest elements */

void print2Smallest(int arr[], int arr_size)
{
int i, first, second;
/* There should be atleast two elements */

if (arr_size < 2)
{
printf(" Invalid Input ");
return;
}
first = second = INT_MAX;

for (i = 0; i < arr_size ; i ++)
{
/* If current element is smaller than first then update both
first and second */
if (arr[i] < first)
{
second = first;
first = arr[i];
}
/* If arr[i] is in between first and second then update second */

else if (arr[i] < second && arr[i] != first)
second = arr[i];
}
if (second == INT_MAX)
printf("There is no second smallest element\n");
else
printf("The smallest element is %d and second Smallest element is %d\n",
first, second);
}

int main()
{
int arr[] = {12, 13, 1, 10, 34, 1};
print2Smallest(arr, n);
return 0;
}

Output:

The smallest element is 1 and second Smallest element is 10

The same approach can be used to find the largest and second largest elements in an array.
problem.
G-Fact 1
In C language, sizeof( ) is an operator. Though it looks like a function, it is an unary operator.
G-Fact 4
In C, function parameters are always passed by value. Pass-by-reference is simulated in C by explicitly
passing pointer values.
Predict the output of the below programs.
Question 1
#include<stdio.h>
int main()
{
typedef int i;
i a = 0;
printf("%d", a);
getchar();
return 0;
}

Output: 0
There is no problem with the program. It simply creates a user defined type i and creates a variable a of type
i.
Question 2
#include<stdio.h>
int main()
{
typedef int *i;
int j = 10;
i *a = &j;
printf("%d", **a);
getchar();
return 0;
}

Output: Compiler Error -> Initialization with incompatible pointer type.

The line typedef int *i makes i as type int *. So, the declaration of a means a is pointer to a pointer. The Error
message may be different on different compilers.
Question 3

#include<stdio.h>
int main()
{
typedef static int *i;
int j;
i a = &j;
printf("%d", *a);
getchar();
return 0;
}

Output: Compiler Error -> Multiple Storage classes for a.

In C, typedef is considered as a storage class. The Error message may be different on different compilers.
Please write comments if you find any of the answers/explanations incorrect, or you want to share more
information about the topics discussed above.
References:
http://www.itee.uq.edu.au/~comp2303/Leslie_C_ref/C/SYNTAX/typedef.html
http://publib.boulder.ibm.com/infocenter/macxhelp/v6v81/index.jsp?
topic=/com.ibm.vacpp6m.doc/language/ref/clrc03sc03.htm
http://msdn.microsoft.com/en-us/library/4x7sfztk.aspx
Asked by Shobhit
#include<stdio.h>
int fun(int n, int *fg)
{
int t, f;
if(n <= 1)
{
*fg = 1;
return 1;
}
t = fun(n-1, fg);
f = t + *fg;
*fg = t;
return f;
}
int main( )
{
int x = 15;
printf ( "%d\n", fun (5, &x));
getchar();
return 0;
}

In the above program, there will be recursive calls till n is not smaller than or equal to 1.
fun(5, &x)
\
\
fun(4, fg)
\
\
fun(3, fg)
\
\
fun(2, fg)
\
\
fun(1, fg)

fun(1, fg) does not further call fun() because n is 1 now, and it goes inside the if part. It changes value at
address fg to 1, and returns 1.
Inside fun(2, fg)

t = fun(n-1, fg); --> t = 1

/* After fun(1, fg) is called, fun(2, fg) does following */
f = t + *fg; --> f = 1 + 1 (changed by fun(1, fg)) = 2
*fg = t; --> *fg = 1
return f (or return 2)

Inside fun(3, fg)
t = fun(2, fg); --> t = 2

f = t + *fg; --> f = 2 + 1 = 3
*fg = t; --> *fg = 2

Inside fun(4, fg)
t = fun(3, fg); --> t = 3

f = t + *fg; --> f = 3 + 2 = 5
*fg = t; --> *fg = 3

Inside fun(5, fg)
t = fun(4, fg); --> t = 5

f = t + *fg; --> f = 5 + 3 = 8
*fg = t; --> *fg = 5
return f (or return 8 )

Finally, value returned by fun(5, &x) is printed, so 8 is printed on the screen

G-Fact 3
In ISO C, you can define main either to take no arguments, or to take two arguments that represent the
command line arguments to the program, like this:
int main (int argc, char *argv[])

Other platform-dependent formats are also allowed by the C and C++ standards; for example, Unix (though
not POSIX.1) and Microsoft Visual C++ have a third argument giving the program’s environment, otherwise
accessible through getenv in stdlib.h:
G-Fact 2
To know the IP address(es) of a URL/website, nslookup can be used at the shell/command prompt
(cmd.exe). It works on both types of operating systems i.e. Linux/Windows. For example, to know the IP
address of our website, type nslookup www.geeksforgeeks.org at the shell/command prompt.
Check for Children Sum Property in a Binary Tree.
Given a binary tree, write a function that returns true if the tree satisfies below property.
For every node, data value must be equal to sum of data values in left and right children. Consider data value
as 0 for NULL children. Below tree is an example
Algorithm:
Traverse the given binary tree. For each node check (recursively) if the node and both its children satisfy the
Children Sum Property, if so then return true else return false.
Implementation:
/* Program to check children sum property */

#include <stdio.h>
#include <stdlib.h>
/* A binary tree node has data, left child and right child */
struct node
{
int data;
struct node* left;
struct node* right;
};
/* returns 1 if children sum property holds for the given

node and both of its children*/
int isSumProperty(struct node* node)
{
/* left_data is left child data and right_data is for right child data*/
int left_data = 0, right_data = 0;
/* If node is NULL or it's a leaf node then

return true */
if(node == NULL ||
(node->left == NULL && node->right == NULL))
return 1;
else
{
/* If left child is not present then 0 is used
as data of left child */
if(node->left != NULL)
left_data = node->left->data;
/* If right child is not present then 0 is used

as data of right child */
if(node->right != NULL)
right_data = node->right->data;
/* if the node and both of its children satisfy the

property return 1 else 0*/
if((node->data == left_data + right_data)&&
isSumProperty(node->left) &&
isSumProperty(node->right))
return 1;
else
return 0;
}
}
/*
Helper function that allocates a new node
pointers.
*/
{
struct node* node =
(struct node*)malloc(sizeof(struct node));
node->data = data;
node->left = NULL;
node->right = NULL;
return(node);
}

int main()
{
if(isSumProperty(root))
printf("The given tree satisfies the children sum property ");
else
printf("The given tree does not satisfy the children sum property ");
getchar();
return 0;
}

Time Complexity: O(n), we are doing a complete traversal of the tree.
As an exercise, extend the above question for an n-ary tree.
This question was asked by Shekhar.
G-Fact 5
A large proportion of programming languages are bootstrapped, including BASIC, C, Pascal, Factor, Haskell,
Modula-2, Oberon, OCaml, Common Lisp, Scheme, and more.
References:
http://en.wikipedia.org/wiki/Bootstrapping_%28compilers%29
http://www.oopweb.com/Compilers/Documents/Compilers/Volume/cha03s.htm
Question 1
int fun(char *str1)

{
char *str2 = str1;
while(*++str1);
return (str1-str2);
}
int main()
{
char *str = "geeksforgeeks";
printf("%d", fun(str));
getchar();
return 0;
}

Output: 13
Inside fun(), pointer str2 is initialized as str1 and str1 is moved till ‘\0’ is reached (note ; after while loop). So
str1 will be incremented by 13 (assuming that char takes 1 byte).
Question 2
void fun(int *p)

{
static int q = 10;
p = &q;
}
int main()
{
int r = 20;
int *p = &r;
fun(p);
printf("%d", *p);
getchar();
return 0;
}

Output: 20
Inside fun(), q is a copy of the pointer p. So if we change q to point something else then p remains
unaffected.
Question 3

void fun(int **p)

{
static int q = 10;
*p = &q;
}
int main()
{
int r = 20;
int *p = &r;
fun(&p);
printf("%d", *p);
getchar();
return 0;
}

Output 10
Note that we are passing address of p to fun(). p in fun() is actually a pointer to p in main() and we are
changing value at p in fun(). So p of main is changed to point q of fun(). To understand it better, let us
rename p in fun() to p_ref or ptr_to_p
void fun(int **ptr_to_p)

{
static int q = 10;
*ptr_to_p = &q; /*Now p of main is pointing to q*/
}

Also, note that the program won’t cause any problem because q is a static variable. Static variables exist in
memory even after functions return. For an auto variable, we might have seen some weird output because
auto variable may not exist in memory after functions return.
Convert an arbitrary Binary Tree to a tree that holds Children Sum Property
Question: Given an arbitrary binary tree, convert it to a binary tree that holds Children Sum Property. You
can only increment data values in any node (You cannot change structure of tree and cannot decrement
value of any node).
For example, the below tree doesn’t hold the children sum property, convert it to a tree that holds the
property.
50
/ \
/ \
7 2
/ \ /\
/ \ / \
3 5 1 30

Algorithm:
Traverse given tree in post order to convert it, i.e., first change left and right children to hold the children
sum property then change the parent node.
Let difference between node’s data and children sum be diff.
diff = node’s children sum - node’s data

If diff is 0 then nothing needs to be done.
If diff > 0 ( node’s data is smaller than node’s children sum) increment the node’s data by diff.
If diff 50 / \ / \ 8 2 / \ /\ / \ / \ 3 5 1 30
Then convert the right subtree (increment 2 to 31)
50
/ \
/ \
8 31
/ \ / \
/ \ / \
3 5 1 30

Now convert the root, we have to increment left subtree for converting the root.

50
/ \
/ \
19 31
/ \ / \
/ \ / \
14 5 1 30

Please note the last step – we have incremented 8 to 19, and to fix the subtree we have incremented 3 to 14.
Implementation:
/* Program to convert an aribitary binary tree to

a tree that holds children sum property */
#include <stdio.h>
#include <stdlib.h>
struct node
{
int data;
struct node* left;
struct node* right;
};
/* This function is used to increment left subtree */

void increment(struct node* node, int diff);

pointers. */
/* This function changes a tree to to hold children sum

property */
void convertTree(struct node* node)
{
int left_data = 0, right_data = 0, diff;
/* If tree is empty or it's a leaf node then

return true */
if (node == NULL ||
return;
else
{
/* convert left and right subtrees */
convertTree(node->left);
convertTree(node->right);
/* If left child is not present then 0 is used

as data of left child */
if (node->left != NULL)
left_data = node->left->data;
/* If right child is not present then 0 is used

if (node->right != NULL)
right_data = node->right->data;
/* get the diff of node's data and children sum */

diff = left_data + right_data - node->data;
/* If node's children sum is greater than the node's data */

if (diff > 0)
node->data = node->data + diff;
/* THIS IS TRICKY --> If node's data is greater than children sum,

then increment subtree by diff */
if (diff < 0)
increment(node, -diff); // -diff is used to make diff positive
}
}
/* This function is used to increment subtree by diff */

void increment(struct node* node, int diff)
{
/* IF left child is not NULL then increment it */
if(node->left != NULL)
{
node->left->data = node->left->data + diff;
// Recursively call to fix the descendants of node->left

increment(node->left, diff);
}
else if (node->right != NULL) // Else increment right child
{
node->right->data = node->right->data + diff;
// Recursively call to fix the descendants of node->right

increment(node->right, diff);
}
}
/* Given a binary tree, printInorder() prints out its

inorder traversal*/
{
if (node == NULL)
return;



}

pointers. */
{
struct node* node =
node->data = data;
node->left = NULL;
node->right = NULL;
node->right = NULL;
return(node);
}

int main()
{
printf("\n Inorder traversal before conversion ");

printInorder(root);
convertTree(root);
printf("\n Inorder traversal after conversion ");

printInorder(root);
getchar();
return 0;
}

Time Complexity: O(n^2), Worst case complexity is for a skewed tree such that nodes are in decreasing
order from root to leaf.
G-Fact 6
The C standard C99 allows inline functions and variable-length-arrays. So following functions are valid in
C99 compliant compilers.
Example for inline functions
inline int max(int a, int b)

{
if (a > b)
return a;
else
return b;
}
a = max (x, y);

/*
This is now equivalent to
if (x > y)
a = x;
else
a = y;
*/

Example for variable length arrays
float read_and_process(int n)
{
float vals[n];

for (int i = 0; i < n; i++)
vals[i] = read_val();
return process(vals, n);
}

References:
http://en.wikipedia.org/wiki/C99
http://en.wikipedia.org/wiki/Variable-length_array
http://en.wikipedia.org/wiki/Inline_function
What is Memory Leak? How can we avoid?
Memory leak occurs when programmers create a memory in heap and forget to delete it.
Memory leaks are particularly serious issues for programs like daemons and servers which by definition
never terminate.
/* Function with memory leak */

#include <stdlib.h>
void f()
{
int *ptr = (int *) malloc(sizeof(int));
/* Do some work */
return; /* Return without freeing ptr*/

}

To avoid memory leaks, memory allocated on heap should always be freed when no longer needed.
/* Function without memory leak */

#include <stdlib.h>;
void f()
{
int *ptr = (int *) malloc(sizeof(int));
/* Do some work */
free(ptr);
return;
}

Check for Majority Element in a sorted array
Question: Write a C function to find if a given integer x appears more than n/2 times in a sorted array of n
integers.
Basically, we need to write a function say isMajority() that takes an array (arr[] ), array’s size (n) and a
number to be searched (x) as parameters and returns true if x is a majority element (present more than n/2
times).
Examples:
Input: arr[] = {1, 2, 3, 3, 3, 3, 10}, x = 3

Output: True (x appears more than n/2 times in the given array)
Input: arr[] = {1, 1, 2, 4, 4, 4, 6, 6}, x = 4

Output: False (x doesn't appear more than n/2 times in the given array)
Input: arr[] = {1, 1, 1, 2, 2}, x = 1

Output: True (x appears more than n/2 times in the given array)

METHOD 1 (Using Linear Search)

Linearly search for the first occurrence of the element, once you find it (let at index i), check element at index
i + n/2. If element is present at i+n/2 then return 1 else return 0.

/* Program to check for majority element in a sorted array */

# include <stdio.h>
# include <stdbool.h>
bool isMajority(int arr[], int n, int x)

{
int i;
/* get last index according to n (even or odd) */

int last_index = n%2? (n/2+1): (n/2);
/* search for first occurrence of x in arr[]*/

for (i = 0; i < last_index; i++)
{
/* check if x is present and is present more than n/2 times */
if (arr[i] == x && arr[i+n/2] == x)
return 1;
}
return 0;
}
/* Driver program to check above function */

int main()
{
int arr[] ={1, 2, 3, 4, 4, 4, 4};
int x = 4;
if (isMajority(arr, n, x))
printf("%d appears more than %d times in arr[]", x, n/2);
else
printf("%d does not appear more than %d times in arr[]", x, n/2);
getchar();
return 0;
}

METHOD 2 (Using Binary Search)

Use binary search methodology to find the first occurrence of the given number. The criteria for binary
search is important here.
/* Program to check for majority element in a sorted array */

# include <stdio.h>;
# include <stdbool.h>
/* If x is present in arr[low...high] then returns the index of

first occurrence of x, otherwise returns -1 */
int _binarySearch(int arr[], int low, int high, int x);
/* This function returns true if the x is present more than n/2

times in arr[] of size n */
bool isMajority(int arr[], int n, int x)
{
/* Find the index of first occurrence of x in arr[] */
int i = _binarySearch(arr, 0, n-1, x);
/* If element is not present at all, return false*/

if (i == -1)
return false;
/* check if the element is present more than n/2 times */

if (((i + n/2) <= (n -1)) && arr[i + n/2] == x)
return true;
else
return false;
}
/* If x is present in arr[low...high] then returns the index of

first occurrence of x, otherwise returns -1 */
int _binarySearch(int arr[], int low, int high, int x)
{
if (high >= low)
{
/* Check if arr[mid] is the first occurrence of x.

arr[mid] is first occurrence if x is one of the following
is true:
(i) mid == 0 and arr[mid] == x
(ii) arr[mid-1] < x and arr[mid] == x
*/
if ( (mid == 0 || x > arr[mid-1]) && (arr[mid] == x) )
return mid;
else if (x > arr[mid])
return _binarySearch(arr, (mid + 1), high, x);
else
return _binarySearch(arr, low, (mid -1), x);
}
return -1;
}

int main()
{
int arr[] = {1, 2, 3, 3, 3, 3, 10};
int x = 3;
if(isMajority(arr, n, x))
printf("%d appears more than %d times in arr[]", x, n/2);
else
printf("%d does not appear more than %d times in arr[]", x, n/2);
return 0;
}

Time Complexity: O(Logn)

Please write comments if you find any bug in the above program/algorithm or a better way to solve the same
problem.
Maximum and minimum of an array using minimum number of
comparisons
Write a C function to return minimum and maximum in an array. You program should make
minimum number of comparisons.
First of all, how do we return multiple values from a C function? We can do it either using structures or
pointers.
We have created a structure named pair (which contains min and max) to return multiple values.
struct pair
{
int min;
int max;
};

And the function declaration becomes: struct pair getMinMax(int arr[], int n) where arr[] is the array of size
n whose minimum and maximum are needed.
METHOD 1 (Simple Linear Search)

Initialize values of min and max as minimum and maximum of the first two elements respectively. Starting
from 3rd, compare each element with max and min, and change max and min accordingly (i.e., if the
element is smaller than min then change min, else if the element is greater than max then change max, else
ignore the element)

/* structure is used to return two values from minMax() */

#include<stdio.h>
struct pair
{
int min;
int max;
};
struct pair getMinMax(int arr[], int n)

{
struct pair minmax;
int i;

/*If there is only one element then return it as min and max both*/
if (n == 1)
{
minmax.max = arr[0];
minmax.min = arr[0];
return minmax;
}
/* If there are more than one elements, then initialize min

and max*/
if (arr[0] > arr[1])
{
}
else
{
}
for (i = 2; i<n; i++)

{
if (arr[i] > minmax.max)
minmax.max = arr[i];

else if (arr[i] < minmax.min)
minmax.min = arr[i];
}

return minmax;
}

int main()
{
int arr[] = {1000, 11, 445, 1, 330, 3000};
int arr_size = 6;
struct pair minmax = getMinMax (arr, arr_size);
printf("\nMinimum element is %d", minmax.min);
printf("\nMaximum element is %d", minmax.max);
getchar();
}


In this method, total number of comparisons is 1 + 2(n-2) in worst case and 1 + n – 2 in best case.
In the above implementation, worst case occurs when elements are sorted in descending order and best case
occurs when elements are sorted in ascending order.
METHOD 2 (Tournament Method)

Divide the array into two parts and compare the maximums and minimums of the the two parts to get the
maximum and the minimum of the the whole array.
Pair MaxMin(array, array_size)

if array_size = 1
return element as both max and min
else if arry_size = 2
one comparison to determine max and min
return that pair
else /* array_size > 2 */
recur for max and min of left half
recur for max and min of right half
one comparison determines true max of the two candidates
one comparison determines true min of the two candidates
return the pair of max and min

Implementation

#include<stdio.h>
struct pair
{
int min;
int max;
};
struct pair getMinMax(int arr[], int low, int high)

{
struct pair minmax, mml, mmr;
int mid;

/* If there is only on element */
if (low == high)
{
minmax.max = arr[low];
minmax.min = arr[low];
return minmax;
}

/* If there are two elements */
if (high == low + 1)
{
if (arr[low] > arr[high])
{
minmax.max = arr[low];
minmax.min = arr[high];
}
else
{
minmax.max = arr[high];
minmax.max = arr[high];
minmax.min = arr[low];
}
return minmax;
}

/* If there are more than 2 elements */
mid = (low + high)/2;
mml = getMinMax(arr, low, mid);
mmr = getMinMax(arr, mid+1, high);

/* compare minimums of two parts*/
if (mml.min < mmr.min)
minmax.min = mml.min;
else
minmax.min = mmr.min;
/* compare maximums of two parts*/

if (mml.max > mmr.max)
minmax.max = mml.max;
else
minmax.max = mmr.max;

return minmax;
}

int main()
{
int arr[] = {1000, 11, 445, 1, 330, 3000};
int arr_size = 6;
struct pair minmax = getMinMax(arr, 0, arr_size-1);
getchar();
}


Total number of comparisons: let number of comparisons be T(n). T(n) can be written as follows:

T(n) = T(floor(n/2)) + T(ceil(n/2)) + 2
T(2) = 1
T(1) = 0

If n is a power of 2, then we can write T(n) as:

T(n) = 2T(n/2) + 2

After solving above recursion, we get

T(n) = 3/2n -2

Thus, the approach does 3/2n -2 comparisons if n is a power of 2. And it does more than 3/2n -2
comparisons if n is not a power of 2.
METHOD 3 (Compare in Pairs)

If n is odd then initialize min and max as first element.
If n is even then initialize min and max as minimum and maximum of the first two elements respectively.
For rest of the elements, pick them in pairs and compare their
maximum and minimum with max and min respectively.
#include<stdio.h>

struct pair
{
int min;
int max;
};
struct pair getMinMax(int arr[], int n)

{
struct pair minmax;
int i;
/* If array has even number of elements then

initialize the first two elements as minimum and
maximum */
if (n%2 == 0)
{
{
}
else
{
}
i = 2; /* set the startung index for loop */
}
/* If array has odd number of elements then

initialize the first element as minimum and
maximum */
else
{
i = 1; /* set the startung index for loop */
}

/* In the while loop, pick elements in pair and
compare the pair with max and min so far */
while (i < n-1)
while (i < n-1)
{
if (arr[i] > arr[i+1])
{
if(arr[i] > minmax.max)
minmax.max = arr[i];
if(arr[i+1] < minmax.min)
minmax.min = arr[i+1];
}
else
{
if (arr[i+1] > minmax.max)
minmax.max = arr[i+1];
if (arr[i] < minmax.min)
minmax.min = arr[i];
}
i += 2; /* Increment the index by 2 as two
elements are processed in loop */
}
return minmax;
}

int main()
{
int arr[] = {1000, 11, 445, 1, 330, 3000};
int arr_size = 6;
struct pair minmax = getMinMax (arr, arr_size);
getchar();
}

Total number of comparisons: Different for even and odd n, see below:
If n is odd: 3*(n-1)/2
If n is even: 1 Initial comparison for initializing min and max,
and 3(n-2)/2 comparisons for rest of the elements
= 1 + 3*(n-2)/2 = 3n/2 -2

Second and third approaches make equal number of comparisons when n is a power of 2.
In general, method 3 seems to be the best.
Please write comments if you find any bug in the above programs/algorithms or a better way to solve the
same problem.
What are Wild Pointers? How can we avoid?
Uninitialized pointers are known as wild pointers because they point to some arbitrary memory location and
may cause a program to crash or behave badly.
int main()
{
int *p; /* wild pointer */
*p = 12; /* Some unknown memory location is being corrupted. This should never be
done. */
}

Please note that if a pointer p points to a known variable then it’s not a wild pointer. In the below program, p
is a wild pointer till this points to a.
int main()
{
int *p; /* wild pointer */
int a = 10;
p = &a; /* p is not a wild pointer now*/
*p = 12; /* This is fine. Value of a is changed */
}

If we want pointer to a value (or set of values) without having a variable for the value, we should explicitly
allocate memory and put the value in allocated memory.
int main()
{
int *p = malloc(sizeof(int));
*p = 12; /* This is fine (assuming malloc doesn't return NULL) */
}

Understanding “register” keyword in C
Registers are faster than memory to access, so the variables which are most frequently used in a C program
can be put in registers using register keyword. The keyword register hints to compiler that a given variable
can be put in a register. It’s compiler’s choice to put it in a register or not. Generally, compilers themselves
do optimizations and put the variables in register.
1) If you use & operator with a register variable then compiler may give an error or warning (depending upon
the compiler you are using), because when we say a variable is a register, it may be stored in a register
instead of memory and accessing address of a register is invalid. Try below program.
int main()
{
register int i = 10;
int *a = &i;
printf("%d", *a);
getchar();
return 0;
}

2) register keyword can be used with pointer variables. Obviously, a register can have address of a memory
location. There would not be any problem with the below program.
int main()
{
int i = 10;
register int *a = &i;
printf("%d", *a);
getchar();
return 0;
}

3) Register is a storage class, and C doesn’t allow multiple storage class specifiers for a variable. So, register
can not be used with static . Try below program.
int main()
{
int i = 10;
register static int *a = &i;
printf("%d", *a);
getchar();
return 0;
}

4) There is no limit on number of register variables in a C program, but the point is compiler may put some
variables in register and some not.
Please write comments if you find anything incorrect in the above article or you want to share more
information about register keyword.
Remove duplicates from a sorted linked list
Write a removeDuplicates() function which takes a list sorted in non-decreasing order and deletes any
duplicate nodes from the list. The list should only be traversed once.
For example if the linked list is 11->11->11->21->43->43->60 then removeDuplicates() should convert the
list to 11->21->43->60.
Algorithm:
Traverse the list from the head (or start) node. While traversing, compare each node with its next node. If
data of next node is same as current node then delete the next node. Before we delete a node, we need to
store next pointer of the node
Implementation:
Functions other than removeDuplicates() are just to create a linked linked list and test removeDuplicates().
/*Program to remove duplicates from a sorted linked list */

#include<stdio.h>
#include<stlib.h>

struct node
{
int data;
struct node* next;
};
/* The function removes duplicates from a sorted list */

void removeDuplicates(struct node* head)
{
/* Pointer to traverse the linked list */
/* Pointer to store the next pointer of a node to be deleted*/

struct node* next_next;

/* do nothing if the list is empty */
if(current == NULL)
return;
/* Traverse the list till last node */

while(current->next != NULL)
{
/* Compare current node with next node */
if(current->data == current->next->data)
{
/*The sequence of steps is important*/
next_next = current->next->next;
free(current->next);
current->next = next_next;
}
else /* This is tricky: only advance if no deletion */
{
}
}
}
/* UTILITY FUNCTIONS */
/* Function to insert a node at the beginging of the linked list */
{
/* allocate node */



}
/* Function to print nodes in a given linked list */

void printList(struct node *node)
{
while(node!=NULL)
{
node = node->next;
}
}
/* Drier program to test above functions*/

int main()
{

/* Let us create a sorted linked list to test the functions
Created linked list will be 11->11->11->13->13->20 */
push(&head, 20);
push(&head, 13);
push(&head, 13);
push(&head, 11);
push(&head, 11);
push(&head, 11);
printf("\n Linked list before duplicate removal ");

printList(head);
/* Remove duplicates from linked list */

removeDuplicates(head);
printf("\n Linked list after duplicate removal ");

printList(head);

getchar();
}

Time Complexity: O(n) where n is number of nodes in the given linked list.
References:
cslibrary.stanford.edu/105/LinkedListProblems.pdf
Remove duplicates from an unsorted linked list
Write a removeDuplicates() function which takes a list and deletes any duplicate nodes from the list. The list
is not sorted.
For example if the linked list is 12->11->12->21->41->43->21 then removeDuplicates() should convert the
list to 12->11->21->41->43.
METHOD 1 (Using two loops)

This is the simple way where two loops are used. Outer loop is used to pick the elements one by one and
inner loop compares the picked element with rest of the elements.
Thanks to Gaurav Saxena for his help in writing this code.
/* Program to remove duplicates in an unsorted array */
#include<stdio.h>
#include<stdlib.h>
/* A linked list node */

struct node
{
int data;
struct node *next;
};
/* Function to remove duplicates from a unsorted linked list */

void removeDuplicates(struct node *start)
{
struct node *ptr1, *ptr2, *dup;
ptr1 = start;
/* Pick elements one by one */

while(ptr1 != NULL && ptr1->next != NULL)
{
ptr2 = ptr1;
/* Compare the picked element with rest of the elements */

while(ptr2->next != NULL)
{
/* If duplicate then delete it */
if(ptr1->data == ptr2->next->data)
{
/* sequence of steps is important here */
dup = ptr2->next;
ptr2->next = ptr2->next->next;
free(dup);
}
else /* This is tricky */
{
ptr2 = ptr2->next;
}
}
ptr1 = ptr1->next;
}
}
void push(struct node** head_ref, int new_data);
void printList(struct node *node);
/* Druver program to test above function */

int main()
{
struct node *start = NULL;
/* The constructed linked list is:

10->12->11->11->12->11->10*/
push(&start, 10);
push(&start, 11);
push(&start, 12);
push(&start, 11);
push(&start, 11);
push(&start, 12);
push(&start, 10);
printf("\n Linked list before removing duplicates ");

printList(start);
removeDuplicates(start);
printf("\n Linked list after removing duplicates ");

printList(start);
getchar();
}

{
/* allocate node */



}

{
while(node != NULL)
{
node = node->next;
}
}


In general, Merge Sort is the best suited sorting algorithm for sorting linked lists efficiently.
1) Sort the elements using Merge Sort. We will soon be writing a post about sorting a linked list. O(nLogn)
2) Remove duplicates in linear time using the algorithm for removing duplicates in sorted Linked List. O(n)
Please note that this method doesn’t preserve the original order of elements.
Time Complexity: O(nLogn)
METHOD 3 (Use Hashing)

We traverse the link list from head to end. For every newly encountered element, we check whether it is in
the hash table: if yes, we remove it; otherwise we put it in the hash table.
Thanks to bearwang for suggesting this method.
Time Complexity: O(n) on average (assuming that hash table access time is O(1) on average).
Please write comments if you find any of the above explanations/algorithms incorrect, or a better ways to
solve the same problem.
Compute the integer absolute value (abs) without branching
We need not to do anything if a number is positive. We want to change only negative numbers. Since
negative numbers are stored in 2’s complement form, to get the absolute value of a negative number we have
to toggle bits of the number and add 1 to the result.
For example -2 in a 8 bit system is stored as follows 1 1 1 1 1 1 1 0 where leftmost bit is the sign bit. To get the
absolute value of a negative number, we have to toggle all bits and add 1 to the toggled number i.e, 0 0 0 0 0
0 0 1 + 1 will give the absolute value of 1 1 1 1 1 1 1 0. Also remember, we need to do these operations only if
the number is negative (sign bit is set).
Method 1
1) Set the mask as right shift of integer by 31 (assuming integers are stored using 32 bits).

mask = n>>31

2) For negative numbers, above step sets mask as 1 1 1 1 1 1 1 1 and 0 0 0 0 0 0 0 0 for positive numbers. Add
the mask to the given number.

mask + n

3) XOR of mask +n and mask gives the absolute value.

(mask + n)^mask

Implementation:
#include <stdio.h>
#define CHAR_BIT 8
/* This function will return absoulte value of n*/

unsigned int getAbs(int n)
{
int const mask = n >> (sizeof(int) * CHAR_BIT - 1);
return ((n + mask) ^ mask);
}

int main()
{
int n = -6;
printf("Absoute value of %d is %u", n, getAbs(n));
getchar();
return 0;
}

Method 2:
1) Set the mask as right shift of integer by 31 (assuming integers are stored using 32 bits).

mask = n>>31

2) XOR the mask with number

mask ^ n

3) Subtract mask from result of step 2 and return the result.

(mask^n) - mask

Implementation:
/* This function will return absoulte value of n*/

unsigned int getAbs(int n)
{
int const mask = n >> (sizeof(int) * CHAR_BIT - 1);
return ((n ^ mask) - mask);
}

On machines where branching is expensive, the above expression can be faster than the obvious approach, r
= (v this for more details about the above two methods.
Please write comments if you find any of the above explanations/algorithms incorrect, or a better ways to
References:
http://graphics.stanford.edu/~seander/bithacks.html#IntegerAbs
Segregate 0s and 1s in an array
Asked by kapil.
You are given an array of 0s and 1s in random order. Segregate 0s on left side and 1s on right side of the
array. Traverse array only once.
Input array = [0, 1, 0, 1, 0, 0, 1, 1, 1, 0]

Output array = [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]

Method 1 (Count 0s or 1s)

Thanks to Naveen for suggesting this method.
1) Count the number of 0s. Let count be C.
2) Once we have count, we can put C 0s at the beginning and 1s at the remaining n – C positions in array.
The method 1 traverses the array two times. Method 2 does the same in a single pass.
Method 2 (Use two indexes to traverse)

Maintain two indexes. Initialize first index left as 0 and second index right as n-1.
Do following while left right

a) Keep incrementing index left while there are 0s at it
b) Keep decrementing index right while there are 1s at it
c) If left // C program to sort a binary array in one pass #include<stdio.h> /*Function to put all 0s on left
and all 1s on right*/ void segregate0and1(int arr[], int size) { /* Initialize left and right indexes */ int left = 0,
right = size-1; while (left < right) { /* Increment left index while we see 0 at left */ while (arr[left] == 0 &&
left < right) left++; /* Decrement right index while we see 1 at right */ while (arr[right] == 1 && left < right)
right–; /* If left is smaller than right then there is a 1 at left and a 0 at right. Exchange arr[left] and
arr[right]*/ if (left < right) { arr[left] = 0; arr[right] = 1; left++; right–; } } } /* driver program to test */ int
main() { int arr[] = {0, 1, 0, 1, 1, 1}; int i, arr_size = sizeof(arr)/sizeof(arr[0]); segregate0and1(arr, arr_size);
printf("array after segregation "); for (i = 0; i < 6; i++) printf("%d ", arr[i]); getchar(); return 0; }
Please write comments if you find any of the above algorithms/code incorrect, or a better ways to solve the
same problem.
k largest(or smallest) elements in an array | added Min Heap method
Question: Write an efficient program for printing k largest elements in an array. Elements in array can be
in any order.
For example, if given array is [1, 23, 12, 9, 30, 2, 50] and you are asked for the largest 3 elements i.e., k = 3
then your program should print 50, 30 and 23.
Method 1 (Use Bubble k times)

Thanks to Shailendra for suggesting this approach.
1) Modify Bubble Sort to run the outer loop at most k times.
2) Print the last k elements of the array obtained in step 1.
Time Complexity: O(nk)
Like Bubble sort, other sorting algorithms like Selection Sort can also be modified to get the k largest
elements.
Method 2 (Use temporary array)

K largest elements from arr[0..n-1]
1) Store the first k elements in a temporary array temp[0..k-1].

2) Find the smallest element in temp[], let the smallest element be min.
3) For each element x in arr[k] to arr[n-1]
If x is greater than the min then remove min from temp[] and insert x.
4) Print final k elements of temp[]
Time Complexity: O((n-k)*k). If we want the output sorted then O((n-k)*k + klogk)
Thanks to nesamani1822 for suggesting this method.
Method 3(Use Sorting)

1) Sort the elements in descending order in O(nLogn)
2) Print the first k numbers of the sorted array O(k).
Time complexity: O(nlogn)
Method 4 (Use Max Heap)

1) Build a Max Heap tree in O(n)
2) Use Extract Max k times to get k maximum elements from the Max Heap O(klogn)
Time complexity: O(n + klogn)
Method 5(Use Oder Statistics)

1) Use order statistic algorithm to find the kth largest element. Please see the topic selection in worst-case
linear time O(n)
2) Use QuickSort Partition algorithm to partition around the kth largest number O(n).
3) Sort the k-1 elements (elements greater than the kth largest element) O(kLogk). This step is needed only if
sorted output is required.
Time complexity: O(n) if we don’t need the sorted output, otherwise O(n+kLogk)
Thanks to Shilpi for suggesting the first two approaches.
Method 6 (Use Min Heap)

This method is mainly an optimization of method 1. Instead of using temp[] array, use Min Heap.
Thanks to geek4u for suggesting this method.

1) Build a Min Heap MH of the first k elements (arr[0] to arr[k-1]) of the given array. O(k)
2) For each element, after the kth element (arr[k] to arr[n-1]), compare it with root of MH.
……a) If the element is greater than the root then make it root and call heapify for MH
……b) Else ignore it.
// The step 2 is O((n-k)*logk)
3) Finally, MH has k largest elements and root of the MH is the kth largest element.
Time Complexity: O(k + (n-k)Logk) without sorted output. If sorted output is needed then O(k + (n-k)Logk +
kLogk)
All of the above methods can also be used to find the kth largest (or smallest) element.
Please write comments if you find any of the above explanations/algorithms incorrect, or find better ways to
References:
http://en.wikipedia.org/wiki/Selection_algorithm
Asked by geek4u
Question 1
Predict the output of below program.
int main()
{
printf("%d", sizeof(arr));
getchar();
return 0;
}

Output: 14
The string “geeksforgeeks” has 13 characters, but the size is 14 because compiler includes a single ‘\0′ (string
terminator) when char array size is not explicitly mentioned.
Question 2
In below program, what would you put in place of “?” to print “geeks”. Obviously, something other than
“geeks”.
int main()
{
printf("%s", ?);
getchar();
return 0;
}

Answer: (arr+8)
The printf statement prints everything starting from arr+8 until it finds ‘\0’
Question 3
int main()
{
int x, y = 5, z = 5;
x = y==z;
printf("%d", x);

getchar();
return 0;
}

The crux of the question lies in the statement x = y==z. The operator == is executed before = because
precedence of comparison operators (= and ==) is higher than assignment operator =.
The result of a comparison operator is either 0 or 1 based on the comparison result. Since y is equal to z,
value of the expression y == z becomes 1 and the value is assigned to x via the assignment operator.
Question 4
int main()
{
printf(" \"GEEKS %% FOR %% GEEKS\"");
getchar();
return 0;
}

Output: “GEEKS % FOR % GEEKS”
Backslash (\) works as escape character for double quote (“). For explanation of %%, please see this.
information about the topics discussed above
Storage for Strings in C
In C, a string can be referred either using a character pointer or as a character array.
Strings as character arrays
char str[4] = "GfG"; /*One extra for string terminator*/

/* OR */
char str[4] = {‘G’, ‘f’, ‘G’, '\0'}; /* '\0' is string terminator */

When strings are declared as character arrays, they are stored like other types of arrays in C. For example, if
str[] is an auto variable then string is stored in stack segment, if it’s a global or static variable then stored in
data segment, etc.
Strings using character pointers

Using character pointer strings can be stored in two ways:
1) Read only string in a shared segment.

When string value is directly assigned to a pointer, in most of the compilers, it’s stored in a read only block
(generally in data segment) that is shared among functions.

char *str = "GfG";

In the above line “GfG” is stored in a shared read only location, but pointer str is stored in a read-write
memory. You can change str to point something else but cannot change value at present str. So this kind of
string should only be used when we don’t want to modify string at a later stage in program.
2) Dynamically allocated in heap segment.

Strings are stored like other dynamically allocated things in C and can be shared among functions.
char *str;
int size = 4; /*one extra for ‘\0’*/
str = (char *)malloc(sizeof(char)*size);
*(str+0) = 'G';
*(str+1) = 'f';
*(str+2) = 'G';
*(str+3) = '\0';

Let us see some examples to better understand above ways to store strings.
Example 1 (Try to modify string)

The below program may crash (gives segmentation fault error) because the line *(str+1) = ‘n’ tries to write a
read only memory.

int main()
{
char *str;
str = "GfG"; /* Stored in read only part of data segment */
*(str+1) = 'n'; /* Problem: trying to modify read only memory */
getchar();
return 0;
}

Below program works perfectly fine as str[] is stored in writable stack segment.
int main()
{
char str[] = "GfG"; /* Stored in stack segment like other auto variables */
*(str+1) = 'n'; /* No problem: String is now GnG */
getchar();
return 0;
}

Below program also works perfectly fine as data at str is stored in writable heap segment.
int main()
{
int size = 4;
/* Stored in heap segment like other dynamically allocated things */

char *str = (char *)malloc(sizeof(char)*size);
*(str+0) = 'G';
*(str+1) = 'f';
*(str+2) = 'G';
*(str+3) = '\0';
*(str+1) = 'n'; /* No problem: String is now GnG */
getchar();
return 0;
}

Example 2 (Try to return string from a function)

The below program works perfectly fine as the string is stored in a shared segment and data stored remains
there even after return of getString()

char *getString()
{
char *str = "GfG"; /* Stored in read only part of shared segment */
/* No problem: remains at address str after getString() returns*/

return str;
}
int main()
{
getchar();
return 0;
}

The below program alse works perfectly fine as the string is stored in heap segment and data stored in heap
segment persists even after return of getString()
char *getString()
{
int size = 4;
char *str = (char *)malloc(sizeof(char)*size); /*Stored in heap segment*/
*(str+0) = 'G';
*(str+1) = 'f';
*(str+2) = 'G';
*(str+3) = '\0';

/* No problem: string remains at str after getString() returns */
return str;
}
int main()
{
getchar();
return 0;
}

But, the below program may print some garbage data as string is stored in stack frame of function getString()
and data may not be there after getString() returns.

char *getString()
{
char str[] = "GfG"; /* Stored in stack segment */
/* Problem: string may not be present after getSting() returns */

return str;
}
int main()
{
getchar();
return 0;
}

Please write comments if you find anything incorrect in the above article, or you want to share more
information about storage of strings
C function to Swap strings
Let us consider the below program.
#include<stdio.h>
void swap(char *str1, char *str2)
{
char *temp = str1;
str1 = str2;
str2 = temp;
}

int main()
{
char *str1 = "geeks";
char *str2 = "forgeeks";
swap(str1, str2);
printf("str1 is %s, str2 is %s", str1, str2);
getchar();
return 0;
}

Output of the program is str1 is geeks, str2 is forgeeks. So the above swap() function doesn’t swap strings.
The function just changes local pointer variables and the changes are not reflected outside the function.
Let us see the correct ways for swapping strings:
Method 1(Swap Pointers)

If you are using character pointer for strings (not arrays) then change str1 and str2 to point each other’s
data. i.e., swap pointers. In a function, if we want to change a pointer (and obviously we want changes to be
reflected outside the function) then we need to pass a pointer to the pointer.
#include<stdio.h>
/* Swaps strings by swapping pointers */

void swap1(char **str1_ptr, char **str2_ptr)
{
char *temp = *str1_ptr;
*str1_ptr = *str2_ptr;
*str2_ptr = temp;
}

int main()
{
char *str1 = "geeks";
char *str2 = "forgeeks";
swap1(&str1, &str2);
getchar();
return 0;
}

This method cannot be applied if strings are stored using character arrays.
Method 2(Swap Data)
If you are using character arrays to store strings then preferred way is to swap the data of both arrays.
#include<stdio.h>
#include<string.h>
#include<stdlib.h>

/* Swaps strings by swapping data*/
void swap2(char *str1, char *str2)
{
char *temp = (char *)malloc((strlen(str1) + 1) * sizeof(char));
strcpy(temp, str1);
strcpy(str1, str2);
strcpy(str2, temp);
free(temp);
}

int main()
{
char str1[10] = "geeks";
char str2[10] = "forgeeks";
swap2(str1, str2);
getchar();
return 0;
}

This method cannot be applied for strings stored in read only block of memory.
Multiply two integers without using multiplication, division and bitwise
operators, and no loops
Asked by Kapil
By making use of recursion, we can multiply two integers with the given constraints.
To multiply x and y, recursively add x y times.
Thanks to geek4u for suggesting this method.
#include<stdio.h>
/* function to multiply two numbers x and y*/
int multiply(int x, int y)
{
/* 0 multiplied with anything gives 0 */
if(y == 0)
return 0;
/* Add x one by one */

if(y > 0 )
return (x + multiply(x, y-1));

/* the case where y is negative */
if(y < 0 )
return -multiply(x, -y);
}
int main()
{
printf("\n %d", multiply(5, -11));
getchar();
return 0;
}

Time Complexity: O(y) where y is the second argument to function multiply().
Please write comments if you find any of the above code/algorithm incorrect, or find better ways to solve the
same problem.
Implement Queue using Stacks
A queue can be implemented using two stacks. Let queue to be implemented be q and stacks used to
implement q be stack1 and stack2. q can be implemented in two ways:
Method 1 (By making enQueue operation costly)

This method makes sure that newly entered element is always at the top of stack 1, so that deQueue
operation just pops from stack1. To put the element at top of stack1, stack2 is used.
enQueue(q, x)
1) While stack1 is not empty, push everything from satck1 to stack2.
2) Push x to stack1 (assuming size of stacks is unlimited).
3) Push everything back to stack1.
dnQueue(q)
1) If stack1 is empty then error
2) Pop an item from stack1 and return it

Method 2 (By making deQueue operation costly)

In this method, in en-queue operation, the new element is entered at the top of stack1. In de-queue
operation, if stack2 is empty then all the elements are moved to stack2 and finally top of stack2 is returned.
enQueue(q, x)
1) Push x to stack1 (assuming size of stacks is unlimited).
deQueue(q)
1) If both stacks are empty then error.
2) If stack2 is empty
While stack1 is not empty, push everything from satck1 to stack2.
3) Pop the element from stack2 and return it.

Method 2 is definitely better than method 1. Method 1 moves all the elements twice in enQueue operation,
while method 2 (in deQueue operation) moves the elements once and moves elements only if stack2 empty.
Implementation of method 2:
/* Program to implement a queue using two stacks */

#include<stdio.h>
#include<stdlib.h>
/* structure of a stack node */

struct sNode
{
int data;
struct sNode *next;
};

/* Function to push an item to stack*/
void push(struct sNode** top_ref, int new_data);

/* Function to pop an item from stack*/
int pop(struct sNode** top_ref);

/* structure of queue having two stacks */
struct queue
{
struct sNode *stack1;
};

/* Function to enqueue an item to queue */
void enQueue(struct queue *q, int x)
{
push(&q->stack1, x);
}

/* Function to dequeue an item from queue */
int deQueue(struct queue *q)
{
int x;

/* If both stacks are empty then error */
if(q->stack1 == NULL && q->stack2 == NULL)
{
printf("Q is empty");
getchar();
exit(0);
}
/* Move elements from satck1 to stack 2 only if

stack2 is empty */
if(q->stack2 == NULL)
{
while(q->stack1 != NULL)
{
x = pop(&q->stack1);
}
}
return x;
}

void push(struct sNode** top_ref, int new_data)
{
/* allocate node */
struct sNode* new_node =
(struct sNode*) malloc(sizeof(struct sNode));

if(new_node == NULL)
{
printf("Stack overflow \n");
getchar();
exit(0);
}


new_node->next = (*top_ref);

(*top_ref) = new_node;
}

int pop(struct sNode** top_ref)
{
int res;
struct sNode *top;

/*If stack is empty then error */
if(*top_ref == NULL)
{
getchar();
exit(0);
}
else
{
top = *top_ref;
res = top->data;
*top_ref = top->next;
free(top);
return res;
}
}

/* Driver function to test anove functions */
int main()
{
/* Create a queue with items 1 2 3*/
struct queue *q = (struct queue*)malloc(sizeof(struct queue));
q->stack1 = NULL;
q->stack2 = NULL;
enQueue(q, 1);
enQueue(q, 2);
enQueue(q, 3);

/* Dequeue items */
printf("%d ", deQueue(q));

getchar();
}

Queue can also be implemented using one user stack and one Function Call Stack.
Below is modified Method 2 where recursion (or Function Call Stack) is used to implement queue using only
one user defined stack.
enQueue(x)
1) Push x to stack1.
deQueue:
1) If stack1 is empty then error.
2) If stack1 has only one element then return it.
3) Recursively pop everything from the stack1, store the popped item
in a variable res, push the res back to stack1 and return res

The step 3 makes sure that the last popped item is always returned and since the recursion stops when there
is only one item in stack1 (step 2), we get the last element of stack1 in dequeue() and all other items are
pushed back in step 3.
Implementation of method 2 using Function Call Stack:
/* Program to implement a queue using one user defined stack and one Function Call Stack
*/
#include<stdio.h>
#include<stdlib.h>

struct sNode
{
int data;
struct sNode *next;
};

/* structure of queue having two stacks */
struct queue
{
};



/* Function to enqueue an item to queue */
void enQueue(struct queue *q, int x)
{
}

/* Function to dequeue an item from queue */
int deQueue(struct queue *q)
{
int x, res;

/* If both stacks are empty then error */
if(q->stack1 == NULL)
{
printf("Q is empty");
getchar();
exit(0);
}
else if(q->stack1->next == NULL)
{
return pop(&q->stack1);
}
else
{
/* pop an item from the stack1 */

/* store the last dequeued item */
res = deQueue(q);

/* push everything back to stack1 */
/* push everything back to stack1 */

return res;
}
}

{
/* allocate node */

{
getchar();
exit(0);
}



}

{
int res;
struct sNode *top;

{
getchar();
exit(0);
}
else
{
top = *top_ref;
res = top->data;
free(top);
return res;
}
}

int main()
{
/* Create a queue with items 1 2 3*/
struct queue *q = (struct queue*)malloc(sizeof(struct queue));
q->stack1 = NULL;

enQueue(q, 1);
enQueue(q, 2);
enQueue(q, 3);

/* Dequeue items */

getchar();
}

Please write comments if you find any of the above codes/algorithms incorrect, or find better ways to solve
the same problem.
Result of sizeof operator
Asked by Kapil
#include <stdio.h>
#define TOTAL_ELEMENTS (sizeof(array) / sizeof(array[0]))
int array[] = {1, 2, 3, 4, 5, 6, 7};
int main()
{
int i;
for(i = -1; i <= (TOTAL_ELEMENTS-2); i++)

printf("%d\n", array[i+1]);
getchar();
return 0;
}

Output: Nothing is printed as loop condition is not true for the first time itself.
The result of sizeof for an array operand is number of elements in the array multiplied by size of an element
in bytes. So value of the expression TOTAL_ELEMENTS in the above program is 7.
The data type of the sizeof result is unsigned int or unsigned long depending upon the compiler
implementation. Therefore, in the loop condition i
Please write comments if you find anything incorrect in the above post.
gets() is risky to use!
Asked by geek4u
Consider the below program.
void read()
{
char str[20];
gets(str);
printf("%s", str);
return;
}

The code looks simple, it reads string from standard input and prints the entered string, but it suffers from
Buffer Overflow as gets() doesn’t do any array bound testing. gets() keeps on reading until it sees a newline
character.
To avoid Buffer Overflow, fgets() should be used instead of gets() as fgets() makes sure that not more than
MAX_LIMIT characters are read.
#define MAX_LIMIT 20
void read()
{
char str[MAX_LIMIT];
fgets(str, MAX_LIMIT, stdin);
printf("%s", str);
getchar();
return;
}

Diameter of a Binary Tree
The diameter of a tree (sometimes called the width) is the number of nodes on the longest path between two
leaves in the tree. The diagram below shows two trees each with diameter nine, the leaves that form the ends
of a longest path are shaded (note that there is more than one path in each tree of length nine, but no path
longer than nine nodes).
The diameter of a tree T is the largest of the following quantities:
* the diameter of T’s left subtree

* the diameter of T’s right subtree
* the longest path between leaves that goes through the root of T (this can be computed from the heights of
the subtrees of T)
Implementation:
#include <stdio.h>
#include <stdlib.h>

struct node
{
int data;
struct node* left;
struct node* right;
};
/* function to create a new node of tree and returns pointer */

/* returns max of two integers */

int max(int a, int b);
/* function to Compute height of a tree. */

/* Function to get diameter of a binary tree */

int diameter(struct node * tree)
{
/* base case where tree is empty */
if (tree == 0)
return 0;
/* get the height of left and right sub-trees */

/* get the height of left and right sub-trees */
int lheight = height(tree->left);
int rheight = height(tree->right);
/* get the diameter of left and right sub-trees */

int ldiameter = diameter(tree->left);
int rdiameter = diameter(tree->right);
/* Return max of following three

1) Diameter of left subtree
2) Diameter of right subtree
3) Height of left subtree + height of right subtree + 1 */
return max(lheight + rheight + 1, max(ldiameter, rdiameter));
}
/* UTILITY FUNCTIONS TO TEST diameter() FUNCTION */
/* The function Compute the "height" of a tree. Height is the

number f nodes along the longest path from the root node
{
/* base case tree is empty */
if(node == NULL)
return 0;
/* If tree is not empty then height = 1 + max of left

height and right heights */
return 1 + max(height(node->left), height(node->right));
}

{
node->data = data;
node->left = NULL;
node->right = NULL;
return(node);
}
/* returns maximum of two integers */

int max(int a, int b)
{
return (a >= b)? a: b;
}

int main()
{
/* Constructed binary tree is

1
/ \
2 3
/ \
4 5
*/
printf("Diameter of the given binary tree is %d\n", diameter(root));
getchar();
return 0;
}

Optimized implementation: The above implementation can be optimized by calculating the height in
the same recursion rather than calling a height() separately. Thanks to Amar for suggesting this optimized
version. This optimization reduces time complexity to O(n).
/*The second parameter is to store the height of tree.

Initially, we need to pass a pointer to a location with value
as 0. So, function should be used as follows:
int height = 0;
struct node *root = SomeFunctionToMakeTree();
int diameter = diameterOpt(root, &height); */
int diameterOpt(struct node *root, int* height)
{
/* lh --> Height of left subtree
rh --> Height of right subtree */
int lh = 0, rh = 0;

/* ldiameter --> diameter of left subtree
rdiameter --> Diameter of right subtree */
int ldiameter = 0, rdiameter = 0;

if(root == NULL)
{
*height = 0;
return 0; /* diameter is also 0 */
}

/* Get the heights of left and right subtrees in lh and rh
And store the returned values in ldiameter and ldiameter */
ldiameter = diameterOpt(root->left, &lh);
rdiameter = diameterOpt(root->right, &rh);

/* Height of current node is max of heights of left and
right subtrees plus 1*/
*height = max(lh, rh) + 1;

return max(lh + rh + 1, max(ldiameter, rdiameter));
}

References:
http://www.cs.duke.edu/courses/spring00/cps100/assign/trees/diameter.html
Please write comments if you find any of the above codes/algorithms incorrect, or find other ways to solve
the same problem.
How to determine if a binary tree is height-balanced?
A tree where no leaf is much farther away from the root than any other leaf. Different balancing schemes
allow different definitions of “much farther” and different amounts of work to keep them balanced.
Consider a height-balancing scheme where following conditions should be checked to determine if a binary
tree is balanced.
An empty tree is height-balanced. A non-empty binary tree T is balanced if:
1) Left subtree of T is balanced
2) Right subtree of T is balanced
3) The difference between heights of left subtree and right subtree is not more than 1.
The above height-balancing scheme is used in AVL trees. The diagram below shows two trees, one of them is
height-balanced and other is not. The second tree is not height-balanced because height of left subtree is 2
more than height of right subtree.
To check if a tree is height-balanced, get the height of left and right subtrees. Return true if difference
between heights is not more than 1 and left and right subtrees are balanced, otherwise return false.
/* program to check if a tree is height-balanced or not */

#include<stdio.h>
#include<stdlib.h>
#define bool int

struct node
{
int data;
struct node* left;
struct node* right;
};
/* Returns the height of a binary tree */

/* Returns true if binary tree with root as root is height-balanced */

bool isBalanced(struct node *root)
{
int lh; /* for height of left subtree */
int rh; /* for height of right subtree */
/* If tree is empty then return true */

if(root == NULL)
return 1;
/* Get the height of left and right sub trees */

/* Get the height of left and right sub trees */
lh = height(root->left);
rh = height(root->right);
if( abs(lh-rh) <= 1 &&

isBalanced(root->left) &&
isBalanced(root->right))
return 1;
/* If we reach here then tree is not height-balanced */

return 0;
}
/* UTILITY FUNCTIONS TO TEST isBalanced() FUNCTION */
/* returns maximum of two integers */

{
return (a >= b)? a: b;
}
/* The function Compute the "height" of a tree. Height is the

number of nodes along the longest path from the root node
{
/* base case tree is empty */
if(node == NULL)
return 0;
/* If tree is not empty then height = 1 + max of left

height and right heights */
return 1 + max(height(node->left), height(node->right));
}

{
node->data = data;
node->left = NULL;
node->right = NULL;
return(node);
}
int main()
{
root->left->left->left = newNode(8);
if(isBalanced(root))
printf("Tree is balanced");
else
printf("Tree is not balanced");
getchar();
return 0;
}

Time Complexity: O(n^2) Worst case occurs in case of skewed tree.
Optimized implementation: Above implementation can be optimized by calculating the height in the
same recursion rather than calling a height() function separately. Thanks to Amar for suggesting this
optimized version. This optimization reduces time complexity to O(n).
/* program to check if a tree is height-balanced or not */

#include<stdio.h>
#include<stdlib.h>
#define bool int

struct node
{
int data;
struct node* left;
struct node* right;
};
/* The function returns true if root is balanced else false

The second parameter is to store the height of tree.
Initially, we need to pass a pointer to a location with value
as 0. We can also write a wrapper over this function */
bool isBalanced(struct node *root, int* height)
{
/* lh --> Height of left subtree
rh --> Height of right subtree */
int lh = 0, rh = 0;
/* l will be true if left subtree is balanced

and r will be true if right subtree is balanced */
int l = 0, r = 0;

if(root == NULL)
{
*height = 0;
return 1;
}
/* Get the heights of left and right subtrees in lh and rh

And store the returned values in l and r */
l = isBalanced(root->left, &lh);
r = isBalanced(root->right,&rh);
/* Height of current node is max of heights of left and

right subtrees plus 1*/
*height = (lh > rh? lh: rh) + 1;

/* If difference between heights of left and right
subtrees is more than 2 then this node is not balanced
so return 0 */
if((lh - rh >= 2) || (rh - lh >= 2))
return 0;

/* If this node is balanced and left and right subtrees
are balanced then return true */
else return l&&r;
}
/* UTILITY FUNCTIONS TO TEST isBalanced() FUNCTION */

{
node->data = data;
node->left = NULL;
node->right = NULL;
return(node);
}
int main()
{
int height = 0;

1
/ \
2 3
/ \ /
4 5 6
/
7
*/
if(isBalanced(root, &height))
printf("Tree is balanced");
else
printf("Tree is not balanced");
getchar();
return 0;
}

the same problem.
Reverse a Doubly Linked List
Write a C function to reverse a given Doubly Linked List
See below diagrams for example.

(a) Original Doubly Linked List

(b) Reversed Doubly Linked List

Here is a simple method for reversing a Doubly Linked List. All we need to do is swap prev and next pointers
for all nodes, change prev of the head (or start) and change the head pointer in the end.
/* Program to reverse a doubly linked list */

#include <stdio.h>
#include <stdlib.h>
/* a node of the doubly linked list */

struct node
{
int data;
struct node *next;
struct node *prev;
};
/* Function to reverse a Doubly Linked List */

void reverse(struct node **head_ref)
{
struct node *temp = NULL;
struct node *current = *head_ref;

/* swap next and prev for all nodes of
doubly linked list */
{
temp = current->prev;
current->prev = current->next;
current->next = temp;
current = current->prev;
}

/* Before changing head, check for the cases like empty
list and list with only one node */
if(temp != NULL )
*head_ref = temp->prev;
}
/* Function to insert a node at the beginging of the Doubly Linked List */
{
/* allocate node */


/* since we are adding at the begining,
prev is always NULL */
new_node->prev = NULL;

/* change prev of head node to new node */

if((*head_ref) != NULL)
(*head_ref)->prev = new_node ;

}
/* Function to print nodes in a given doubly linked list

This function is same as printList() of singly linked lsit */
{
while(node!=NULL)
{
node = node->next;
}
}

int main()
{

Created linked list will be 10->8->4->2 */
push(&head, 2);
push(&head, 4);
push(&head, 8);
push(&head, 10);

printf("\n Original Linked list ");
printList(head);
printList(head);

/* Reverse doubly linked list */
reverse(&head);

printf("\n Reversed Linked list ");
printList(head);

getchar();
}

We can also swap data instead of pointers to reverse the Doubly Linked List. Method used for reversing array
can be used to swap data. Swapping data can be costly compared to pointers if size of data item(s) is more.
the same problem.
Find whether a given number is a power of 4 or not
Asked by Ajay
1. A simple method is to take log of the given number on base 4, and if we get an integer then number is
power of 4.
2. Another solution is to keep dividing the number by 4, i.e, do n = n/4 iteratively. In any iteration, if n%4
becomes non-zero and n is not 1 then n is not a power of 4, otherwise n is a power of 4.
#include<stdio.h>
#define bool int

bool isPowerOfFour(int n)
{
if(n == 0)
return 0;
while(n != 1)
{
if(n%4 != 0)
return 0;
n = n/4;
}
return 1;
}

int main()
{
int test_no = 64;
if(isPowerOfFour(test_no))
printf("%d is a power of 4", test_no);
else
printf("%d is not a power of 4", test_no);
getchar();
}

3. A number n is a power of 4 if following conditions are met.

a) There is only one bit set in the binary representation of n (or n is a power of 2)
b) The count of zero bits before the (only) set bit is even.
For example: 16 (10000) is power of 4 because there is only one bit set and count of 0s before the set bit is 4
which is even.
Thanks to Geek4u for suggesting the approach and providing the code.

#include<stdio.h>
#define bool int
bool isPowerOfFour(unsigned int n)

{
int count = 0;
/*Check if there is only one bit set in n*/

if ( n && !(n&(n-1)) )
{
/* count 0 bits before set bit */
while(n > 1)
{
n >>= 1;
count += 1;
}
/*If count is even then return true else false*/

return (count%2 == 0)? 1 :0;
}
/* If there are more than 1 bit set

then n is not a power of 4*/
return 0;
}

int main()
{
int test_no = 64;
if(isPowerOfFour(test_no))
printf("%d is a power of 4", test_no);
else
printf("%d is not a power of 4", test_no);
getchar();
}

the same problem.
Split a Circular Linked List into two halves
Asked by Bharani

Original Linked List

Result Linked List 1

Result Linked List 2

Thanks to Geek4u for suggesting the algorithm.

1) Store the mid and last pointers of the circular linked list using tortoise and hare algorithm.
2) Make the second half circular.
3) Make the first half circular.
4) Set head (or start) pointers of the two linked lists.
In the below implementation, if there are odd nodes in the given circular linked list then the first result list
has 1 more node than the second result list.
/* Program to split a circular linked list into two halves */

#include<stdio.h>
#include<stdlib.h>
/* structure for a node */

struct node
{
int data;
struct node *next;
};
/* Function to split a list (starting with head) into two lists.

head1_ref and head2_ref are references to head nodes of
the two resultant linked lists */
void splitList(struct node *head, struct node **head1_ref,
struct node **head2_ref)
{
struct node *slow_ptr = head;
struct node *fast_ptr = head;
if(head == NULL)
return;

/* If there are odd nodes in the circular list then
fast_ptr->next becomes head and for even nodes
fast_ptr->next->next becomes head */
while(fast_ptr->next != head &&
fast_ptr->next->next != head)
{
}
/* If there are even elements in list then move fast_ptr */

if(fast_ptr->next->next == head)
fast_ptr = fast_ptr->next;

/* Set the head pointer of first half */
*head1_ref = head;

/* Set the head pointer of second half */
if(head->next != head)
*head2_ref = slow_ptr->next;

/* Make second half circular */
fast_ptr->next = slow_ptr->next;

/* Make first half circular */
slow_ptr->next = head;
}
/* Function to insert a node at the begining of a Circular
linked lsit */
void push(struct node **head_ref, int data)
{
struct node *ptr1 = (struct node *)malloc(sizeof(struct node));
struct node *temp = *head_ref;
ptr1->data = data;
ptr1->next = *head_ref;

/* If linked list is not NULL then set the next of
last node */
if(*head_ref != NULL)
{
while(temp->next != *head_ref)
temp = temp->next;
temp->next = ptr1;
}
else
ptr1->next = ptr1; /*For the first node */
*head_ref = ptr1;
}
/* Function to print nodes in a given Circular linked list */

/* Function to print nodes in a given Circular linked list */
{
if(head != NULL)
{
printf("\n");
do {
temp = temp->next;
} while(temp != head);
}
}

int main()
{
int list_size, i;

/* Initialize lists as empty */
struct node *head = NULL;
struct node *head1 = NULL;
struct node *head2 = NULL;
/* Created linked list will be 12->56->2->11 */

push(&head, 12);
push(&head, 56);
push(&head, 2);
push(&head, 11);
printf("Original Circular Linked List");

printList(head);

/* Split the list */
splitList(head, &head1, &head2);

printf("\nFirst Circular Linked List");
printList(head1);
printf("\nSecond Circular Linked List");

printList(head2);

getchar();
return 0;
}

Please write comments if you find any bug in above code/algorithm, or find other ways to solve the same
problem
Print list items containing all characters of a given word
There is a list of items. Given a specific word, e.g., “sun”, print out all the items in list which contain all the
characters of “sum”
For example if the given word is “sun” and the items are “sunday”, “geeksforgeeks”, “utensils”, “”just” and
“sss”, then the program should print “sunday” and “utensils”.
Algorithm: Thanks to geek4u for suggesting this algorithm.
1) Initialize a binary map:

map[256] = {0, 0, ..}
2) Set values in map[] for the given word "sun"
map['s'] = 1, map['u'] = 1, map['n'] = 1
3) Store length of the word "sun":
len = 3 for "sun"
4) Pick words (or items)one by one from the list
a) set count = 0;
b) For each character ch of the picked word
if(map['ch'] is set)
increment count and unset map['ch']
c) If count becomes equal to len (3 for "sun"),
print the currently picked word.
d) Set values in map[] for next list item
map['s'] = 1, map['u'] = 1, map['n'] = 1

# include <stdio.h>
/* prints list items having all caharacters of word */

void print(char *list[], char *word, int list_size)
{
/*Since calloc is used, map[] is initialized as 0 */
int *map = (int *)calloc(sizeof(int), NO_OF_CHARS);
int i, j, count, word_size;
/*Set the values in map */

for (i = 0; *(word+i); i++)
map[*(word + i)] = 1;
/* Get the length of given word */

word_size = strlen(word);
/* Check each item of list if has all characters

of word*/
for (i = 0; i < list_size; i++)
{
for(j = 0, count = 0; *(list[i] + j); j++)
{
if(map[*(list[i] + j)])
{
count++;
/* unset the bit so that strings like

sss not printed*/
map[*(list[i] + j)] = 0;
}
}
if(count == word_size)
printf("\n %s", list[i]);
/*Set the values in map for next item*/

for (j = 0; *(word+j); j++)
map[*(word + j)] = 1;
}
}

int main()
{
char str[] = "sun";
char *list[] = {"geeksforgeeks", "unsorted", "sunday", "just", "sss" };
print(list, str, 5);
getchar();
return 0;
}

Asked by Joey
Time Complexity: O(n + m) where n is total number of characters in the list of items. And m = (number of
items in list) * (number of characters in the given word)
problem
Maximum size square sub-matrix with all 1s
Given a binary matrix, find out the maximum size square sub-matrix with all 1s.
For example, consider the below binary matrix.

0 1 1 0 1
1 1 0 1 0
0 1 1 1 0
1 1 1 1 0
1 1 1 1 1
0 0 0 0 0

The maximum square sub-matrix with all set bits is
1 1 1
1 1 1
1 1 1

Algorithm:
Let the given binary matrix be M[R][C]. The idea of the algorithm is to construct an auxiliary size matrix S[]
[] in which each entry S[i][j] represents size of the square sub-matrix with all 1s including M[i][j] where M[i]
[j] is the rightmost and bottommost entry in sub-matrix.
1) Construct a sum matrix S[R][C] for the given M[R][C].

a) Copy first row and first columns as it is from M[][] to S[][]
b) For other entries, use following expressions to construct S[][]
If M[i][j] is 1 then
S[i][j] = min(S[i][j-1], S[i-1][j], S[i-1][j-1]) + 1
Else /*If M[i][j] is 0*/
S[i][j] = 0
2) Find the maximum entry in S[R][C]
3) Using the value and coordinates of maximum entry in S[i], print
sub-matrix of M[][]

For the given M[R][C] in above example, constructed S[R][C] would be:
0 1 1 0 1
1 1 0 1 0
0 1 1 1 0
1 1 2 2 0
1 2 2 3 1
0 0 0 0 0

The value of maximum entry in above matrix is 3 and coordinates of the entry are (4, 3). Using the
maximum value and its coordinates, we can find out the required sub-matrix.
#include<stdio.h>
#define bool int
#define R 6
#define C 5
void printMaxSubSquare(bool M[R][C])

{
int i,j;
int S[R][C];
int max_of_s, max_i, max_j;

/* Set first column of S[][]*/
for(i = 0; i < R; i++)
S[i][0] = M[i][0];

/* Set first row of S[][]*/
for(j = 0; j < C; j++)
S[0][j] = M[0][j];

/* Construct other entries of S[][]*/
for(i = 1; i < R; i++)
{
for(j = 1; j < C; j++)
{
if(M[i][j] == 1)
S[i][j] = min(S[i][j-1], S[i-1][j], S[i-1][j-1]) + 1;
else
S[i][j] = 0;
}
}

/* Find the maximum entry, and indexes of maximum entry
in S[][] */
max_of_s = S[0][0]; max_i = 0; max_j = 0;
for(i = 0; i < R; i++)
{
for(j = 0; j < C; j++)
{
if(max_of_s < S[i][j])
{
max_of_s = S[i][j];
max_i = i;
max_j = j;
}
}
}

printf("\n Maximum size sub-matrix is: \n");
for(i = max_i; i > max_i - max_of_s; i--)
{
for(j = max_j; j > max_j - max_of_s; j--)
{
printf("%d ", M[i][j]);
}
printf("\n");
}
}
/* Function to get minimum of three values */
/* Function to get minimum of three values */
int min(int a, int b, int c)
{
int m = a;
if (m > b)
m = b;
if (m > c)
m = c;
return m;
}

int main()
{
bool M[R][C] = {{0, 1, 1, 0, 1},
{1, 1, 0, 1, 0},
{0, 1, 1, 1, 0},
{1, 1, 1, 1, 0},
{1, 1, 1, 1, 1},
{0, 0, 0, 0, 0}};

printMaxSubSquare(M);
getchar();
}

Time Complexity: O(m*n) where m is number of rows and n is number of columns in the given matrix.
Auxiliary Space: O(m*n) where m is number of rows and n is number of columns in the given matrix.
problem
Inorder Tree Traversal without Recursion
Using Stack is the obvious way to traverse tree without recursion. Below is an algorithm for traversing binary
tree using stack. See this for step wise step execution of the algorithm.
1) Create an empty stack S.

2) Initialize current node as root
3) Push the current node to S and set current = current->left until current is NULL
4) If current is NULL and stack is not empty then
a) Pop the top item from stack.
b) Print the popped item, set current = popped_item->right
c) Go to step 3.
5) If current is NULL and stack is empty then we are done.

Let us consider the below tree for example

1
/ \
2 3
/ \
4 5
Step 1 Creates an empty stack: S = NULL
Step 2 sets current as address of root: current -> 1
Step 3 Pushes the current node and set current = current->left until current is NULL
current -> 1
push 1: Stack S -> 1
current -> 2
push 2: Stack S -> 2, 1
current -> 4
push 4: Stack S -> 4, 2, 1
current = NULL
Step 4 pops from S

a) Pop 4: Stack S -> 2, 1
b) print "4"
c) current = NULL /*right of 4 */ and go to step 3
Since current is NULL step 3 doesn't do anything.
Step 4 pops again.

a) Pop 2: Stack S -> 1
b) print "2"
c) current -> 5/*right of 2 */ and go to step 3
Step 3 pushes 5 to stack and makes current NULL

Stack S -> 5, 1
current = NULL
Step 4 pops from S

a) Pop 5: Stack S -> 1
b) print "5"
c) current = NULL /*right of 5 */ and go to step 3
Since current is NULL step 3 doesn't do anything
Step 4 pops again.

a) Pop 1: Stack S -> NULL
b) print "1"
c) current -> 3 /*right of 5 */
Step 3 pushes 3 to stack and makes current NULL

Stack S -> 3
current = NULL
Step 4 pops from S

a) Pop 3: Stack S -> NULL
b) print "3"
c) current = NULL /*right of 3 */
Traversal is done now as stack S is empty and current is NULL.

Implementation:

#include<stdio.h>
#include<stdlib.h>
#define bool int
/* A binary tree tNode has data, pointer to left child

struct tNode
{
int data;
struct tNode* left;
struct tNode* right;
};
/* Structure of a stack node. Linked List implementation is used for

stack. A stack node contains a pointer to tree node and a pointer to
next stack node */
struct sNode
{
struct tNode *t;
struct sNode *next;
};
/* Stack related functions */

void push(struct sNode** top_ref, struct tNode *t);
struct tNode *pop(struct sNode** top_ref);
bool isEmpty(struct sNode *top);
/* Iterative function for inorder tree traversal */

void inOrder(struct tNode *root)
{
/* set current to root of binary tree */
struct tNode *current = root;
struct sNode *s = NULL; /* Initialize stack s */
bool done = 0;
while (!done)
{
/* Reach the left most tNode of the current tNode */
if(current != NULL)
{
/* place pointer to a tree node on the stack before traversing
the node's left subtree */
push(&s, current);
}

/* backtrack from the empty subtree and visit the tNode
at the top of the stack; however, if the stack is empty,
you are done */
else
{
if (!isEmpty(s))
{
current = pop(&s);
printf("%d ", current->data);
/* we have visited the node and its left subtree.

Now, it's right subtree's turn */
current = current->right;
}
else
done = 1;
}
}
} /* end of while */
}
/* Function to push an item to sNode*/
void push(struct sNode** top_ref, struct tNode *t)
{
/* allocate tNode */
struct sNode* new_tNode =
if(new_tNode == NULL)
{
printf("Stack Overflow \n");
getchar();
exit(0);
}

new_tNode->t = t;
/* link the old list off the new tNode */

new_tNode->next = (*top_ref);
/* move the head to point to the new tNode */

(*top_ref) = new_tNode;
}
/* The function returns true if stack is empty, otherwise false */

bool isEmpty(struct sNode *top)
{
return (top == NULL)? 1 : 0;
}

struct tNode *pop(struct sNode** top_ref)
{
struct tNode *res;
struct sNode *top;
/*If sNode is empty then error */

if(isEmpty(*top_ref))
{
printf("Stack Underflow \n");
getchar();
exit(0);
}
else
{
top = *top_ref;
res = top->t;
free(top);
return res;
}
}
/* Helper function that allocates a new tNode with the

struct tNode* newtNode(int data)
{
struct tNode* tNode = (struct tNode*)
malloc(sizeof(struct tNode));
tNode->data = data;
tNode->data = data;
tNode->left = NULL;
tNode->right = NULL;
return(tNode);
}

int main()
{

1
/ \
2 3
/ \
4 5
*/
struct tNode *root = newtNode(1);
root->left = newtNode(2);
root->right = newtNode(3);
root->left->left = newtNode(4);
root->left->right = newtNode(5);
inOrder(root);
getchar();
return 0;
}

References:
http://web.cs.wpi.edu/~cs2005/common/iterative.inorder
http://neural.cs.nthu.edu.tw/jang/courses/cs2351/slide/animation/Iterative%20Inorder%20Traversal.pps
See this post for another approach of Inorder Tree Traversal without recursion and without stack!
Please write comments if you find any bug in above code/algorithm, or want to share more information
about stack based Inorder Tree Traversal.
Inorder Tree Traversal without recursion and without stack!
Using Morris Traversal, we can traverse the tree without using stack and recursion. The idea of Morris
Traversal is based on Threaded Binary Tree. In this traversal, we first create links to Inorder successor and
print the data using these links, and finally revert the changes to restore original tree.
1. Initialize current as root

2. While current is not NULL
If current does not have left child
a) Print current’s data
b) Go to the right, i.e., current = current->right
Else
a) Make current as right child of the rightmost node in current's left subtree
b) Go to this left child, i.e., current = current->left

Although the tree is modified through the traversal, it is reverted back to its original shape after the
completion. Unlike Stack based traversal, no extra space is required for this traversal.
#include<stdio.h>
#include<stdlib.h>
/* A binary tree tNode has data, pointer to left child

struct tNode
{
int data;
struct tNode* left;
struct tNode* right;
};
/* Function to traverse binary tree without recursion and

without stack */
void MorrisTraversal(struct tNode *root)
{
struct tNode *current,*pre;
if(root == NULL)
return;
current = root;
while(current != NULL)
{
if(current->left == NULL)
{
printf(" %d ", current->data);
}
else
{
/* Find the inorder predecessor of current */
pre = current->left;
while(pre->right != NULL && pre->right != current)
pre = pre->right;
/* Make current as right child of its inorder predecessor */

if(pre->right == NULL)
{
pre->right = current;
}

/* Revert the changes made in if part to restore the original
tree i.e., fix the right child of predecssor */
else
{
pre->right = NULL;
printf(" %d ",current->data);
} /* End of if condition pre->right == NULL */
} /* End of if condition current->left == NULL*/
} /* End of while */
}
/* Helper function that allocates a new tNode with the
struct tNode* newtNode(int data)
{
struct tNode* tNode = (struct tNode*)
malloc(sizeof(struct tNode));
tNode->data = data;
tNode->left = NULL;
tNode->right = NULL;
return(tNode);
}

int main()
{

1
/ \
2 3
/ \
4 5
*/
struct tNode *root = newtNode(1);
root->left = newtNode(2);
root->right = newtNode(3);
root->left->left = newtNode(4);
root->left->right = newtNode(5);
MorrisTraversal(root);
getchar();
return 0;
}

References:
www.liacs.nl/~deutz/DS/september28.pdf
http://comsci.liu.edu/~murali/algo/Morris.htm
www.scss.tcd.ie/disciplines/software_systems/…/HughGibbonsSlides.pdf
Please write comments if you find any bug in above code/algorithm, or want to share more information
about stack Morris Inorder Tree Traversal.
Root to leaf path sum equal to a given number
Given a binary tree and a number, return true if the tree has a root-to-leaf path such that adding up all the
values along the path equals the given number. Return false if no such path can be found.
For example, in the above tree root to leaf paths exist with following sums.
21 –> 10 – 8 – 3
23 –> 10 – 8 – 5
14 –> 10 – 2 – 2
So the returned value should be true only for numbers 21, 23 and 14. For any other number, returned value
should be false.
Algorithm:
Recursively check if left or right child has path sum equal to ( number – value at current node)
Implementation:
#include<stdio.h>
#include<stdlib.h>
#define bool int

struct node
{
int data;
struct node* left;
struct node* right;
};
/*
Given a tree and a sum, return true if there is a path from the root
down to a leaf, such that adding up all the values along the path
equals the given sum.
Strategy: subtract the node value from the sum when recurring down,
and check to see if the sum is 0 when you run out of tree.
*/
bool hasPathSum(struct node* node, int sum)
{
/* return true if we run out of tree and sum==0 */
if (node == NULL)
{
return (sum == 0);
}

else
{
{
bool ans = 0;

/* otherwise check both subtrees */
int subSum = sum - node->data;

/* If we reach a leaf node and sum becomes 0 then return true*/
if ( subSum == 0 && node->left == NULL && node->right == NULL )
return 1;

if(node->left)
ans = ans || hasPathSum(node->left, subSum);
if(node->right)
ans = ans || hasPathSum(node->right, subSum);

return ans;
}
}
struct node* newnode(int data)
{
node->data = data;
node->left = NULL;
node->right = NULL;
return(node);
}

int main()
{
int sum = 21;

10
/ \
8 2
/ \ /
3 5 2
*/
struct node *root = newnode(10);
root->left = newnode(8);
root->right = newnode(2);
root->left->left = newnode(3);
root->left->right = newnode(5);
root->right->left = newnode(2);
if(hasPathSum(root, sum))
printf("There is a root-to-leaf path with sum %d", sum);
else
printf("There is no root-to-leaf path with sum %d", sum);
getchar();
return 0;
}

References:
Author: Tushar Roy
problem
Maximum difference between two elements such that larger element
appears after the smaller number
Given an array arr[] of integers, find out the difference between any two elements such that larger
element appears after the smaller number in arr[].
Examples: If array is [2, 3, 10, 6, 4, 8, 1] then returned value should be 8 (Diff between 10 and 2). If array is [
7, 9, 5, 6, 3, 2 ] then returned value should be 2 (Diff between 7 and 9)
Method 1 (Simple)
Use two loops. In the outer loop, pick elements one by one and in the inner loop calculate the difference of
the picked element with every other element in the array and compare the difference with the maximum
difference calculated so far.
#include<stdio.h>
/* The function assumes that there are at least two

elements in array.
The function returns a negative value if the array is
sorted in decreasing order.
Returns 0 if elements are equal */
int maxDiff(int arr[], int arr_size)
{
int max_diff = arr[1] - arr[0];
int i, j;
{
for(j = i+1; j < arr_size; j++)
{
if(arr[j] - arr[i] > max_diff)
max_diff = arr[j] - arr[i];
}
}
return max_diff;
}

int main()
{
int arr[] = {1, 2, 90, 10, 110};
printf("Maximum difference is %d", maxDiff(arr, 5));
getchar();
return 0;
}


Method 2 (Tricky and Efficient)

In this method, instead of taking difference of the picked element with every other element, we take the
difference with the minimum element found so far. So we need to keep track of 2 things:
1) Maximum difference found so far (max_diff).
2) Minimum number visited so far (min_element).

#include<stdio.h>
/* The function assumes that there are at least two

elements in array.
The function returns a negative value if the array is
sorted in decreasing order.
Returns 0 if elements are equal */
int maxDiff(int arr[], int arr_size)
{
int max_diff = arr[1] - arr[0];
int min_element = arr[0];
int i;
{
if(arr[i] - min_element > max_diff)
max_diff = arr[i] - min_element;
if(arr[i] < min_element)
min_element = arr[i];
}
return max_diff;
}

int main()
{
int arr[] = {1, 2, 6, 80, 100};
int size = sizeof(arr)/sizeof(arr[0]);
printf("Maximum difference is %d", maxDiff(arr, size));
getchar();
return 0;
}


Method 3 (Another Tricky Solution)

First find the difference between the adjacent elements of the array and store all differences in an auxiliary
array diff[] of size n-1. Now this problems turns into finding the maximum sum subarray of this difference
array.
Thanks to Shubham Mittal for suggesting this solution.

#include<stdio.h>
int maxDiff(int arr[], int n)

{
// Create a diff array of size n-1. The array will hold
// the difference of adjacent elements
int diff[n-1];
for (int i=0; i < n-1; i++)
diff[i] = arr[i+1] - arr[i];
// Now find the maximum sum subarray in diff array

int max_diff = diff[0];
for (int i=1; i<n-1; i++)
{
if (diff[i-1] > 0)
diff[i] += diff[i-1];
if (max_diff < diff[i])
max_diff = diff[i];
}
return max_diff;
}

int main()
{
int arr[] = {80, 2, 6, 3, 100};
printf("Maximum difference is %d", maxDiff(arr, size));
return 0;
}

Output:

98

This method is also O(n) time complexity solution, but it requires O(n) extra space

We can modify the above method to work in O(1) extra space. Instead of creating an auxiliary array, we can
calculate diff and max sum in same loop. Following is the space optimized version.

int maxDiff (int arr[], int n)

{
// Initialize diff, current sum and max sum
int diff = arr[1]-arr[0];
int curr_sum = diff;
int max_sum = curr_sum;
for(int i=1; i<n-1; i++)

{
// Calculate current diff
diff = arr[i+1]-arr[i];
// Calculate current sum

if (curr_sum > 0)
curr_sum += diff;
else
curr_sum = diff;
// Update max sum, if needed

if (curr_sum > max_sum)
max_sum = curr_sum;
}
return max_sum;
}


problem
Check for balanced parentheses in an expression
Given an expression string exp, write a program to examine whether the pairs and the orders of
“{“,”}”,”(“,”)”,”[“,”]” are correct in exp. For example, the program should print true for exp = “[()]{}{[()()]()}”
and false for exp = “[(])”
Algorithm:
1) Declare a character stack S.
2) Now traverse the expression string exp.
a) If the current character is a starting bracket (‘(‘ or ‘{‘ or ‘[‘) then push it to stack.
b) If the current character is a closing bracket (‘)’ or ‘}’ or ‘]’) then pop from stack and if the popped
character is the matching starting bracket then fine else parenthesis are not balanced.
3) After complete traversal, if there is some starting bracket left in stack then “not balanced”
Implementation:
#include<stdio.h>
#include<stdlib.h>
#define bool int

struct sNode
{
char data;
struct sNode *next;
};


/* Returns 1 if character1 and character2 are matching left

and right Parenthesis */
bool isMatchingPair(char character1, char character2)
{
if(character1 == '(' && character2 == ')')
return 1;
else if(character1 == '{' && character2 == '}')
return 1;
else if(character1 == '[' && character2 == ']')
return 1;
else
return 0;
}
/*Return 1 if expression has balanced Parenthesis */

bool areParenthesisBalanced(char exp[])
{
int i = 0;
/* Declare an empty character stack */

struct sNode *stack = NULL;
/* Traverse the given expression to check matching parenthesis */

while(exp[i])
{
/*If the exp[i] is a starting parenthesis then push it*/
if(exp[i] == '{' || exp[i] == '(' || exp[i] == '[')
if(exp[i] == '{' || exp[i] == '(' || exp[i] == '[')
push(&stack, exp[i]);
/* If exp[i] is a ending parenthesis then pop from stack and

check if the popped parenthesis is a matching pair*/
if(exp[i] == '}' || exp[i] == ')' || exp[i] == ']')
{

/*If we see an ending parenthesis without a pair then return false*/
if(stack == NULL)
return 0;
/* Pop the top element from stack, if it is not a pair

parenthesis of character then there is a mismatch.
This happens for expressions like {(}) */
else if ( !isMatchingPair(pop(&stack), exp[i]) )
return 0;
}
i++;
}

/* If there is something left in expression then there is a starting
parenthesis without a closing parenthesis */
if(stack == NULL)
return 1; /*balanced*/
else
return 0; /*not balanced*/
}
/*driver program to test above functions*/
int main()
{
char exp[100] = "{()}[]";
if(areParenthesisBalanced(exp))
printf("\n Balanced ");
else
printf("\n Not Balanced "); \
getchar();
}

{
/* allocate node */
{
getchar();
exit(0);
}



}
{
char res;
struct sNode *top;

{
getchar();
exit(0);
}
else
{
top = *top_ref;
res = top->data;
free(top);
return res;
}
}


Auxiliary Space: O(n) for stack.
problem
Do not use sizeof for array parameters
Consider the below program.
#include<stdio.h>
void fun(int arr[])
{
int i;
/* sizeof should not be used here to get number

of elements in array*/
int arr_size = sizeof(arr)/sizeof(arr[0]); /* incorrect use of siseof*/
for (i = 0; i < arr_size; i++)
{
arr[i] = i; /*executed only once */
}
}
int main()
{
int i;
int arr[4] = {0, 0 ,0, 0};
fun(arr);

/* use of sizeof is fine here*/
for(i = 0; i < sizeof(arr)/sizeof(arr[0]); i++)
printf(" %d " ,arr[i]);
getchar();
return 0;
}

Output: 0 0 0 0 on a IA-32 machine.
The function fun() receives an array parameter arr[] and tries to find out number of elements in arr[] using
sizeof operator.
In C, array parameters are treated as pointers (See http://geeksforgeeks.org/?p=4088 for details). So the
expression sizeof(arr)/sizeof(arr[0]) becomes sizeof(int *)/sizeof(int) which results in 1 for IA 32 bit machine
(size of int and int * is 4) and the for loop inside fun() is executed only once irrespective of the size of the
array.
Therefore, sizeof should not be used to get number of elements in such cases. A separate parameter for array
size (or length) should be passed to fun(). So the corrected program is:

#include<stdio.h>
void fun(int arr[], size_t arr_size)
{
int i;
{
arr[i] = i;
}
}
int main()
{
int i;
int arr[4] = {0, 0 ,0, 0};
fun(arr, 4);

for(i = 0; i < sizeof(arr)/sizeof(arr[0]); i++)
printf(" %d ", arr[i]);
getchar();
return 0;
}

Please write comments if you find anything incorrect in the above article or you want to share more
Construct Tree from given Inorder and Preorder traversals
Let us consider the below traversals:
Inorder sequence: D B E A F C
Preorder sequence: A B D E C F
In a Preorder sequence, leftmost element is the root of the tree. So we know ‘A’ is root for given sequences.
By searching ‘A’ in Inorder sequence, we can find out all elements on left side of ‘A’ are in left subtree and
elements on right are in right subtree. So we know below structure now.
A
/ \
/ \
D B E F C

We recursively follow above steps and get the following tree.
A
/ \
/ \
B C
/ \ /
/ \ /
D E F

Algorithm: buildTree()
1) Pick an element from Preorder. Increment a Preorder Index Variable (preIndex in below code) to pick
next element in next recursive call.
2) Create a new tree node tNode with the data as picked element.
3) Find the picked element’s index in Inorder. Let the index be inIndex.
4) Call buildTree for elements before inIndex and make the built tree as left subtree of tNode.
5) Call buildTree for elements after inIndex and make the built tree as right subtree of tNode.
6) return tNode.
Thanks to Rohini and Tushar for suggesting the code.
/* program to construct tree using inorder and preorder traversals */

#include<stdio.h>
#include<stdlib.h>

struct node
{
char data;
struct node* left;
struct node* right;
};
/* Prototypes for utility functions */

/* Prototypes for utility functions */
int search(char arr[], int strt, int end, char value);
struct node* newNode(char data);
/* Recursive function to construct binary of size len from

Inorder traversal in[] and Preorder traversal pre[]. Initial values
of inStrt and inEnd should be 0 and len -1. The function doesn't
do any error checking for cases where inorder and preorder
do not form a tree */
struct node* buildTree(char in[], char pre[], int inStrt, int inEnd)
{
static int preIndex = 0;
if(inStrt > inEnd)

return NULL;
/* Pick current node from Preorder traversal using preIndex

and increment preIndex */
struct node *tNode = newNode(pre[preIndex++]);
/* If this node has no children then return */

if(inStrt == inEnd)
return tNode;
/* Else find the index of this node in Inorder traversal */

int inIndex = search(in, inStrt, inEnd, tNode->data);
/* Using index in Inorder traversal, construct left and

right subtress */
tNode->left = buildTree(in, pre, inStrt, inIndex-1);
tNode->right = buildTree(in, pre, inIndex+1, inEnd);
return tNode;
}
/* Function to find index of value in arr[start...end]
The function assumes that value is present in in[] */
int search(char arr[], int strt, int end, char value)
{
int i;
for(i = strt; i <= end; i++)
{
if(arr[i] == value)
return i;
}
}

struct node* newNode(char data)
{
struct node* node = (struct node*)malloc(sizeof(struct node));
node->data = data;
node->left = NULL;
node->right = NULL;
return(node);
}
/* This funtcion is here just to test buildTree() */

{
if (node == NULL)
return;


printf("%c ", node->data);

}

int main()
{
char in[] = {'D', 'B', 'E', 'A', 'F', 'C'};
char pre[] = {'A', 'B', 'D', 'E', 'C', 'F'};
int len = sizeof(in)/sizeof(in[0]);
struct node *root = buildTree(in, pre, 0, len - 1);
/* Let us test the built tree by printing Insorder traversal */

printInorder(root);
getchar();
}

Time Complexity: O(n^2). Worst case occurs when tree is left skewed. Example Preorder and Inorder
traversals for worst case are {A, B, C, D} and {D, C, B, A}.
problem.
Given a binary tree, print all root-to-leaf paths
For the below example tree, all root-to-leaf paths are:
10 –> 8 –> 3
10 –> 8 –> 5
10 –> 2 –> 2
Algorithm:
Use a path array path[] to store current root to leaf path. Traverse from root to all leaves in top-down
fashion. While traversing, store data of all nodes in current path in array path[]. When we reach a leaf node,
print the path array.
#include<stdio.h>
#include<stdlib.h>

struct node
{
int data;
struct node* left;
struct node* right;
};
/* Prototypes for funtions needed in printPaths() */

void printPathsRecur(struct node* node, int path[], int pathLen);
void printArray(int ints[], int len);
/*Given a binary tree, print out all of its root-to-leaf

paths, one per line. Uses a recursive helper to do the work.*/
void printPaths(struct node* node)
{
int path[1000];
printPathsRecur(node, path, 0);
}
/* Recursive helper function -- given a node, and an array containing

the path from the root node up to but not including this node,
print out all the root-leaf paths.*/
void printPathsRecur(struct node* node, int path[], int pathLen)
{
if (node==NULL)
return;
/* append this node to the path array */

path[pathLen] = node->data;
pathLen++;

if (node->left==NULL && node->right==NULL)
{
printArray(path, pathLen);
}
else
{
/* otherwise try both subtrees */
printPathsRecur(node->left, path, pathLen);
printPathsRecur(node->right, path, pathLen);
}
}
/* Utility that prints out an array on a line. */
void printArray(int ints[], int len)
{
int i;
for (i=0; i<len; i++)
{
printf("%d ", ints[i]);
}
printf("\n");
}
/* utility that allocates a new node with the

{
node->data = data;
node->left = NULL;
node->right = NULL;

return(node);
}

int main()
{

10
/ \
8 2
/ \ /
3 5 2
*/
root->right->left = newnode(2);

printPaths(root);

getchar();
return 0;
}

References:
problem.
Move last element to front of a given Linked List
Write a C function that moves last element to front in a given Singly Linked List. For example, if the given
Linked List is 1->2->3->4->5, then the function should change the list to 5->1->2->3->4.
Algorithm:
Traverse the list till last node. Use two pointers: one to store the address of last node and other for address of
second last node. After the end of loop do following operations.
i) Make second last as last (secLast->next = NULL).
ii) Set next of last as head (last->next = *head_ref).
iii) Make last as head ( *head_ref = last)
/* Program to move last element to front in a given linked list */

#include<stdio.h>
#include<stdlib.h>

struct node
{
int data;
struct node *next;
};
/* We are using a double pointer head_ref here because we change

head of the linked list inside this function.*/
void moveToFront(struct node **head_ref)
{
/* If linked list is empty, or it contains only one node,
then nothing needs to be done, simply return */
if(*head_ref == NULL || (*head_ref)->next == NULL)
return;

/* Initialize second last and last pointers */
struct node *secLast = NULL;
struct node *last = *head_ref;

/*After this loop secLast contains address of second last
node and last contains address of last node in Linked List */
while(last->next != NULL)
{
secLast = last;
last = last->next;
}

/* Set the next of second last as NULL */
secLast->next = NULL;

/* Set next of last as head node */
last->next = *head_ref;

/* Change the head pointer to point to last node now */
*head_ref = last;
}
/* Function to add a node at the begining of Linked List */
{
/* allocate node */



}

{
while(node != NULL)
{
node = node->next;
}
}

int main()
{

1->2->3->4->5 */
push(&start, 5);
push(&start, 4);
push(&start, 3);
push(&start, 2);
push(&start, 1);
printf("\n Linked list before moving last to front ");

printList(start);
moveToFront(&start);
printf("\n Linked list after removing last to front ");

printList(start);
getchar();
}

Time Complexity: O(n) where n is the number of nodes in the given Linked List.
problem.
Practice questions for Linked List and Recursion
Assume the structure of a Linked List node is as follows.
struct node
{
int data;
struct node *next;
};

Explain the functionality of following C functions.
1. What does the following function do for a given Linked List?
void fun1(struct node* head)

{
if(head == NULL)
return;

fun1(head->next);
}

fun1() prints the given Linked List in reverse manner. For Linked List 1->2->3->4->5, fun1() prints 5->4->3-
>2->1.
2. What does the following function do for a given Linked List ?

{
if(head== NULL)
return;
if(head->next != NULL )
fun2(head->next->next);
}

fun2() prints alternate nodes of the given Linked List, first from head to end, and then from end to head. If
Linked List has even number of nodes, then fun2() skips the last node. For Linked List 1->2->3->4->5,
fun2() prints 1 3 5 5 3 1. For Linked List 1->2->3->4->5->6, fun2() prints 1 3 5 5 3 1.
Below is a complete running program to test above functions.
#include<stdio.h>
#include<stdlib.h>
#include<stdlib.h>

struct node
{
int data;
struct node *next;
};
/* Prints a linked list in reverse manner */

{
if(head == NULL)
return;
fun1(head->next);
}
/* prints alternate nodes of a Linked List, first

from head to end, and then from end to head. */
void fun2(struct node* start)
{
if(start == NULL)
return;
printf("%d ", start->data);
if(start->next != NULL )
fun2(start->next->next);
printf("%d ", start->data);
}
/* UTILITY FUNCTIONS TO TEST fun1() and fun2() */

of the list. */
{
/* allocate node */



}

/* Drier program to test above functions */
int main()
{
/* Using push() to construct below list

1->2->3->4->5 */
push(&head, 5);
push(&head, 4);
push(&head, 3);
push(&head, 2);
push(&head, 2);
push(&head, 1);

printf("\n Output of fun1() for list 1->2->3->4->5 \n");
fun1(head);
printf("\n Output of fun2() for list 1->2->3->4->5 \n");

fun2(head);

getchar();
return 0;
}

Quine – A self-reproducing program
A quine is a program which prints a copy of its own as the only output. A quine takes no input. Quines are
named after the American mathematician and logician Willard Van Orman Quine (1908–2000). The
interesting thing is you are not allowed to use open and then print file of the program.
To the best of our knowledge, below is the shortest quine in C.
main() { char *s="main() { char *s=%c%s%c; printf(s,34,s,34); }"; printf(s,34,s,34); }

This program uses the printf function without including its corresponding header (#include ), which can
result in undefined behavior. Also, the return type declaration for main has been left off to reduce the length
of the program. Two 34s are used to print double quotes around the string s.
Following is a shorter version of the above program suggested by Narendra.
main(a){printf(a="main(a){printf(a=%c%s%c,34,a,34);}",34,a,34);}

If you find a shorter C quine or you want to share quine in other programming languages, then please do
write in the comment section.
Source:
http://en.wikipedia.org/wiki/Quine_%28computing%29
Union and Intersection of two sorted arrays
Given two sorted arrays, find their union and intersection.
For example, if the input arrays are:

arr1[] = {1, 3, 4, 5, 7}
arr2[] = {2, 3, 5, 6}
Then your program should print Union as {1, 2, 3, 4, 5, 6, 7} and Intersection as {3, 5}.
Algorithm Union(arr1[], arr2[]):

For union of two arrays, follow the following merge procedure.
1) Use two index variables i and j, initial values i = 0, j = 0
2) If arr1[i] is smaller than arr2[j] then print arr1[i] and increment i.
3) If arr1[i] is greater than arr2[j] then print arr2[j] and increment j.
4) If both are same then print any of them and increment both i and j.
5) Print remaining elements of the larger array.
#include<stdio.h>
/* Function prints union of arr1[] and arr2[]

m is the number of elements in arr1[]
n is the number of elements in arr2[] */
int printUnion(int arr1[], int arr2[], int m, int n)
{
int i = 0, j = 0;
while (i < m && j < n)
{
if (arr1[i] < arr2[j])
printf(" %d ", arr1[i++]);
else if (arr2[j] < arr1[i])
printf(" %d ", arr2[j++]);
else
{
i++;
}
}
/* Print remaining elements of the larger array */

while(i < m)
printf(" %d ", arr1[i++]);
while(j < n)
}

int main()
{
int arr1[] = {1, 2, 4, 5, 6};
int arr2[] = {2, 3, 5, 7};
int m = sizeof(arr1)/sizeof(arr1[0]);
int n = sizeof(arr2)/sizeof(arr2[0]);
printUnion(arr1, arr2, m, n);
getchar();
return 0;
}

Algorithm Intersection(arr1[], arr2[]):

For Intersection of two arrays, print the element only if the element is present in both arrays.
1) Use two index variables i and j, initial values i = 0, j = 0
2) If arr1[i] is smaller than arr2[j] then increment i.
3) If arr1[i] is greater than arr2[j] then increment j.
4) If both are same then print any of them and increment both i and j.
#include<stdio.h>
/* Function prints Intersection of arr1[] and arr2[]

m is the number of elements in arr1[]
n is the number of elements in arr2[] */
int printIntersection(int arr1[], int arr2[], int m, int n)
{
int i = 0, j = 0;
{
i++;
else if (arr2[j] < arr1[i])
j++;
else /* if arr1[i] == arr2[j] */
{
i++;
}
}
}

int main()
{
int arr1[] = {1, 2, 4, 5, 6};
int arr2[] = {2, 3, 5, 7};
printIntersection(arr1, arr2, m, n);
getchar();
return 0;
}

Another approach that is useful when difference between sizes of two given arrays is
significant.
The idea is to iterate through the shorter array and do a binary search for every element of short array in big
array (note that arrays are sorted). Time complexity of this solution is O(min(mLogn, nLogm)). This solution
works better than the above approach when ratio of larger length to smaller is more than logarithmic order.
See following post for unsorted arrays.

Find Union and Intersection of two unsorted arrays
problem.
Reverse a stack using recursion
You are not allowed to use loop constructs like while, for..etc, and you can only use the following ADT
functions on Stack S:
isEmpty(S)
push(S)
pop(S)
Solution:
The idea of the solution is to hold all values in Function Call Stack until the stack becomes empty. When the
stack becomes empty, insert all held items one by one at the bottom of the stack.
For example, let the input stack be

First 4 is inserted at the bottom.
4
So we need a function that inserts at the bottom of a stack using the above given basi
c stack function. //Below is a recursive function that inserts an element at the botto
m of a stack.

void insertAtBottom(struct sNode** top_ref, int item)
{
int temp;
if(isEmpty(*top_ref))
{
push(top_ref, item);
}
else
{

/* Hold all items in Function Call Stack until we reach end of
the stack. When the stack becomes empty, the isEmpty(*top_ref)
becomes true, the above if part is executed and the item is
inserted at the bottom */
temp = pop(top_ref);
insertAtBottom(top_ref, item);
/* Once the item is inserted at the bottom, push all the

items held in Function Call Stack */
push(top_ref, temp);
}
}

//Below is the function that reverses the given stack using insertAtBottom()

void reverse(struct sNode** top_ref)
{
int temp;
if(!isEmpty(*top_ref))
{

/* Hold all items in Function Call Stack until we reach end of
the stack */
temp = pop(top_ref);
reverse(top_ref);
/* Insert all the items (held in Function Call Stack) one by one
from the bottom to top. Every item is inserted at the bottom */
insertAtBottom(top_ref, temp);
}
}

//Below is a complete running program for testing above functions.

#include<stdio.h>
#include<stdlib.h>
#define bool int

struct sNode
{
char data;
struct sNode *next;
};
/* Function Prototypes */
bool isEmpty(struct sNode* top);
void print(struct sNode* top);
/* Driveer program to test above functions */

int main()
{
struct sNode *s = NULL;
push(&s, 4);
push(&s, 3);
push(&s, 2);
push(&s, 1);
printf("\n Original Stack ");

print(s);
reverse(&s);
printf("\n Reversed Stack ");
print(s);
getchar();
}
/* Function to check if the stack is empty */

bool isEmpty(struct sNode* top)
{
return (top == NULL)? 1 : 0;
}

{
/* allocate node */
{
getchar();
exit(0);
}



}

{
char res;
struct sNode *top;

{
getchar();
exit(0);
}
else
{
top = *top_ref;
res = top->data;
free(top);
return res;
}
}
/* Functrion to pront a linked list */

void print(struct sNode* top)
{
printf("\n");
while(top != NULL)
{
printf(" %d ", top->data);
top = top->next;
}
}

Please write comments if you find any bug in above code/algorithm, or find other ways
to solve the same problem.

Pairwise swap elements of a given linked list
Given a singly linked list, write a function to swap elements pairwise. For example, if the linked list is 1->2-
>3->4->5 then the function should change it to 2->1->4->3->5, and if the linked list is 1->2->3->4->5->6
then the function should change it to 2->1->4->3->6->5.
METHOD 1 (Iterative)
Start from the head node and traverse the list. While traversing swap data of each node with its next node’s
data.
/* Program to pairwise swap elements in a given linked list */

#include<stdio.h>
#include<stdlib.h>

struct node
{
int data;
struct node *next;
};
/*Function to swap two integers at addresses a and b */

void swap(int *a, int *b);
/* Function to pairwise swap elements of a linked list */

void pairWiseSwap(struct node *head)
{
/* Traverse further only if there are at-least two nodes left */

while (temp != NULL && temp->next != NULL)
{
/* Swap data of node with its next node's data */
swap(&temp->data, &temp->next->data);
/* Move temp by 2 for the next pair */

temp = temp->next->next;
}
}
/* Function to swap two integers */
void swap(int *a, int *b)
{
int temp;
temp = *a;
*a = *b;
*b = temp;
}

{
/* allocate node */



}

{
while (node != NULL)
{
node = node->next;
}
}

int main()
{

1->2->3->4->5 */
push(&start, 5);
push(&start, 4);
push(&start, 3);
push(&start, 2);
push(&start, 1);
printf("\n Linked list before calling pairWiseSwap() ");

printList(start);
pairWiseSwap(start);
printf("\n Linked list after calling pairWiseSwap() ");

printList(start);
getchar();
return 0;
}

METHOD 2 (Recursive)
If there are 2 or more than 2 nodes in Linked List then swap the first two nodes and recursively call for rest
of the list.

/* Recursive function to pairwise swap elements of a linked list */

void pairWiseSwap(struct node *head)
{
/* There must be at-least two nodes in the list */
if(head != NULL && head->next != NULL)
{
/* Swap the node's data with data of next node */
swap(&head->data, &head->next->data);

/* Call pairWiseSwap() for rest of the list */
pairWiseSwap(head->next->next);
}
}

The solution provided there swaps data of nodes. If data contains many fields, there will be many swap
operations. See this for an implementation that changes links rather than swapping data.
problem.
Double Tree
Write a program that converts a given tree to its Double tree. To create Double tree of the given tree, create a
new duplicate for each node, and insert the duplicate as the left child of the original node.
So the tree…

2
/ \
1 3

is changed to…

2
/ \
2 3
/ /
1 3
/
1

And the tree
1
/ \
2 3
/ \
4 5

is changed to
1
/ \
1 3
/ /
2 3
/ \
2 5
/ /
4 5
/
4

Algorithm:
Recursively convert the tree to double tree in postorder fashion. For each node, first convert the left subtree
of the node, then right subtree, finally create a duplicate node of the node and fix the left child of the node
and left child of left child.
Implementation:
#include <stdio.h>
#include <stdlib.h>

struct node
{
int data;
struct node* left;
struct node* right;
};

/* function to create a new node of tree and returns pointer */

/* Function to convert a tree to double tree */
void doubleTree(struct node* node)
{
struct node* oldLeft;
doubleTree(node->left);
doubleTree(node->right);
/* duplicate this node to its left */

oldLeft = node->left;
node->left = newNode(node->data);
node->left->left = oldLeft;
}

/* UTILITY FUNCTIONS TO TEST doubleTree() FUNCTION */
{
node->data = data;
node->left = NULL;
node->right = NULL;

return(node);
}
/* Given a binary tree, print its nodes in inorder*/

{
if (node == NULL)
return;
}

int main()
{

1
/ \
2 3
/ \
4 5
*/

printf("Inorder traversal of the original tree is \n");
printInorder(root);
doubleTree(root);

printf("\n Inorder traversal of the double tree is \n");
printInorder(root);

getchar();
return 0;
}

Time Complexity: O(n) where n is the number of nodes in the tree.
References:
problem.
Print all combinations of points that can compose a given number
You can win three kinds of basketball points, 1 point, 2 points, and 3 points. Given a total score n, print out
all the combination to compose n.
Examples:
For n = 1, the program should print following:
1

1 1
2

1 1 1
1 2
2 1
3

1 1 1 1
1 1 2
1 2 1
1 3
2 1 1
2 2
3 1
and so on …
Algorithm:
At first position we can have three numbers 1 or 2 or 3.
First put 1 at first position and recursively call for n-1.
Then put 2 at first position and recursively call for n-2.
Then put 3 at first position and recursively call for n-3.
If n becomes 0 then we have formed a combination that compose n, so print the current combination.
Below is a generalized implementation. In the below implementation, we can change MAX_POINT if there
are higher points (more than 3) in the basketball game.

#define MAX_POINT 3
#define ARR_SIZE 100
#include<stdio.h>
/* Utility function to print array arr[] */

void printArray(int arr[], int arr_size);
/* The function prints all combinations of numbers 1, 2, ...MAX_POINT

that sum up to n.
i is used in recursion keep track of index in arr[] where next
element is to be added. Initital value of i must be passed as 0 */
void printCompositions(int n, int i)
{
/* array must be static as we want to keep track

of values stored in arr[] using current calls of
printCompositions() in function call stack*/
static int arr[ARR_SIZE];
if (n == 0)
{
printArray(arr, i);
}
else if(n > 0)
{
int k;
for (k = 1; k <= MAX_POINT; k++)
{
arr[i]= k;
printCompositions(n-k, i+1);
}
}
}
void printArray(int arr[], int arr_size)
{
int i;
printf("\n");
}

int main()
{
int n = 5;
printf("Differnt compositions formed by 1, 2 and 3 of %d are\n", n);
printCompositions(n, 0);
getchar();
return 0;
}

Asked by Aloe
problem.
Reverse words in a given string
Example: Let the input string be “i like this program very much”. The function should change the string to
“much very program this like i”
Algorithm:
1) Reverse the individual words, we get the below string.

"i ekil siht margorp yrev hcum"
2) Reverse the whole string from start to end and you get the desired output.
"much very program this like i"

#include<stdio.h>
/* function prototype for utility function to

reverse a string from begin to end */
void reverse(char *begin, char *end);
/*Function to reverse words*/

void reverseWords(char *s)
{
char *word_begin = s;
char *temp = s; /* temp is for word boundry */
/*STEP 1 of the above algorithm */

while( *temp )
{
temp++;
if (*temp == '\0')
{
reverse(word_begin, temp-1);
}
else if(*temp == ' ')
{
reverse(word_begin, temp-1);
word_begin = temp+1;
}

reverse(s, temp-1);
}
/*Function to reverse any sequence starting with pointer
begin and ending with pointer end */
void reverse(char *begin, char *end)
{
char temp;
while (begin < end)
{
temp = *begin;
*begin++ = *end;
*end-- = temp;
}
}

int main()
{
char s[] = "i like this program very much";
char *temp = s;
reverseWords(s);
printf("%s", s);
getchar();
return 0;
}

The above code doesn’t handle the cases when the string starts with space. The following version handles
this specific case and doesn’t make unnecessary calls to reverse function in the case of multiple space in
between. Thanks to rka143 for providing this version.
void reverseWords(char *s)

{
char *word_begin = NULL;
char *temp = s; /* temp is for word boundry */

while( *temp )
{
/*This condition is to make sure that the string start with
valid character (not space) only*/
if (( word_begin == NULL ) && (*temp != ' ') )
{
word_begin=temp;
}
if(word_begin && ((*(temp+1) == ' ') || (*(temp+1) == '\0')))
{
reverse(word_begin, temp);
word_begin = NULL;
}
temp++;

reverse(s, temp-1);
}

problem.
Delete a node in a Doubly Linked List
Write a function to delete a given node in a doubly linked list.

(a) Original Doubly Linked List

(a) After deletion of head node

(a) After deletion of middle node

(a) After deletion of last node

Algorithm
Let the node to be deleted is del.
1) If node to be deleted is head node, then change the head pointer to next current head.
2) Set next of previous to del, if previous to del exixts.
3) Set prev of next to del, if next to del exixts.
#include <stdio.h>
#include <stdlib.h>

struct node
{
int data;
struct node *next;
struct node *prev;
};
/* Function to delete a node in a Doubly Linked List.

head_ref --> pointer to head node pointer.
del --> pointer to node to be deleted. */
void deleteNode(struct node **head_ref, struct node *del)
{
/* base case */
if(*head_ref == NULL || del == NULL)
return;
/* If node to be deleted is head node */

if(*head_ref == del)
*head_ref = del->next;
/* Change next only if node to be deleted is NOT the last node */

if(del->next != NULL)
del->next->prev = del->prev;
/* Change prev only if node to be deleted is NOT the first node */

if(del->prev != NULL)
del->prev->next = del->next;
/* Finally, free the memory occupied by del*/

free(del);
return;
}
/* Function to insert a node at the beginning of the Doubly Linked List */
{
/* allocate node */





}

{
while(node!=NULL)
{
node = node->next;
}
}

int main()
{
/* Let us create the doubly linked list 10<->8<->4<->2 */

push(&head, 2);
push(&head, 4);
push(&head, 8);
push(&head, 10);

printList(head);
/* delete nodes from the doubly linked list */

deleteNode(&head, head); /*delete first node*/
deleteNode(&head, head->next); /*delete middle node*/
deleteNode(&head, head->next); /*delete last node*/
/* Modified linked list will be NULL<-8->NULL */

printf("\n Modified Linked list ");
printList(head);
getchar();
}


the same problem.
G-Fact 7
“Pointer arithmetic and array indexing [that] are equivalent in C, pointers and arrays are different” – Wayne
Throop
References:
http://c-faq.com/aryptr/aryptrequiv.html
Floor and Ceiling in a sorted array
Given a sorted array and a value x, the ceiling of x is the smallest element in array greater than or equal to x,
and the floor is the greatest element smaller than or equal to x. Assume than the array is sorted in non-
decreasing order. Write efficient functions to find floor and ceiling of x.
For example, let the input array be {1, 2, 8, 10, 10, 12, 19}
For x = 0: floor doesn't exist in array, ceil = 1
For x = 1: floor = 1, ceil = 1
For x = 5: floor = 2, ceil = 8
For x = 20: floor = 19, ceil doesn't exist in array

In below methods, we have implemented only ceiling search functions. Floor search can be implemented in
the same way.
Method 1 (Linear Search)

Algorithm to search ceiling of x:
1) If x is smaller than or equal to the first element in array then return 0(index of first element)
2) Else Linearly search for an index i such that x lies between arr[i] and arr[i+1].
3) If we do not find an index i in step 2, then return -1

#include<stdio.h>
/* Function to get index of ceiling of x in arr[low..high] */

int ceilSearch(int arr[], int low, int high, int x)
{
int i;
/* If x is smaller than or equal to first element,

then return the first element */
if(x <= arr[low])
return low;
/* Otherwise, linearly search for ceil value */

for(i = low; i < high; i++)
{
if(arr[i] == x)
return i;
/* if x lies between arr[i] and arr[i+1] including

arr[i+1], then return arr[i+1] */
if(arr[i] < x && arr[i+1] >= x)
return i+1;
}
/* If we reach here then x is greater than the last element

of the array, return -1 in this case */
return -1;
}

int main()
{
int arr[] = {1, 2, 8, 10, 10, 12, 19};
int x = 3;
int index = ceilSearch(arr, 0, n-1, x);
if(index == -1)
printf("Ceiling of %d doesn't exist in array ", x);
else
printf("ceiling of %d is %d", x, arr[index]);
getchar();
return 0;
}

Method 2 (Binary Search)

Instead of using linear search, binary search is used here to find out the index. Binary search reduces time
complexity to O(Logn).

#include<stdio.h>
/* Function to get index of ceiling of x in arr[low..high]*/

{
int mid;
/* If x is smaller than or equal to the first element,

if(x <= arr[low])
return low;
/* If x is greater than the last element, then return -1 */

if(x > arr[high])
return -1;
/* get the index of middle element of arr[low..high]*/

mid = (low + high)/2; /* low + (high - low)/2 */
/* If x is same as middle element, then return mid */

if(arr[mid] == x)
return mid;

/* If x is greater than arr[mid], then either arr[mid + 1]
is ceiling of x or ceiling lies in arr[mid+1...high] */
else if(arr[mid] < x)
{
if(mid + 1 <= high && x <= arr[mid+1])
return mid + 1;
else
return ceilSearch(arr, mid+1, high, x);
}
/* If x is smaller than arr[mid], then either arr[mid]

is ceiling of x or ceiling lies in arr[mid-1...high] */
else
{
if(mid - 1 >= low && x > arr[mid-1])
return mid;
else
return ceilSearch(arr, low, mid - 1, x);
}
}

int main()
{
int arr[] = {1, 2, 8, 10, 10, 12, 19};
int x = 20;
int index = ceilSearch(arr, 0, n-1, x);
if(index == -1)
printf("Ceiling of %d doesn't exist in array ", x);
else
printf("ceiling of %d is %d", x, arr[index]);
getchar();
return 0;
}

the same problem, or want to share code for floor implementation.
Practice Questions for Recursion | Set 1
Explain the functionality of following functions.
Question 1
int fun1(int x, int y)

{
if(x == 0)
return y;
else
return fun1(x - 1, x + y);
}

Answer: The function fun() calculates and returns ((1 + 2 … + x-1 + x) +y) which is x(x+1)/2 + y. For example
if x is 5 and y is 2, then fun should return 15 + 2 = 17.
Question 2
void fun2(int arr[], int start_index, int end_index)

{
if(start_index >= end_index)
return;
int min_index;
int temp;
/* Assume that minIndex() returns index of minimum value in

array arr[start_index...end_index] */
min_index = minIndex(arr, start_index, end_index);
temp = arr[start_index];
arr[start_index] = arr[min_index];
arr[min_index] = temp;
fun2(arr, start_index + 1, end_index);

}

Answer: The function fun2() is a recursive implementation of Selection Sort.
Please write comments if you find any of the answers/codes incorrect, or you want to share more
Maximum width of a binary tree
Given a binary tree, write a function to get the maximum width of the given tree. Width of a tree is maximum
of widths of all levels.
Let us consider the below example tree.
1
/ \
2 3
/ \ \
4 5 8
/ \
6 7

For the above tree,

width of level 1 is 1,
width of level 2 is 2,
width of level 3 is 3
width of level 4 is 2.
So the maximum width of the tree is 3.
Method 1 (Using Level Order Traversal)

This method mainly involves two functions. One is to count nodes at a given level (getWidth), and other is to
get the maximum width of the tree(getMaxWidth). getMaxWidth() makes use of getWidth() to get the width
of all levels starting from root.
/*Function to print level order traversal of tree*/

getMaxWidth(tree)
maxWdth = 0
for i = 1 to height(tree)
width = getWidth(tree, i);
if(width > maxWdth)
maxWdth = width
return width

/*Function to get width of a given level */

getWidth(tree, level)
if tree is NULL then return 0;
if level is 1, then return 1;
return getWidth(tree->left, level-1) +
getWidth(tree->right, level-1);

#include <stdio.h>
#include <stdlib.h>

struct node
{
int data;
struct node* left;
struct node* right;
};
int getWidth(struct node* root, int level);
/* Function to get the maximum width of a binary tree*/

int getMaxWidth(struct node* root)
{
int maxWidth = 0;
int width;
int i;

/* Get width of each level and compare
the width with maximum width so far */
for(i=1; i<=h; i++)
{
width = getWidth(root, i);
if(width > maxWidth)
maxWidth = width;
}

return maxWidth;
}
/* Get width of a given level */

int getWidth(struct node* root, int level)
{

if(root == NULL)
return 0;

if(level == 1)
return 1;

else if (level > 1)
return getWidth(root->left, level-1) +
getWidth(root->right, level-1);
}
{
if (node==NULL)
return 0;
else
{
int lHeight = height(node->left);
int rHeight = height(node->right);

return (lHeight > rHeight)? (lHeight+1): (rHeight+1);
}
}
{
node->data = data;
node->left = NULL;
node->right = NULL;
return(node);
}
int main()
{
root->right->right->left = newNode(6);
root->right->right->right = newNode(7);
/*
Constructed bunary tree is:
1
/ \
2 3
/ \ \
4 5 8
/ \
6 7
*/
printf("Maximum width is %d \n", getMaxWidth(root));
getchar();
return 0;
}

Time Complexity: O(n^2) in the worst case.
We can use Queue based level order traversal to optimize the time complexity of this method. The Queue
based level order traversal will take O(n) time in worst case. Thanks to Nitish, DivyaC and tech.login.id2 for
suggesting this optimization. See their comments for implementation using queue based traversal.
Method 2 (Using Preorder Traversal)

In this method we create a temporary array count[] of size equal to the height of tree. We initialize all values
in count as 0. We traverse the tree using preorder traversal and fill the entries in count so that the count
array contains count of nodes at each level in Binary Tree.
#include <stdio.h>
#include <stdlib.h>

struct node
{
int data;
struct node* left;
struct node* right;
};
// A utility function to get height of a binary tree

// A utility function to allocate a new node with given data

// A utility function that returns maximum value in arr[] of size n

int getMax(int arr[], int n);
// A function that fills count array with count of nodes at every

// level of given binary tree
void getMaxWidthRecur(struct node *root, int count[], int level);
/* Function to get the maximum width of a binary tree*/

int getMaxWidth(struct node* root)
{
int width;
// Create an array that will store count of nodes at each level

int *count = (int *)calloc(sizeof(int), h);
int level = 0;
// Fill the count array using preorder traversal

getMaxWidthRecur(root, count, level);
// Return the maximum value from count array

return getMax(count, h);
}
// A function that fills count array with count of nodes at every

// level of given binary tree
void getMaxWidthRecur(struct node *root, int count[], int level)
{
if(root)
{
count[level]++;
getMaxWidthRecur(root->left, count, level+1);
getMaxWidthRecur(root->right, count, level+1);
}
}
{
if (node==NULL)
return 0;
return 0;
else
{
int lHeight = height(node->left);
int rHeight = height(node->right);
return (lHeight > rHeight)? (lHeight+1): (rHeight+1);

}
}
{
node->data = data;
node->left = NULL;
node->right = NULL;
return(node);
}
// Return the maximum value from count array

int getMax(int arr[], int n)
{
int max = arr[0];
int i;
for (i = 0; i < n; i++)
{
if (arr[i] > max)
max = arr[i];
}
return max;
}

int main()
{
/*
Constructed bunary tree is:
1
/ \
2 3
/ \ \
4 5 8
/ \
6 7
*/
printf("Maximum width is %d \n", getMaxWidth(root));
getchar();
return 0;
}

Thanks to Raja and jagdish for suggesting this method.
Please write comments if you find the above code/algorithm incorrect, or find better ways to solve the same
problem.
Run Length Encoding
Given an input string, write a function that returns the Run Length Encoded string for the input string.
For example, if the input string is “wwwwaaadexxxxxx”, then the function should return “w4a3d1e1x6″.
Algorithm:
a) Pick the first character from source string.
b) Append the picked character to the destination string.
c) Count the number of subsequent occurrences of the picked character and append the count to destination
string.
d) Pick the next character and repeat steps b) c) and d) if end of string is NOT reached.

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#define MAX_RLEN 50
/* Returns the Run Length Encoded string for the

source string src */
char *encode(char *src)
{
int rLen;
char count[MAX_RLEN];
int len = strlen(src);

/* If all characters in the source string are different,
then size of destination string would be twice of input string.
For example if the src is "abcd", then dest would be "a1b1c1d1"
For other inputs, size would be less than twice. */
char *dest = (char *)malloc(sizeof(char)*(len*2 + 1));

int i, j = 0, k;
/* traverse the input string one by one */

for(i = 0; i < len; i++)
{
/* Copy the first occurrence of the new character */

dest[j++] = src[i];

/* Count the number of occurrences of the new character */
rLen = 1;
while(i + 1 < len && src[i] == src[i+1])
{
rLen++;
i++;
}

/* Store rLen in a character array count[] */
sprintf(count, "%d", rLen);
/* Copy the count[] to destination */

for(k = 0; *(count+k); k++, j++)
{
dest[j] = count[k];
}
}
/*terminate the destination string */

dest[j] = '\0';
return dest;
}
/*driver program to test above function */

int main()
{
char *res = encode(str);
printf("%s", res);
getchar();
}

References:
http://en.wikipedia.org/wiki/Run-length_encoding
problem.
Intersection of two Sorted Linked Lists
Given two lists sorted in increasing order, create and return a new list representing the intersection of the
two lists. The new list should be made with its own memory — the original lists should not be changed.
For example, let the first linked list be 1->2->3->4->6 and second linked list be 2->4->6->8, then your
function should create and return a third list as 2->4->6.
Method 1 (Using Dummy Node)

The strategy here uses a temporary dummy node as the start of the result list. The pointer tail always points
to the last node in the result list, so appending new nodes is easy. The dummy node gives tail something to
point to initially when the result list is empty. This dummy node is efficient, since it is only temporary, and it
is allocated in the stack. The loop proceeds, removing one node from either ‘a’ or ‘b’, and adding it to tail.
When we are done, the result is in dummy.next.
#include<stdio.h>
#include<stdlib.h>

struct node
{
int data;
struct node* next;
};
/*This solution uses the temporary dummy to build up the result list */
struct node* sortedIntersect(struct node* a, struct node* b)
{
struct node dummy;
struct node* tail = &dummy;
dummy.next = NULL;

/* Once one or the other list runs out -- we're done */
while (a != NULL && b != NULL)
{
if (a->data == b->data)
{
push((&tail->next), a->data);
tail = tail->next;
a = a->next;
b = b->next;
}
else if (a->data < b->data) /* advance the smaller list */
a = a->next;
else
b = b->next;
}
return(dummy.next);
}
{
/* allocate node */



}

{
{
node = node->next;
}
}

int main()
{
/* Start with the empty lists */
struct node* a = NULL;
struct node* b = NULL;
struct node *intersect = NULL;

/* Let us create the first sorted linked list to test the functions
push(&a, 6);
push(&a, 5);
push(&a, 4);
push(&a, 3);
push(&a, 2);
push(&a, 1);

/* Let us create the second sorted linked list
push(&b, 8);
push(&b, 6);
push(&b, 4);
push(&b, 2);

/* Find the intersection two linked lists */
intersect = sortedIntersect(a, b);

printf("\n Linked list containing common items of a & b \n ");
printList(intersect);

getchar();
}

Time Complexity: O(m+n) where m and n are number of nodes in first and second linked lists respectively.
Method 2 (Using Local References)

This solution is structurally very similar to the above, but it avoids using a dummy node Instead, it
maintains a struct node** pointer, lastPtrRef, that always points to the last pointer of the result list. This
solves the same case that the dummy node did — dealing with the result list when it is empty. If you are
trying to build up a list at its tail, either the dummy node or the struct node** “reference” strategy can be
used
#include<stdio.h>
#include<stdlib.h>

struct node
{
int data;
struct node* next;
};
/* This solution uses the local reference */

struct node* sortedIntersect(struct node* a, struct node* b)
{
struct node* result = NULL;
struct node** lastPtrRef = &result;

/* Advance comparing the first nodes in both lists.
When one or the other list runs out, we're done. */
while (a!=NULL && b!=NULL)
{
if (a->data == b->data)
{
/* found a node for the intersection */
push(lastPtrRef, a->data);
lastPtrRef = &((*lastPtrRef)->next);
a = a->next;
b = b->next;
}
else if (a->data < b->data)
a=a->next; /* advance the smaller list */
else
b=b->next;
}
return(result);
}
{
/* allocate node */



}
{
while(node != NULL)
{
node = node->next;
}
}

int main()
{

push(&a, 6);
push(&a, 5);
push(&a, 4);
push(&a, 3);
push(&a, 2);
push(&a, 1);

push(&b, 8);
push(&b, 6);
push(&b, 4);
push(&b, 2);



getchar();
}

Below is the recursive implementation of sortedIntersect().
#include<stdio.h>
#include<stdlib.h>

struct node
{
int data;
struct node* next;
};
struct node *sortedIntersect(struct node *a, struct node *b)

{
/* base case */
if (a == NULL || b == NULL)
return NULL;
/* If both lists are non-empty */
/* advance the smaller list and call recursively */

if (a->data < b->data)
return sortedIntersect(a->next, b);
if (a->data > b->data)

return sortedIntersect(a, b->next);
// Below lines are executed only when a->data == b->data

struct node *temp = (struct node *)malloc(sizeof(struct node));
temp->data = a->data;
/* advance both lists and call recursively */

temp->next = sortedIntersect(a->next, b->next);
return temp;
}
{
/* allocate node */
struct node* new_node = (struct node*) malloc(sizeof(struct node));



}

{
{
node = node->next;
}
}

int main()
{
push(&a, 6);
push(&a, 5);
push(&a, 4);
push(&a, 3);
push(&a, 2);
push(&a, 1);

push(&b, 8);
push(&b, 6);
push(&b, 4);
push(&b, 2);


return 0;
}

Please write comments if you find the above codes/algorithms incorrect, or find better ways to solve the
same problem.
References:
cslibrary.stanford.edu/105/LinkedListProblems.pdf
A Product Array Puzzle
Given an array arr[] of n integers, construct a Product Array prod[] (of same size) such that prod[i] is equal
to the product of all the elements of arr[] except arr[i]. Solve it without division operator and in O(n) .
Example:
arr[] = {10, 3, 5, 6, 2}
prod[] = {180, 600, 360, 300, 900}
Algorithm:
1) Construct a temporary array left[] such that left[i] contains product of all elements on left of arr[i]
excluding arr[i].
2) Construct another temporary array right[] such that right[i] contains product of all elements on on right
of arr[i] excluding arr[i].
3) To get prod[], multiply left[] and right[].
Implementation:

#include<stdio.h>
#include<stdlib.h>
/* Function to print product array for a given array

arr[] of size n */
void productArray(int arr[], int n)
{
/* Allocate memory for temporary arrays left[] and right[] */
int *left = (int *)malloc(sizeof(int)*n);
int *right = (int *)malloc(sizeof(int)*n);
/* Allocate memory for the product array */

int *prod = (int *)malloc(sizeof(int)*n);
int i, j;
/* Left most element of left array is always 1 */

left[0] = 1;
/* Rightmost most element of right array is always 1 */

right[n-1] = 1;
/* Construct the left array */

for(i = 1; i < n; i++)
left[i] = arr[i-1]*left[i-1];
/* Construct the right array */

for(j = n-2; j >=0; j--)
right[j] = arr[j+1]*right[j+1];
/* Construct the product array using

left[] and right[] */
for (i=0; i<n; i++)
prod[i] = left[i] * right[i];
/* print the constructed prod array */

for (i=0; i<n; i++)
printf("%d ", prod[i]);
return;
}

int main()
{
int arr[] = {10, 3, 5, 6, 2};
printf("The product array is: \n");
productArray(arr, n);
getchar();
}


Space Complexity: O(n)
The above method can be optimized to work in space complexity O(1). Thanks to Dileep for
suggesting the below solution.

void productArray(int arr[], int n)

{
int i, temp = 1;
/* Allocate memory for the product array */

int *prod = (int *)malloc(sizeof(int)*n);
/* Initialize the product array as 1 */

memset(prod, 1, n);
/* In this loop, temp variable contains product of

elements on left side excluding arr[i] */
for(i=0; i<n; i++)
{
prod[i] = temp;
temp *= arr[i];
}
/* Initialize temp to 1 for product on right side */

temp = 1;
/* In this loop, temp variable contains product of

elements on right side excluding arr[i] */
for(i= n-1; i>=0; i--)
{
prod[i] *= temp;
temp *= arr[i];
}
/* print the constructed prod array */

for (i=0; i<n; i++)
printf("%d ", prod[i]);
return;
}


Space Complexity: O(n)
problem.
Explain the functionality of following functions.
Question 1
/* Assume that n is greater than or equal to 1 */

int fun1(int n)
{
if(n == 1)
return 0;
else
return 1 + fun1(n/2);
}

Answer: The function calculates and returns
. For example, if n is between 8 and 15 then fun1() returns 3. If n is between 16 to 31 then fun1() returns 4.
Question 2
/* Assume that n is greater than or equal to 0 */

void fun2(int n)
{
if(n == 0)
return;
fun2(n/2);
printf("%d", n%2);
}

Answer: The function fun2() prints binary equivalent of n. For example, if n is 21 then fun2() prints 10101.
Note that above functions are just for practicing recursion, they are not the ideal implementation of the
functionality they provide.
Please write comments if you find any of the answers/codes incorrect.

Delete alternate nodes of a Linked List
Given a Singly Linked List, starting from the second node delete all alternate nodes of it. For example, if the
given linked list is 1->2->3->4->5 then your function should convert it to 1->3->5, and if the given linked list
is 1->2->3->4 then convert it to 1->3.
Keep track of previous of the node to be deleted. First change the next link of previous node and then free the
memory allocated for the node.
#include<stdio.h>
#include<stdlib.h>

struct node
{
int data;
struct node *next;
};
/* deletes alternate nodes of a list starting with head */

void deleteAlt(struct node *head)
{
if (head == NULL)
return;
/* Initialize prev and node to be deleted */

struct node *prev = head;
struct node *node = head->next;
while (prev != NULL && node != NULL)

{
/* Change next link of previous node */
prev->next = node->next;
/* Free memory */
free(node);
/* Update prev and node */

prev = prev->next;
if(prev != NULL)
node = prev->next;
}
}

of the list. */
{
/* allocate node */


}

{
while(node != NULL)
{
node = node->next;
}
}
/* Drier program to test above functions */

int main()
{
int arr[100];

/* Using push() to construct below list

1->2->3->4->5 */
push(&head, 5);
push(&head, 4);
push(&head, 3);
push(&head, 2);
push(&head, 1);
printf("\n List before calling deleteAlt() ");

printList(head);
deleteAlt(head);
printf("\n List after calling deleteAlt() ");

printList(head);
getchar();
return 0;
}

Time Complexity: O(n) where n is the number of nodes in the given Linked List.
Recursive code uses the same approach as method 1. The recursive coed is simple and short, but causes O(n)
recursive function calls for a linked list of size n.

/* deletes alternate nodes of a list starting with head */

void deleteAlt(struct node *head)
{
if (head == NULL)
return;

struct node *node = head->next;
if (node == NULL)
return;
/* Change the next link of head */

head->next = node->next;
/* free memory allocated for node */

free(node);
/* Recursively call for the new next of head */

deleteAlt(head->next);
}

problem.
Alternating split of a given Singly Linked List
Write a function AlternatingSplit() that takes one list and divides up its nodes to make two smaller lists ‘a’
and ‘b’. The sublists should be made from alternating elements in the original list. So if the original list is 0-
>1->0->1->0->1 then one sublist should be 0->0->0 and the other should be 1->1->1.
Method 1(Simple)
The simplest approach iterates over the source list and pull nodes off the source and alternately put them at
the front (or beginning) of ‘a’ and b’. The only strange part is that the nodes will be in the reverse order that
they occurred in the source list. Method 2 inserts the node at the end by keeping track of last node in
sublists.
/*Program to alternatively split a linked list into two halves */

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

struct node
{
int data;
struct node* next;
};
/* pull off the front node of the source and put it in dest */
void MoveNode(struct node** destRef, struct node** sourceRef) ;
/* Given the source list, split its nodes into two shorter lists.
If we number the elements 0, 1, 2, ... then all the even elements
should go in the first list, and all the odd elements in the second.
The elements in the new lists may be in any order. */
void AlternatingSplit(struct node* source, struct node** aRef,
struct node** bRef)
{
/* split the nodes of source to these 'a' and 'b' lists */

struct node* current = source;
{
MoveNode(&a, &current); /* Move a node to list 'a' */
if (current != NULL)
{
MoveNode(&b, &current); /* Move a node to list 'b' */
}
}
*aRef = a;
*bRef = b;
}
/* Take the node from the front of the source, and move it to the front of the dest.
It is an error to call this with the source list empty.

Before calling MoveNode():
source == {1, 2, 3}
dest == {1, 2, 3}

Affter calling MoveNode():
source == {2, 3}
source == {2, 3}
dest == {1, 1, 2, 3}
*/
void MoveNode(struct node** destRef, struct node** sourceRef)
{
/* the front source node */
struct node* newNode = *sourceRef;
assert(newNode != NULL);

/* Advance the source pointer */
*sourceRef = newNode->next;

/* Link the old dest off the new node */
newNode->next = *destRef;

/* Move dest to point to the new node */
*destRef = newNode;
}
{
/* allocate node */



}

{
while(node!=NULL)
{
node = node->next;
}
}

int main()
{

push(&head, 5);
push(&head, 4);
push(&head, 3);
push(&head, 2);
push(&head, 1);
push(&head, 0);
printf("\n Original linked List: ");

printf("\n Original linked List: ");
printList(head);

AlternatingSplit(head, &a, &b);
printf("\n Resultant Linked List 'a' ");

printList(a);
printf("\n Resultant Linked List 'b' ");

printList(b);
getchar();
return 0;
}

Time Complexity: O(n) where n is number of node in the given linked list.
Method 2(Using Dummy Nodes)

Here is an alternative approach which builds the sub-lists in the same order as the source list. The code uses
a temporary dummy header nodes for the ‘a’ and ‘b’ lists as they are being built. Each sublist has a “tail”
pointer which points to its current last node — that way new nodes can be appended to the end of each list
easily. The dummy nodes give the tail pointers something to point to initially. The dummy nodes are
efficient in this case because they are temporary and allocated in the stack. Alternately, local “reference
pointers” (which always points to the last pointer in the list instead of to the last node) could be used to avoid
Dummy nodes.
void AlternatingSplit(struct node* source, struct node** aRef,

struct node** bRef)
{
struct node aDummy;
struct node* aTail = &aDummy; /* points to the last node in 'a' */
struct node bDummy;
struct node* bTail = &bDummy; /* points to the last node in 'b' */
struct node* current = source;
aDummy.next = NULL;
bDummy.next = NULL;
{
MoveNode(&(aTail->next), &current); /* add at 'a' tail */
aTail = aTail->next; /* advance the 'a' tail */
if (current != NULL)
{
MoveNode(&(bTail->next), &current);
bTail = bTail->next;
}
}
*aRef = aDummy.next;
*bRef = bDummy.next;
}

Time Complexity: O(n) where n is number of node in the given linked list.
Source: http://cslibrary.stanford.edu/105/LinkedListProblems.pdf
problem.
Question 1
#include<stdio.h>
int main()
{
int a;
char *x;
x = (char *) &a;
a = 512;
x[0] = 1;
x[1] = 2;
printf("%d\n",a);
getchar();
return 0;
}

Answer: The output is dependent on endianness of a machine. Output is 513 in a little endian machine and
258 in a big endian machine.
Let integers are stored using 16 bits. In a little endian machine, when we do x[0] = 1 and x[1] = 2, the number
a is changed to 00000001 00000010 which is representation of 513 in a little endian machine. The output
would be same for 32 bit numbers also.
In a big endian machine, when we do x[0] = 1 and x[1] = 2, the number is changed to 00000001 00000010
which is representation of 258 in a big endian machine.
Question 2
int main()
{
int f = 0, g = 1;
int i;
for(i = 0; i < 15; i++)
{
printf("%d \n", f);
f = f + g;
g = f - g;
}
getchar();
return 0;
}

Answer: The function prints first 15 Fibonacci Numbers.
Question 3
Explain functionality of following function.

int func(int i)
{
if(i%2) return (i++);
else return func(func(i-1));
}

Answer: If n is odd then returns n, else returns (n-1). So if n is 12 then we get and if n is 11 then we get 11.
Total number of possible Binary Search Trees with n keys
Total number of possible Binary Search Trees with n different keys = Catalan number Cn = (2n)!/(n+1)!*n!
See references for proof and examples.
References:
http://en.wikipedia.org/wiki/Catalan_number
G-Fact 8
To uniquely construct a Binary Tree, Inorder together with either Postorder or Preorder must be given (See
this for details). However, either Postorder or Preorder traversal is sufficient to uniquely construct a Binary
Search Tree. To construct Binary Search tree, we can get Inorder traversal by sorting the given Preorder or
Postorder traversal. So we have the required two traversals and can construct the Binary Search Tree.
Merge two sorted linked lists
Write a SortedMerge() function that takes two lists, each of which is sorted in increasing order, and merges
the two together into one list which is in increasing order. SortedMerge() should return the new list. The
new list should be made by splicing
together the nodes of the first two lists.
For example if the first linked list a is 5->10->15 and the other linked list b is 2->3->20, then SortedMerge()
should return a pointer to the head node of the merged list 2->3->5->10->15->20.
There are many cases to deal with: either ‘a’ or ‘b’ may be empty, during processing either ‘a’ or ‘b’ may run
out first, and finally there’s the problem of starting the result list empty, and building it up while going
through ‘a’ and ‘b’.
Method 1 (Using Dummy Nodes)

The strategy here uses a temporary dummy node as the start of the result list. The pointer Tail always points
to the last node in the result list, so appending new nodes is easy.
The dummy node gives tail something to point to initially when the result list is empty. This dummy node is
efficient, since it is only temporary, and it is allocated in the stack. The loop proceeds, removing one node
from either ‘a’ or ‘b’, and adding it to tail. When
we are done, the result is in dummy.next.
/*Program to alternatively split a linked list into two halves */

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

struct node
{
int data;
struct node* next;
};
/* pull off the front node of the source and put it in dest */
void MoveNode(struct node** destRef, struct node** sourceRef);
/* Takes two lists sorted in increasing order, and splices their nodes together to make
one big sorted list which is returned. */
struct node* SortedMerge(struct node* a, struct node* b)
{
/* a dummy first node to hang the result on */
struct node dummy;

/* tail points to the last result node */
struct node* tail = &dummy;
/* so tail->next is the place to add new nodes

to the result. */
dummy.next = NULL;
while(1)
{
if(a == NULL)
{
/* if either list runs out, use the other list */
tail->next = b;
break;
}
else if (b == NULL)
else if (b == NULL)
{
tail->next = a;
break;
}
if (a->data <= b->data)
{
MoveNode(&(tail->next), &a);
}
else
{
MoveNode(&(tail->next), &b);
}
tail = tail->next;
}
return(dummy.next);
}
/*MoveNode() function takes the node from the front of the source, and move it to the fr
ont of the dest.
It is an error to call this with the source list empty.
Before calling MoveNode():

source == {1, 2, 3}
dest == {1, 2, 3}
Affter calling MoveNode():

source == {2, 3}
dest == {1, 1, 2, 3}
*/
void MoveNode(struct node** destRef, struct node** sourceRef)
{
/* the front source node */
struct node* newNode = *sourceRef;
assert(newNode != NULL);
/* Advance the source pointer */

*sourceRef = newNode->next;
/* Link the old dest off the new node */

newNode->next = *destRef;
/* Move dest to point to the new node */

*destRef = newNode;
}

{
/* allocate node */



}
}

{
while(node!=NULL)
{
node = node->next;
}
}

int main()
{
struct node* res = NULL;
/* Let us create two sorted linked lists to test the functions

Created lists shall be a: 5->10->15, b: 2->3->20 */
push(&a, 15);
push(&a, 10);
push(&a, 5);

push(&b, 20);
push(&b, 3);
push(&b, 2);

res = SortedMerge(a, b);
printf("\n Merged Linked List is: \n");

printList(res);
getchar();
return 0;
}

Method 2 (Using Local References)

This solution is structurally very similar to the above, but it avoids using a dummy node. Instead, it
maintains a struct node** pointer, lastPtrRef, that always points to the last pointer of the result list. This
solves the same case that the dummy node did — dealing with the result list when it is empty. If you are
trying to build up a list at its tail, either the dummy node or the struct node** “reference” strategy can be
used (see Section 1 for details).


{

/* point to the last result pointer */
struct node** lastPtrRef = &result;

while(1)
{
if (a == NULL)
{
*lastPtrRef = b;
break;
}
else if (b==NULL)
{
*lastPtrRef = a;
break;
}
if(a->data <= b->data)
{
MoveNode(lastPtrRef, &a);
}
else
{
MoveNode(lastPtrRef, &b);
}

/* tricky: advance to point to the next ".next" field */
lastPtrRef = &((*lastPtrRef)->next);
}
return(result);
}

Method 3 (Using Recursion)

Merge is one of those nice recursive problems where the recursive solution code is much cleaner than the
iterative code. You probably wouldn’t want to use the recursive version for production code however,
because it will use stack space which is proportional to the length of the lists.


{
/* Base cases */
if (a == NULL)
return(b);
else if (b==NULL)
return(a);
/* Pick either a or b, and recur */

{
result = a;
result->next = SortedMerge(a->next, b);
}
else
{
result = b;
result->next = SortedMerge(a, b->next);
}
return(result);
}

Source: http://cslibrary.stanford.edu/105/LinkedListProblems.pdf
problem.
Identical Linked Lists
Two Linked Lists are identical when they have same data and arrangement of data is also same. For example
Linked lists a (1->2->3) and b(1->2->3) are identical. . Write a function to check if the given two linked lists
are identical.
To identify if two lists are identical, we need to traverse both lists simultaneously, and while traversing we
need to compare data.
#include<stdio.h>
#include<stdlib.h>
/* Structure for a linked list node */

struct node
{
int data;
struct node *next;
};
/* returns 1 if linked lists a and b are identical, otherwise 0 */

bool areIdentical(struct node *a, struct node *b)
{
while(1)
{
/* base case */
if(a == NULL && b == NULL)
{ return 1; }
if(a == NULL && b != NULL)
{ return 0; }
if(a != NULL && b == NULL)
{ return 0; }
if(a->data != b->data)
{ return 0; }

/* If we reach here, then a and b are not NULL and their
data is same, so move to next nodes in both lists */
a = a->next;
b = b->next;
}
}

of the list. */
{
/* allocate node */



}
}

int main()
{
struct node *a = NULL;
struct node *b = NULL;
/* The constructed linked lists are :

a: 3->2->1
b: 3->2->1 */
push(&a, 1);
push(&a, 2);
push(&a, 3);

push(&b, 1);
push(&b, 2);
push(&b, 3);
if(areIdentical(a, b) == 1)
printf(" Linked Lists are identical ");
else
printf(" Linked Lists are not identical ");
getchar();
return 0;
}

Recursive solution code is much cleaner than the iterative code. You probably wouldn’t want to use the
recursive version for production code however, because it will use stack space which is proportional to the
length of the lists
bool areIdentical(struct node *a, struct node *b)

{
if (a == NULL && b == NULL)
{ return 1; }
if (a == NULL && b != NULL)
{ return 0; }
if (a != NULL && b == NULL)
{ return 0; }
if (a->data != b->data)
{ return 0; }
/* If we reach here, then a and b are not NULL and their

data is same, so move to next nodes in both lists */
return areIdentical(a->next, b->next);
}

Time Complexity: O(n) for both iterative and recursive versions. n is the length of the smaller list among a
and b.
same problem.
Merge Sort for Linked Lists
Merge sort is often preferred for sorting a linked list. The slow random-access performance of a linked list
makes some other algorithms (such as quicksort) perform poorly, and others (such as heapsort) completely
impossible.
Let head be the first node of the linked list to be sorted and headRef be the pointer to head. Note that we
need a reference to head in MergeSort() as the below implementation changes next links to sort the linked
lists (not data at the nodes), so head node has to be changed if the data at original head is not the smallest
value in linked list.
MergeSort(headRef)
1) If head is NULL or there is only one element in the Linked List
then return.
2) Else divide the linked list into two halves.
FrontBackSplit(head, &a, &b); /* a and b are two halves */
3) Sort the two halves a and b.
MergeSort(a);
MergeSort(b);
4) Merge the sorted a and b (using SortedMerge() discussed here)
and update the head pointer using headRef.
*headRef = SortedMerge(a, b);

#include<stdio.h>
#include<stdlib.h>

struct node
{
int data;
struct node* next;
};
/* function prototypes */
struct node* SortedMerge(struct node* a, struct node* b);
void FrontBackSplit(struct node* source,
struct node** frontRef, struct node** backRef);
/* sorts the linked list by changing next pointers (not data) */

void MergeSort(struct node** headRef)
{
struct node* head = *headRef;
struct node* a;
struct node* b;
/* Base case -- length 0 or 1 */

if ((head == NULL) || (head->next == NULL))
{
return;
}
/* Split head into 'a' and 'b' sublists */

FrontBackSplit(head, &a, &b);
/* Recursively sort the sublists */

MergeSort(&a);
MergeSort(&a);
MergeSort(&b);
/* answer = merge the two sorted lists together */

}
/* See http://geeksforgeeks.org/?p=3622 for details of this

function */
{
/* Base cases */
if (a == NULL)
return(b);
else if (b==NULL)
return(a);

{
result = a;
result->next = SortedMerge(a->next, b);
}
else
{
result = b;
result->next = SortedMerge(a, b->next);
}
return(result);
}
/* Split the nodes of the given list into front and back halves,
and return the two lists using the reference parameters.
If the length is odd, the extra node should go in the front list.
Uses the fast/slow pointer strategy. */
struct node** frontRef, struct node** backRef)
{
struct node* fast;
struct node* slow;
if (source==NULL || source->next==NULL)
{
/* length < 2 cases */
*frontRef = source;
*backRef = NULL;
}
else
{
slow = source;
fast = source->next;
/* Advance 'fast' two nodes, and advance 'slow' one node */

while (fast != NULL)
{
fast = fast->next;
if (fast != NULL)
{
slow = slow->next;
fast = fast->next;
}
}
/* 'slow' is before the midpoint in the list, so split it in two
at that point. */
*frontRef = source;
*backRef = slow->next;
slow->next = NULL;
}
}

{
while(node!=NULL)
{
node = node->next;
}
}

{
/* allocate node */



}

int main()
{

/* Let us create a unsorted linked lists to test the functions
Created lists shall be a: 2->3->20->5->10->15 */
push(&a, 15);
push(&a, 10);
push(&a, 5);
push(&a, 20);
push(&a, 3);
push(&a, 2);

/* Sort the above created Linked List */
MergeSort(&a);

printf("\n Sorted Linked List is: \n");
printList(a);

getchar();
return 0;
}

Sources:
http://en.wikipedia.org/wiki/Merge_sort
problem.
Segregate Even and Odd numbers
Given an array A[], write a function that segregates even and odd numbers. The functions should put all even
numbers first, and then odd numbers.
Example
Input = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
In the output, order of numbers can be changed, i.e., in the above example 34 can come before 12 and 3 can
come before 9.
The problem is very similar to our old post Segregate 0s and 1s in an array, and both of these problems are
variation of famous Dutch national flag problem.
Algorithm: segregateEvenOdd()
1) Initialize two index variables left and right:
left = 0, right = size -1
2) Keep incrementing left index until we see an odd number.
3) Keep decrementing right index until we see an even number.
4) If lef
Implementation:

#include<stdio.h>
/* Function to swap *a and *b */

void segregateEvenOdd(int arr[], int size)

{
/* Initialize left and right indexes */
int left = 0, right = size-1;
while(left < right)
{
/* Increment left index while we see 0 at left */
while(arr[left]%2 == 0 && left < right)
left++;
/* Decrement right index while we see 1 at right */

while(arr[right]%2 == 1 && left < right)
right--;
if(left < right)

{
/* Swap arr[left] and arr[right]*/
swap(&arr[left], &arr[right]);
left++;
right--;
}
}
}
{
int temp = *a;
*a = *b;
*b = temp;
}
/* driver program to test */

int main()
{
int arr[] = {12, 34, 45, 9, 8, 90, 3};
int arr_size = 7, i = 0;
segregateEvenOdd(arr, arr_size);
printf("array after segregation ");

getchar();
return 0;
}

References:
http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Flag/
Please write comments if you find the above code/algorithm incorrect, or find better
ways to solve the same problem.

Find the two repeating elements in a given array
You are given an array of n+2 elements. All elements of the array are in range 1 to n. And all elements occur
once except two numbers which occur twice. Find the two repeating numbers.
For example, array = {4, 2, 4, 5, 2, 3, 1} and n = 5
The above array has n + 2 = 7 elements with all elements occurring once except 2 and 4 which occur twice.
So the output should be 4 2.
Method 1 (Basic)
Use two loops. In the outer loop, pick elements one by one and count the number of occurrences of the
picked element in the inner loop.
This method doesn’t use the other useful data provided in questions like range of numbers is between 1 to n
and there are only two repeating elements.
#include<stdio.h>
#include<stdlib.h>
void printRepeating(int arr[], int size)
{
int i, j;
printf(" Repeating elements are ");
for(j = i+1; j < size; j++)
if(arr[i] == arr[j])
}
int main()
{
int arr[] = {4, 2, 4, 5, 2, 3, 1};
int arr_size = sizeof(arr)/sizeof(arr[0]);
printRepeating(arr, arr_size);
getchar();
return 0;
}

Time Complexity: O(n*n)

Method 2 (Use Count array)

Traverse the array once. While traversing, keep track of count of all elements in the array using a temp array
count[] of size n, when you see an element whose count is already set, print it as duplicate.
This method uses the range given in the question to restrict the size of count[], but doesn’t use the data that
there are only two repeating elements.

#include<stdio.h>
#include<stdlib.h>

{
int *count = (int *)calloc(sizeof(int), (size - 2));
int i;

printf(" Repeating elements are ");
{
if(count[arr[i]] == 1)
else
count[arr[i]]++;
}
}
int main()
{
int arr[] = {4, 2, 4, 5, 2, 3, 1};
getchar();
return 0;
}


Method 3 (Make two equations)

Let the numbers which are being repeated are X and Y. We make two equations for X and Y and the simple
task left is to solve the two equations.
We know the sum of integers from 1 to n is n(n+1)/2 and product is n!. We calculate the sum of input array,
when this sum is subtracted from n(n+1)/2, we get X + Y because X and Y are the two numbers missing from
set [1..n]. Similarly calculate product of input array, when this product is divided from n!, we get X*Y. Given
sum and product of X and Y, we can find easily out X and Y.
Let summation of all numbers in array be S and product be P
X + Y = S – n(n+1)/2
XY = P/n!
Using above two equations, we can find out X and Y. For array = 4 2 4 5 2 3 1, we get S = 21 and P as 960.
X + Y = 21 – 15 = 6
XY = 960/5! = 8
X – Y = sqrt((X+Y)^2 – 4*XY) = sqrt(4) = 2
Using below two equations, we easily get X = (6 + 2)/2 and Y = (6-2)/2

X + Y = 6
X – Y = 2
Thanks to geek4u for suggesting this method. As pointed by Beginer , there can be addition and
multiplication overflow problem with this approach.
The methods 3 and 4 use all useful information given in the question
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
/* function to get factorial of n */

int fact(int n);

{
int S = 0; /* S is for sum of elements in arr[] */
int P = 1; /* P is for product of elements in arr[] */
int x, y; /* x and y are two repeating elements */
int D; /* D is for difference of x and y, i.e., x-y*/
int n = size - 2, i;
/* Calculate Sum and Product of all elements in arr[] */

{
S = S + arr[i];
P = P*arr[i];
}

S = S - n*(n+1)/2; /* S is x + y now */
P = P/fact(n); /* P is x*y now */

D = sqrt(S*S - 4*P); /* D is x - y now */

x = (D + S)/2;
y = (S - D)/2;

printf("The two Repeating elements are %d & %d", x, y);
}
int fact(int n)
{
return (n == 0)? 1 : n*fact(n-1);
}
int main()
{
int arr[] = {4, 2, 4, 5, 2, 3, 1};
getchar();
return 0;
}


Method 4 (Use XOR)

Thanks to neophyte for suggesting this method.
The approach used here is similar to method 2 of this post.
Let the repeating numbers be X and Y, if we xor all the elements in the array and all integers from 1 to n,
then the result is X xor Y.
The 1’s in binary representation of X xor Y is corresponding to the different bits between X and Y. Suppose
that the kth bit of X xor Y is 1, we can xor all the elements in the array and all integers from 1 to n, whose kth
bits are 1. The result will be one of X and Y.

{
int xor = arr[0]; /* Will hold xor of all elements */
int set_bit_no; /* Will have only single set bit of xor */
int i;
int n = size - 2;
int x = 0, y = 0;

/* Get the xor of all elements in arr[] and {1, 2 .. n} */
xor ^= arr[i];
for(i = 1; i <= n; i++)
xor ^= i;

set_bit_no = xor & ~(xor-1);

bit of xor with bit at same position in each element. */
{
x = x ^ arr[i]; /*XOR of first set in arr[] */
else
y = y ^ arr[i]; /*XOR of second set in arr[] */
}
for(i = 1; i <= n; i++)
{
if(i & set_bit_no)
x = x ^ i; /*XOR of first set in arr[] and {1, 2, ...n }*/
else
y = y ^ i; /*XOR of second set in arr[] and {1, 2, ...n } */
}

printf("\n The two repeating elements are %d & %d ", x, y);
}
int main()
{
int arr[] = {4, 2, 4, 5, 2, 3, 1};
getchar();
return 0;
}

Method 5 (Use array elements as index)

Thanks to Manish K. Aasawat for suggesting this method.

Traverse the array. Do following for every index i of A[].

{
check for sign of A[abs(A[i])] ;
if positive then
make it negative by A[abs(A[i])]=-A[abs(A[i])];
else // i.e., A[abs(A[i])] is negative
this element (ith element of list) is a repetition
}

Example: A[] = {1, 1, 2, 3, 2}

i=0;
Check sign of A[abs(A[0])] which is A[1]. A[1] is positive, so make it negative.
Array now becomes {1, -1, 2, 3, 2}
i=1;
Check sign of A[abs(A[1])] which is A[1]. A[1] is negative, so A[1] is a repetition.
i=2;
Check sign of A[abs(A[2])] which is A[2]. A[2] is positive, so make it negative. '
Array now becomes {1, -1, -2, 3, 2}
i=3;
Check sign of A[abs(A[3])] which is A[3]. A[3] is positive, so make it negative.
Array now becomes {1, -1, -2, -3, 2}
i=4;
Check sign of A[abs(A[4])] which is A[2]. A[2] is negative, so A[4] is a repetition.

Note that this method modifies the original array and may not be a recommended method if we are not
allowed to modify the array.

#include <stdio.h>
#include <stdlib.h>

{
int i;

printf("\n The repeating elements are");

{
if(arr[abs(arr[i])] > 0)
arr[abs(arr[i])] = -arr[abs(arr[i])];
else
printf(" %d ", abs(arr[i]));
}
}
int main()
{
int arr[] = {1, 3, 2, 2, 1};
getchar();
return 0;
}

The problem can be solved in linear time using other method also, please see this and this comments
same problem.
Reverse a Linked List in groups of given size
Given a linked list, write a function to reverse every k nodes (where k is an input to the function).
Example:
Inputs: 1->2->3->4->5->6->7->8->NULL and k = 3
Output: 3->2->1->6->5->4->8->7->NULL.
Inputs: 1->2->3->4->5->6->7->8->NULL and k = 5

Output: 5->4->3->2->1->8->7->6->NULL.

Algorithm: reverse(head, k)
1) Reverse the first sub-list of size k. While reversing keep track of the next node and previous node. Let the
pointer to the next node be next and pointer to the previous node be prev. See this post for reversing a linked
list.
2) head->next = reverse(next, k) /* Recursively call for rest of the list and link the two sub-lists */
3) return prev /* prev becomes the new head of the list (see the diagrams of iterative method of this post) */
#include<stdio.h>
#include<stdlib.h>

struct node
{
int data;
struct node* next;
};
/* Reverses the linked list in groups of size k and returns the

pointer to the new head node. */
struct node *reverse (struct node *head, int k)
{
struct node* next = NULL;
int count = 0;

/*reverse first k nodes of the linked list */
while (current != NULL && count < k)
{
prev = current;
current = next;
count++;
}

/* next is now a pointer to (k+1)th node
Recursively call for the list starting from current.
And make rest of the list as next of first node */
if(next != NULL)
{ head->next = reverse(next, k); }
/* prev is new head of the input list */

return prev;
}
}
{
/* allocate node */



}

{
while(node != NULL)
{
node = node->next;
}
}

int main(void)
{

/* Created Linked list is 1->2->3->4->5->6->7->8 */
push(&head, 8);
push(&head, 7);
push(&head, 6);
push(&head, 5);
push(&head, 4);
push(&head, 3);
push(&head, 2);
push(&head, 1);
printf("\n Given linked list \n");

printList(head);
head = reverse(head, 3);
printf("\n Reversed Linked list \n");

printList(head);
getchar();
return(0);
}

Time Complexity: O(n) where n is the number of nodes in the given list.
Please write comments if you find the above code/algorithm incorrect, or find other ways to solve the same
problem.
Foldable Binary Trees
Question: Given a binary tree, find out if the tree can be folded or not.
A tree can be folded if left and right subtrees of the tree are structure wise mirror image of each other. An
empty tree is considered as foldable.
Consider the below trees:

(a) and (b) can be folded.
(c) and (d) cannot be folded.
(a)
10
/ \
7 15
\ /
9 11
(b)
10
/ \
7 15
/ \
9 11
(c)
10
/ \
7 15
/ /
5 11
(d)
10
/ \
7 15
/ \ /
9 10 12

Method 1 (Change Left subtree to its Mirror and compare it with Right subtree)
Algorithm: isFoldable(root)

1) If tree is empty, then return true.
2) Convert the left subtree to its mirror image
mirror(root->left); /* See this post */
3) Check if the structure of left subtree and right subtree is same
and store the result.
res = isStructSame(root->left, root->right); /*isStructSame()
recursively compares structures of two subtrees and returns
true if structures are same */
4) Revert the changes made in step (2) to get the original tree.
mirror(root->left);
5) Return result res stored in step 2.

Thanks to ajaym for suggesting this approach.
#include<stdio.h>
#include<stdlib.h>
/* You would want to remove below 3 lines if your compiler

supports bool, true and false */
#define bool int
#define true 1
#define false 0

struct node
{
int data;
struct node* left;
struct node* right;
};
/* converts a tree to its mrror image */

void mirror(struct node* node);
/* returns true if structure of two trees a and b is same

Only structure is considered for comparison, not data! */
bool isStructSame(struct node *a, struct node *b);
/* Returns true if the given tree is foldable */

bool isFoldable(struct node *root)
{
bool res;
/* base case */
if(root == NULL)
return true;
/* convert left subtree to its mirror */

mirror(root->left);
/* Compare the structures of the right subtree and mirrored

left subtree */
res = isStructSame(root->left, root->right);
/* Get the originial tree back */

mirror(root->left);
return res;
}
bool isStructSame(struct node *a, struct node *b)

{
if (a == NULL && b == NULL)
{ return true; }
if ( a != NULL && b != NULL &&
isStructSame(a->left, b->left) &&
isStructSame(a->right, b->right)
)
{ return true; }
return false;
}
/* Change a tree so that the roles of the left and
right pointers are swapped at every node.
See http://geeksforgeeks.org/?p=662 for details */
void mirror(struct node* node)
{
if (node==NULL)
return;
else
{
struct node* temp;
mirror(node->left);
mirror(node->right);
/* swap the pointers in this node */

temp = node->left;
node->left = node->right;
node->right = temp;
}
}

{
node->data = data;
node->left = NULL;
node->right = NULL;
return(node);
}

int main(void)
{
/* The constructed binary tree is
1
/ \
2 3
\ /
4 5
*/
if(isFoldable(root) == 1)
{ printf("\n tree is foldable"); }
else
{ printf("\n tree is not foldable"); }
getchar();
return 0;
}

Method 2 (Check if Left and Right subtrees are Mirror)

There are mainly two functions:
// Checks if tree can be folded or not
IsFoldable(root)
1) If tree is empty then return true
2) Else check if left and right subtrees are structure wise mirrors of
each other. Use utility function IsFoldableUtil(root->left,
root->right) for this.

// Checks if n1 and n2 are mirror of each other.
IsFoldableUtil(n1, n2)
1) If both trees are empty then return true.
2) If one of them is empty and other is not then return false.
3) Return true if following conditions are met
a) n1->left is mirror of n2->right
b) n1->right is mirror of n2->left

#include<stdio.h>
#include<stdlib.h>
/* You would want to remove below 3 lines if your compiler

supports bool, true and false */
#define bool int
#define true 1
#define false 0

struct node
{
int data;
struct node* left;
struct node* right;
};
/* A utility function that checks if trees with roots as n1 and n2

are mirror of each other */
bool IsFoldableUtil(struct node *n1, struct node *n2);
/* Returns true if the given tree can be folded */

bool IsFoldable(struct node *root)
{
if (root == NULL)
{ return true; }
return IsFoldableUtil(root->left, root->right);

return IsFoldableUtil(root->left, root->right);
}
/* A utility function that checks if trees with roots as n1 and n2

are mirror of each other */
bool IsFoldableUtil(struct node *n1, struct node *n2)
{
/* If both left and right subtrees are NULL,
then return true */
if (n1 == NULL && n2 == NULL)
{ return true; }
/* If one of the trees is NULL and other is not,

then return false */
if (n1 == NULL || n2 == NULL)
{ return false; }
/* Otherwise check if left and right subtrees are mirrors of

their counterparts */
return IsFoldableUtil(n1->left, n2->right) &&
IsFoldableUtil(n1->right, n2->left);
}
/*UTILITY FUNCTIONS */
{
node->data = data;
node->left = NULL;
node->right = NULL;
return(node);
}

int main(void)
{
/* The constructed binary tree is
1
/ \
2 3
\ /
4 5
*/
if(IsFoldable(root) == true)
{ printf("\n tree is foldable"); }
else
{ printf("\n tree is not foldable"); }
getchar();
return 0;
}

Thanks to Dzmitry Huba for suggesting this approach.
problem.
Explain the functionality of below recursive functions.
Question 1
void fun1(int n)
{
int i = 0;
if (n > 1)
fun1(n-1);
for (i = 0; i < n; i++)
printf(" * ");
}

Answer: Total numbers of stars printed is equal to 1 + 2 + …. (n-2) + (n-1) + n, which is n(n+1)/2.
Question 2
#define LIMIT 1000

void fun2(int n)
{
if (n <= 0)
return;
if (n > LIMIT)
return;
printf("%d ", n);
fun2(2*n);
printf("%d ", n);
}

Answer: For a positive n, fun2(n) prints the values of n, 2n, 4n, 8n … while the value is smaller than LIMIT.
After printing values in increasing order, it prints same numbers again in reverse order. For example
fun2(100) prints 100, 200, 400, 800, 800, 400, 200, 100.
If n is negative, then it becomes a non-terminating recursion and causes overflow.
Sort an array of 0s, 1s and 2s
Given an array A[] consisting 0s, 1s and 2s, write a function that sorts A[]. The functions should put all 0s
first, then all 1s and all 2s in last.
Example
Input = {0, 1, 1, 0, 1, 2, 1, 2, 0, 0, 0, 1};
Output = {0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2}
The problem is similar to our old post Segregate 0s and 1s in an array, and both of these problems are
variation of famous Dutch national flag problem.
The problem was posed with three colours, here `0′, `1′ and `2′. The array is divided into four sections:
1. a[1..Lo-1] zeroes (red)

2. a[Lo..Mid-] ones (white)
3. a[Mid..Hi] unknown
4. a[Hi+1..N] twos (blue)
The unknown region is shrunk while maintaining these conditions
1. Lo := 1; Mid := 1; Hi := N;
2. while Mid <= Hi do
1. Invariant: a[1..Lo-1]=0 and a[Lo..Mid-1]=1 and a[Hi+1..N]=2; a[Mid..Hi] are unknown.
2. case a[Mid] in
0: swap a[Lo] and a[Mid]; Lo++; Mid++
1: Mid++
2: swap a[Mid] and a[Hi]; Hi–
— Dutch National Flag Algorithm, or 3-way Partitioning —
Part way through the process, some red, white and blue elements are known and are in the “right” place. The
section of unknown elements, a[Mid..Hi], is shrunk by examining a[Mid]:

Examine a[Mid]. There are three possibilities:

a[Mid] is (0) red, (1) white or (2) blue.
Case (0) a[Mid] is red, swap a[Lo] and a[Mid]; Lo++; Mid++
Case (1) a[Mid] is white, Mid++
Case (2) a[Mid] is blue, swap a[Mid] and a[Hi]; Hi--
Continue until Mid>Hi.

Below is C implementation of above algorithm.
// C program to sort an array with 0,1 and 2

// in a single pass
#include<stdio.h>
/* Function to swap *a and *b */

// Sort the input array, the array is assumed to

// have values in {0, 1, 2}
void sort012(int a[], int arr_size)
{
int lo = 0;
int lo = 0;
int hi = arr_size - 1;
int mid = 0;
while (mid <= hi)

{
switch (a[mid])
{
case 0:
swap(&a[lo++], &a[mid++]);
break;
case 1:
mid++;
break;
case 2:
swap(&a[mid], &a[hi--]);
break;
}
}
}
{
int temp = *a;
*a = *b;
*b = temp;
}

void printArray(int arr[], int arr_size)
{
int i;
printf("\n");
}
/* driver program to test */

int main()
{
int arr[] = {0, 1, 1, 0, 1, 2, 1, 2, 0, 0, 0, 1};
int i;
sort012(arr, arr_size);
printf("array after segregation ");

printArray(arr, arr_size);
getchar();
return 0;
}

The above code performs unnecessary swaps for inputs like 0 0 0 0 1 1 1 2 2 2 2 2 : lo=4 and mid=7 and
hi=11. In present code: first 7 exchanged with 11 and hi become 10 and mid is still pointing to 7. again same
operation is till the mid http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Flag/
problem.
Turn off the rightmost set bit
Write a C function that unsets the rightmost set bit of an integer.
Examples:
Input: 12 (00...01100)
Output: 8 (00...01000)
Input: 7 (00...00111)
Output: 6 (00...00110)

Let the input number be n. n-1 would have all the bits flipped after the rightmost set bit (including the set
bit). So, doing n&(n-1) would give us the required result.
#include<stdio.h>
/* unsets the rightmost set bit of n and returns the result */

int fun(unsigned int n)
{
return n&(n-1);
}

int main()
{
int n = 7;
printf("The number after unsetting the rightmost set bit %d", fun(n));
getchar();
return 0;
}

problem
exit(), abort() and assert()
exit()
void exit ( int status );

exit() terminates the process normally.

status: Status value returned to the parent process. Generally, a status value of 0 or EXIT_SUCCESS
indicates success, and any other value or the constant EXIT_FAILURE is used to indicate an error. exit()
performs following operations.
* Flushes unwritten buffered data.
* Closes all open files.
* Removes temporary files.
* Returns an integer exit status to the operating system.
The C standard atexit() function can be used to customize exit() to perform additional actions at program
termination.
Example use of exit.
/* exit example */
#include <stdio.h>
#include <stdlib.h>

int main ()
{
FILE * pFile;
pFile = fopen ("myfile.txt", "r");
if (pFile == NULL)
{
printf ("Error opening file");
exit (1);
}
else
{
/* file operations here */
}
return 0;
}

abort()
void abort ( void );

Unlike exit() function, abort() may not close files that are open. It may also not delete temporary files and
may not flush stream buffer. Also, it does not call functions registered with atexit().
This function actually terminates the process by raising a SIGABRT signal, and your program can include a
handler to intercept this signal (see this).
So programs like below might not write “Geeks for Geeks” to “tempfile.txt”
#include<stdio.h>
#include<stdlib.h>
int main()
{
FILE *fp = fopen("C:\\myfile.txt", "w");

if(fp == NULL)
{
printf("\n could not open file ");
getchar();
exit(1);
}

fprintf(fp, "%s", "Geeks for Geeks");

/* ....... */
/* ....... */
/* Something went wrong so terminate here */
abort();

getchar();
return 0;
}

If we want to make sure that data is written to files and/or buffers are flushed then we should either use
exit() or include a signal handler for SIGABRT.
assert()
void assert( int expression );

If expression evaluates to 0 (false), then the expression, sourcecode filename, and line number are sent to
the standard error, and then abort() function is called. If the identifier NDEBUG (“no debug”) is defined
with #define NDEBUG then the macro assert does nothing.
Common error outputting is in the form:
Assertion failed: expression, file filename, line line-number

#include<assert.h>
void open_record(char *record_name)

{
assert(record_name != NULL);
/* Rest of code */
}
int main(void)
{
open_record(NULL);
}

This article is contributed by Rahul Gupta. Please write comments if you find anything incorrect in the
above article or you want to share more information about the topic discussed above.
References:
http://www.cplusplus.com/reference/clibrary/cstdlib/abort/
http://www.cplusplus.com/reference/clibrary/cassert/assert/
http://www.acm.uiuc.edu/webmonkeys/book/c_guide/2.1.html
https://www.securecoding.cert.org/confluence/display/seccode/ERR06-
C.+Understand+the+termination+behavior+of+assert%28%29+and+abort%28%29
https://www.securecoding.cert.org/confluence/display/seccode/ERR04-
C.+Choose+an+appropriate+termination+strategy
Multiply a given Integer with 3.5
Given a integer x, write a function that multiplies x with 3.5 and returns the integer result. You are not
allowed to use %, /, *.
Examples:
Input: 2
Output: 7
Input: 5
Output: 17 (Ignore the digits after decimal point)
Solution:
1. We can get x*3.5 by adding 2*x, x and x/2. To calculate 2*x, left shift x by 1 and to calculate x/2, right shift
x by 2.
#include <stdio.h>
int multiplyWith3Point5(int x)
{
return (x<<1) + x + (x>>1);
}

int main()
{
int x = 4;
printf("%d", multiplyWith3Point5(x));
getchar();
return 0;
}

2. Another way of doing this could be (8*x – x)/2 (See below code). Thanks to ajaym for suggesting this.
#include <stdio.h>
int multiplyWith3Point5(int x)
{
return ((x<<3) - x)>>1;
}

problem
G-Fact 9
The number of structurally different Binary Trees with n nodes is Catalan number Cn = (2n)!/(n+1)!*n!
References:
http://mathworld.wolfram.com/BinaryTree.html
Add 1 to a given number
Write a program to add one to a given number. You are not allowed to use operators like ‘+’, ‘-‘, ‘*’, ‘/’, ‘++’,
‘–‘ …etc.
Examples:
Input: 12
Output: 13
Input: 6
Output: 7
Yes, you guessed it right, we can use bitwise operators to achieve this. Following are different methods to
achieve same using bitwise operators.
Method 1
To add 1 to a number x (say 0011000111), we need to flip all the bits after the rightmost 0 bit (we get
0011000000). Finally, flip the rightmost 0 bit also (we get 0011001000) and we are done.
#include<stdio.h>
int addOne(int x)
{
int m = 1;
/* Flip all the set bits until we find a 0 */

while( x & m )
{
x = x^m;
m <<= 1;
}
/* flip the rightmost 0 bit */

x = x^m;
return x;
}

int main()
{
printf("%d", addOne(13));
getchar();
return 0;
}

Method 2
We know that the negative number is represented in 2’s complement form on most of the architectures. We
have the following lemma hold for 2’s complement representation of signed numbers.
Say, x is numerical value of a number, then
~x = -(x+1) [ ~ is for bitwise complement ]
(x + 1) is due to addition of 1 in 2’s complement conversion
To get (x + 1) apply negation once again. So, the final expression becomes (-(~x)).

int addOne(int x)
{
return (-(~x));
}

int main()
{
printf("%d", addOne(13));
getchar();
return 0;
}

Example, assume the machine word length is one *nibble* for simplicity.
And x = 2 (0010),
~x = ~2 = 1101 (13 numerical)
-~x = -1101
Interpreting bits 1101 in 2’s complement form yields numerical value as -(2^4 – 13) = -3. Applying ‘-‘ on the
result leaves 3. Same analogy holds for decrement. See this comment for implementation of decrement.
Note that this method works only if the numbers are stored in 2’s complement form.
Thanks to Venki for suggesting this method.
problem
Question 1
#include<stdio.h>
int main(void)
{
int a = 1;
int b = 0;
b = ++a + ++a;
printf("%d %d",a,b);
getchar();
return 0;
}

Output: Undefined Behavior

See http://en.wikipedia.org/wiki/C_syntax#Undefined_behavior )
Question 2
#include<stdio.h>
int main()
{
int a[] = {1, 2, 3, 4, 5, 6};
int *ptr = (int*)(&a+1);
printf("%d ", *(ptr-1) );
getchar();
return 0;
}
Output: 6
&a is address of the whole array a[]. If we add 1 to &a, we get “base address of a[] + sizeof(a)”. And this value
is typecasted to int *. So ptr – 1 points to last element of a[]
Question 1
#include <stdio.h>
char* fun()
{
return "awake";
}
int main()
{
printf("%s",fun()+ printf("I see you"));
getchar();
return 0;
}

Output: Some string starting with “I see you”

Explanation: (Thanks to Venki for suggesting this solution)
The function fun() returns pointer to char. Apart from printing string “I see you”, printf() function returns
number of characters it printed(i.e. 9). The expression [fun()+ printf(“I see you”)] can be boiled down to
[“awake” + 9] which is nothing but base address of string literal “awake” displaced by 9 characters. Hence,
the expression [“awake” + 9] returns junk data when printed via %s specifier till it finds ‘\0′.
Question 2
#include <stdio.h>
int main()
{
unsigned i ;
for( i = 0 ; i < 4 ; ++i )
{
fprintf( stdout , "i = %d\n" , ("11213141") ) ;
}
getchar();
return 0 ;
}

Output: Prints different output on different machines.

Explanation: (Thanks to Venki for suggesting this solution)
The format specifier is %d, converts the base address of string “11213141” as an integer. The base address of
string depends on memory allocation by the compiler. The for loop prints same address four times. Try to
use C++ streams, you will see power of type system.
G-Fact 10
Enumeration constants ( enum values) are always of type int in C, whereas they are distinct types in C++
and may have size different from that of int .
Source:
http://en.wikipedia.org/wiki/Compatibility_of_C_and_C%2B%2B
Output of C++ Program | Set 1
Predict the output of below C++ programs.
Question 1
// Assume that integers take 4 bytes.

#include<iostream>
class Test
{
static int i;
int j;
};
int Test::i;
int main()
{
cout << sizeof(Test);
return 0;
}

Output: 4 (size of integer)

static data members do not contribute in size of an object. So ‘i’ is not considered in size of Test. Also, all
functions (static and non-static both) do not contribute in size.
Question 2

#include<iostream>

class Base1 {
public:
Base1()
{ cout << " Base1's constructor called" << endl; }
};
class Base2 {
public:
Base2()
{ cout << "Base2's constructor called" << endl; }
};
class Derived: public Base1, public Base2 {

public:
Derived()
{ cout << "Derived's constructor called" << endl; }
};
int main()
{
Derived d;
return 0;
}

Ouput:
Base1’s constructor called
Base2’s constructor called
Derived’s constructor called
In case of Multiple Inheritance, constructors of base classes are always called in derivation order from left to
right and Destructors are called in reverse order.
Output of C Program | Set 17
Predict the output of following C programs.
Question 1
#include<stdio.h>
#define R 10
#define C 20
int main()
{
int (*p)[R][C];
printf("%d", sizeof(*p));
getchar();
return 0;
}

Output: 10*20*sizeof(int) which is “800” for compilers with integer size as 4 bytes.
The pointer p is de-referenced, hence it yields type of the object. In the present case, it is an array of array of
integers. So, it prints R*C*sizeof(int).
Thanks to Venki for suggesting this solution.
Question 2
#include<stdio.h>
#define f(g,g2) g##g2
int main()
{
int var12 = 100;
printf("%d", f(var,12));
getchar();
return 0;
}

Output: 100
The operator ## is called “Token-Pasting” or “Merge” Operator. It merges two tokens into one token. So,
after preprocessing, the main function becomes as follows, and prints 100.
int main()
{
int var12 = 100;
printf("%d", var12);
getchar();
return 0;
}

Question 3
#include<stdio.h>
int main()
{
unsigned int x = -1;
int y = ~0;
if(x == y)
printf("same");
else
printf("not same");
printf("\n x is %u, y is %u", x, y);
getchar();
return 0;
}

Output: “same x is MAXUINT, y is MAXUINT” Where MAXUINT is the maximum possible value for an
unsigned integer.
-1 and ~0 essentially have same bit pattern, hence x and y must be same. In the comparison, y is promoted
to unsigned and compared against x. The result is “same”. However, when interpreted as signed and
unsigned their numerical values will differ. x is MAXUNIT and y is -1. Since we have %u for y also, the
output will be MAXUNIT and MAXUNIT.
Thanks to Venki for explanation.
Write you own Power without using multiplication(*) and division(/)
operators
Method 1 (Using Nested Loops)
We can calculate power by using repeated addition.
For example to calculate 5^6.

1) First 5 times add 5, we get 25. (5^2)
2) Then 5 times add 25, we get 125. (5^3)
3) Then 5 time add 125, we get 625 (5^4)
4) Then 5 times add 625, we get 3125 (5^5)
5) Then 5 times add 3125, we get 15625 (5^6)
/* Works only if a >= 0 and b >= 0 */

int pow(int a, int b)
{
if (b == 0)
return 1;
int answer = a;
int increment = a;
int i, j;
for(i = 1; i < b; i++)
{
for(j = 1; j < a; j++)
{
answer += increment;
}
increment = answer;
}
return answer;
}
/* driver program to test above function */

int main()
{
printf("\n %d", pow(5, 3));
getchar();
return 0;
}

Method 2 (Using Recursion)

Recursively add a to get the multiplication of two numbers. And recursively multiply to get a raise to the
power b.

#include<stdio.h>
/* A recursive function to get a^b
Works only if a >= 0 and b >= 0 */
int pow(int a, int b)
{
if(b)
return multiply(a, pow(a, b-1));
else
return 1;
}
/* A recursive function to get x*y */

int multiply(int x, int y)
{
if(y)
return (x + multiply(x, y-1));
else
return 0;
}
/* driver program to test above functions */

int main()
{
printf("\n %d", pow(5, 3));
getchar();
return 0;
}

problem.
Print nodes at k distance from root
Given a root of a tree, and an integer k. Print all the nodes which are at k distance from root.
For example, in the below tree, 4, 5 & 8 are at distance 2 from root.
1
/ \
2 3
/ \ /
4 5 8

The problem can be solved using recursion. Thanks to eldho for suggesting the solution.
#include <stdio.h>
#include <stdlib.h>

struct node
{
int data;
struct node* left;
struct node* right;
};
void printKDistant(node *root , int k)

{
if(root == NULL)
return;
if( k == 0 )
{
printf( "%d ", root->data );
return ;
}
else
{
printKDistant( root->left, k-1 ) ;
printKDistant( root->right, k-1 ) ;
}
}

{
node->data = data;
node->left = NULL;
node->right = NULL;
return(node);
}

int main()
int main()
{

1
/ \
2 3
/ \ /
4 5 8
*/
printKDistant(root, 2);
getchar();
return 0;
}

The above program prints 4, 5 and 8.
Time Complexity: O(n) where n is number of nodes in the given binary tree.
problem.
Print all combinations of balanced parentheses
Write a function to generate all possible n pairs of balanced parentheses.
For example, if n=1

{}
for n=2
{}{}
{{}}
Algorithm:
Keep track of counts of open and close brackets. Initialize these counts as 0. Recursively call the
_printParenthesis() function until open bracket count is less than the given n. If open bracket count becomes
more than the close bracket count, then put a closing bracket and recursively call for the remaining brackets.
If open bracket count is less than n, then put an opening bracket and call _printParenthesis() for the
remaining brackets.
Thanks to Shekhu for providing the below code.

# include<stdio.h>
# define MAX_SIZE 100
void _printParenthesis(int pos, int n, int open, int close);
/* Wrapper over _printParenthesis()*/

void printParenthesis(int n)
{
if(n > 0)
_printParenthesis(0, n, 0, 0);
return;
}
void _printParenthesis(int pos, int n, int open, int close)

{
static char str[MAX_SIZE];
if(close == n)
{
printf("%s \n", str);
return;
}
else
{
if(open > close) {
str[pos] = '}';
_printParenthesis(pos+1, n, open, close+1);
}
if(open < n) {
str[pos] = '{';
_printParenthesis(pos+1, n, open+1, close);
}
}
}

int main()
{
int n = 4;
printParenthesis(n);
getchar();
return 0;
}

same problem.
Question 1
#include<iostream>
class A {
public:
A(int ii = 0) : i(ii) {}
void show() { cout << "i = " << i << endl;}
private:
int i;
};
class B {
public:
B(int xx) : x(xx) {}
operator A() const { return A(x); }
private:
int x;
};
void g(A a)
{ a.show(); }
int main() {
B b(10);
g(b);
g(20);
getchar();
return 0;
}

Output:
i = 10
i = 20
Since there is a Conversion constructor in class A, integer value can be assigned to objects of class A and
function call g(20) works. Also, there is a conversion operator overloaded in class B, so we can call g() with
objects of class B.
Question 2

#include<iostream>
class base {
int arr[10];
};
class b1: public base { };
class b2: public base { };
class derived: public b1, public b2 {};
int main(void)
{
cout<<sizeof(derived);
getchar();
return 0;
}

Output: If integer takes 4 bytes, then 80.
Since b1 and b2 both inherit from class base, two copies of class base are there in class derived. This kind of
inheritance without virtual causes wastage of space and ambiguities. virtual base classes are used to save
space and avoid ambiguities in such cases. For example, following program prints 48. 8 extra bytes are for
bookkeeping information stored by the compiler (See this for details)
#include<iostream>
class base {
int arr[10];
};
class b1: virtual public base { };
class b2: virtual public base { };
class derived: public b1, public b2 {};
int main(void)
{
cout<<sizeof(derived);
getchar();
return 0;
}

Comma operator should be used carefully
In C and C++, comma is the last operator in precedence table. So comma should be carefully used on right
side of an assignment expression. For example, one might expect the output as b = 10 in below program. But
program prints b = 20 as assignment has higher precedence over comma and the statement “b = 20, a”
becomes equivalent to “(b = 20), a”.
#include<stdio.h>
int main()
{
int a = 10, b;
b = 20, a; // b = 20
printf(" b = %d ", b);
getchar();
return 0;
}

Putting a bracket with comma makes b = a (or 10).
#include<stdio.h>
int main()
{
int a = 10, b;
b = (20, a); // b = a
printf(" b = %d ", b);
getchar();
return 0;
}

discussed above.
G-Fact 11
Following relationship holds in any n-ary tree in which every node has either 0 or n children.
L = (n-1)*I + 1
Where L is the number of leaf nodes and I is the number of internal nodes.
Proof:
The tree is n-ary tree. Assume it has T total nodes, which is sum of internal nodes (I) and leaf nodes (L). A
tree with T total nodes will have (T – 1) edges or branches.
In other words, since the tree is n-ary tree, each internal node will have n branches contributing total of n*I
internal branches. Therefore we have the following relations from the above explanations,
n*I = T – 1
L + I = T
From the above two equations, it is easy to prove that L = (n – 1) * I + 1.
Thanks to venki for providing the proof.
discussed above.
How does default virtual behavior differ in C++ and Java ?
Default virtual behavior of methods is opposite in C++ and Java:
In C++, class member methods are non-virtual by default. They can be made virtual by using virtual
keyword. For example, Base::show() is non-virtual in following program and program prints “Base::show()
called”.
#include<iostream>
class Base {
public:
// non-virtual by default
void show() {
cout<<"Base::show() called";
}
};
class Derived: public Base {

public:
void show() {
cout<<"Derived::show() called";
}
};
int main()
{
Derived d;
Base &b = d;
b.show();
getchar();
return 0;
}

Adding virtual before definition of Base::show() makes program print “Derived::show() called”
In Java, methods are virtual by default and can be made non-virtual by using final keyword. For example, in
the following java program, show() is by default virtual and the program prints “Derived::show() called”

class Base {
// virtual by default
public void show() {
System.out.println("Base::show() called");
}
}
class Derived extends Base {

public void show() {
System.out.println("Derived::show() called");
}
}
public class Main {

public static void main(String[] args) {
Base b = new Derived();;
b.show();
}
}

Unlike C++ non-virtual behavior, if we add final before definition of show() in Base , then the above program
fails in compilation.
discussed above.
Question 1
Predict the output of following program.
#include<stdio.h>
void fun(int x)
{
if(x > 0)
{
fun(--x);
printf("%d\t", x);
fun(--x);
}
}
int main()
{
int a = 4;
fun(a);
getchar();
return 0;
}

Output: 0 1 2 0 3 0 1

fun(4);
/
fun(3), print(3), fun(2)(prints 0 1)
/
fun(2), print(2), fun(1)(prints 0)
/
fun(1), print(1), fun(0)(does nothing)
/
fun(0), print(0), fun(-1) (does nothing)

Question 2
Predict the output of following program. What does the following fun() do in general?

int fun(int a[],int n)

{
int x;
if(n == 1)
return a[0];
else
x = fun(a, n-1);
if(x > a[n-1])
return x;
else
return a[n-1];
}
int main()
{
int arr[] = {12, 10, 30, 50, 100};
printf(" %d ", fun(arr, 5));
getchar();
return 0;
}

Output: 100
fun() returns the maximum value in the input array a[] of size n.
Question 3
int fun(int i)
{
if ( i%2 ) return (i++);
else return fun(fun( i - 1 ));
}
int main()
{
printf(" %d ", fun(200));
getchar();
return 0;
}

Output: 199
If n is odd then returns n, else returns (n-1). Eg., for n = 12, you get 11 and for n = 11 you get 11. The
statement “return i++;” returns value of i only as it is a post increment.
information/questions about the topics discussed above.
Question 1
#include<stdio.h>
int fun()
{
static int num = 40;
return num--;
}
int main()
{
for(fun(); fun(); fun())
{
printf("%d ", fun());
}
getchar();
return 0;
}

Output: 38 35 32 29 26 23 20 17 14 11 8 5 2
Since num is static in fun(), the old value of num is preserved for subsequent functions calls. Also, since the
statement return num– is postfix, it returns the old value of num, and updates the value for next function
call.
Question 2
#include<stdio.h>
int main()
{
char *s[] = { "knowledge","is","power"};
char **p;
p = s;
printf("%s ", ++*p);
printf("%s ", *p++);
printf("%s ", ++*p);
getchar();
return 0;
}

Output: nowledge nowledge s
Let us consider the expression ++*p in first printf(). Since precedence of prefix ++ and * is same,
associativity comes into picture. *p is evaluated first because both prefix ++ and * are right to left
associative. When we increment *p by 1, it starts pointing to second character of “knowledge”. Therefore, the
first printf statement prints “nowledge”.
Let us consider the expression *p++ in second printf() . Since precedence of postfix ++ is higher than *, p++
is evaluated first. And since it’s a psotfix ++, old value of p is used in this expression. Therefore, second printf
statement prints “nowledge”.
In third printf statement, the new value of p (updated by second printf) is used, and third printf() prints “s”.
G-Fact 12
In C, struct keyword must be used for declaring structure variables, but it is optional in C++.
For example, following program gives error in C and works in C++.
struct node {
int x;
node *next; // Error in C, struct must be there. Works in C++
};
int main()
{
node a; // Error in C, struct must be there. Works in C++
}

And following program works in both C and C++.
struct node {
int x;
struct node *next; // Works in both C and C++
};
int main()
{
struct node a; // Works in both C and C++
}

discussed above.
G-Fact 13
const Behaviour in C and C++
In C, the const qualified identifiers will have external linkage, where as in C++ it will have internal linkage.
For example,
In C++, the following statement

float const interest_rate = 9.25;

is implicitly defined as

static float const interest_rate = 9.25;

i.e. the scope of interest_rate is limited to the block in which it is defined.
In C, the above statement will have external linkage when defined at file scope, i.e. it will be visible outside
the current translation unit (source file).
The internal linkage of const qualified variables have some advantages in C++. We will cover them in next
article.
Thanks to Venki for writing the above fact. Please write comments if you find anything incorrect, or you
want to share more information about the topic discussed above.
Optimization Techniques | Set 1 (Modulus)
Modulus operator is costly.
The modulus operator (%) in various languages is costly operation. Ultimately every operator/operation
must result in processor instructions. Some processors won’t have modulus instruction at hardware level, in
such case the compilers will insert stubs (predefined functions) to perform modulus. It impacts
performance.
There is simple technique to extract remainder when a number is divided by another number (divisor) that
is power of 2? A number that is an exact power of 2 will have only one bit set in it’s binary representation.
Consider the following powers of 2 and their binary representations
2 – 10
4 – 100
8 – 1000
16 – 10000
Note those zeros in red color, they contribute to remainder in division operation. We can get mask for
those zeros by decrementing the divisor by 1.
Generalizing the above pattern, a number that can be written in 2n form will have only one bit set followed
n
by n zeros on the right side of 1. When a number (N) divided by (2), the bit positions corresponding to the
above mentioned zeros will contribute to the remainder of division operation. An example can make it clear,
N = 87 (1010111 – binary form)
N%2 = N & (2-1) = 1010111 & 1 = 1 = 1
N%4 = N & (4-1) = 1010111 & 11 = 11 = 3
N%8 = N & (8-1) = 1010111 & 111 = 111 = 7
N%16 = N & (16-1) = 1010111 & 1111 = 111 = 7
N%32 = N & (32-1) = 1010111 & 11111 = 10111 = 23
Modulus operation over exact powers of 2 is simple and faster bitwise ANDing. This is the reason,
programmers usually make buffer length as powers of 2.
Note that the technique will work only for divisors that are powers of 2.
An Example:
Implementation of circular queue (ring buffer) using an array. Omitting one position in the circular
buffer implementation can make it easy to distinguish between full and empty conditions. When the buffer
reaches SIZE-1, it needs to wrap back to initial position. The wrap back operation can be simple AND
operation if the buffer size is power of 2. If we use any other size, we would need to use modulus operation.
Note:
Per experts comments, premature optimization is an evil. The optimization techniques provided are to fine
tune your code after finalizing design strategy, algorithm, data structures and implementation.
We recommend to avoid them at the start of code development. Code readability is key for maintenance.
Thanks to Venki for writing the above article. Please write comments if you find anything incorrect, or you
Recursive Functions
Recursion:
In programming terms a recursive function can be defined as a routine that calls itself directly or indirectly.
Using recursive algorithm, certain problems can be solved quite easily. Towers of Hanoi (TOH) is one such
programming exercise. Try to write an iterative algorithm for TOH. Moreover, every recursive program can
be written using iterative methods (Refer Data Structures by Lipschutz).
Mathematically recursion helps to solve few puzzles easily.
For example, a routine interview question,
In a party of N people, each person will shake her/his hand with each other person only once. On total how
many hand-shakes would happen?
Solution:
It can be solved in different ways, graphs, recursion, etc. Let us see, how recursively it can be solved.
There are N persons. Each person shake-hand with each other only once. Considering N-th person, (s)he has
to shake-hand with (N-1) persons. Now the problem reduced to small instance of (N-1) persons. Assuming
TN as total shake-hands, it can be formulated recursively.
TN = (N-1) + TN-1 [T1 = 0, i.e. the last person have already shook-hand with every one]
Solving it recursively yields an arithmetic series, which can be evaluated to N(N-1)/2.
Exercise: In a party of N couples, only one gender (either male or female) can shake hand with every one.
How many shake-hands would happen?
Usually recursive programs results in poor time complexities. An example is Fibonacci series. The time
complexity of calculating n-th Fibonacci number using recursion is approximately 1.6 n. It means the same
computer takes almost 60% more time for next Fibonacci number. Recursive Fibonacci algorithm has
overlapped subproblems. There are other techniques like dynamic programming to improve such
overlapped algorithms.
However, few algorithms, (e.g. merge sort, quick sort, etc…) results in optimal time complexity using
recursion.
Base Case:
One critical requirement of recursive functions is termination point or base case. Every recursive program
must have base case to make sure that the function will terminate. Missing base case results in unexpected
behaviour.
Different Ways of Writing Recursive Functions in C/C++:
Function calling itself: (Direct way)
Most of us aware atleast two different ways of writing recursive programs. Given below is towers
of Hanoi code. It is an example of direct calling.

// Assuming n-th disk is bottom disk (count down)

void tower(int n, char sourcePole, char destinationPole, char auxiliaryPole)
{
// Base case (termination condition)
if(0 == n)
return;
// Move first n-1 disks from source pole

// to auxiliary pole using destination as
// temporary pole
tower(n-1, sourcePole, auxiliaryPole,
destinationPole);

// Move the remaining disk from source
// pole to destination pole
printf("Move the disk %d from %c to %c\n", n,
sourcePole, destinationPole);
// Move the n-1 disks from auxiliary (now source)

// pole to destination pole using source pole as
// temporary (auxiliary) pole
tower(n-1, auxiliaryPole, destinationPole,
sourcePole);
}
void main()
{
tower(3, 'S', 'D', 'A');
}

The time complexity of TOH can be calculated by formulating number of moves.
We need to move the first N-1 disks from Source to Auxiliary and from Auxiliary to Destination, i.e. the first
N-1 disks requires two moves. One more move of last disk from Source to Destination. Mathematically it can
be defined recursively.
MN = 2MN-1 + 1.
We can easily solve the above recursive relation (2N-1), which is exponential.
Recursion using mutual function call: (Indirect way)
Indirect calling. Though least pratical, a function [funA()] can call another function [funB()] which inturn
calls [funA()] former function. In this case both the functions should have the base case.
Defensive Programming:
We can combine defensive coding techniques with recursion for graceful functionality of application. Usually
recursive programming is not allowed in safety critical applications, such as flight controls, health
monitoring, etc. However, one can use a static count technique to avoid uncontrolled calls (NOT in safety
critical systems, may be used in soft real time systems).

void recursive(int data)

{
static callDepth;
if(callDepth > MAX_DEPTH)
return;
// Increase call depth

callDepth++;
// do other processing
recursive(data);
// do other processing
// Decrease call depth
callDepth--;
}

callDepth depth depends on function stack frame size and maximum stack size.
Recursion using function pointers: (Indirect way)
Recursion can also implemented with function pointers. An example is signal handler in POSIX complaint
systems. If the handler causes to trigger same event due to which the handler being called, the function will
reenter.
We will cover function pointer approach and iterative solution to TOH puzzle in later article.
Thanks to Venki for writing the above post. Please write comments if you find anything incorrect, or you
G-Fact 14
In C, a structure cannot have static members, but in C++ a structure can have static members.
For example, following program causes compilation error in C, but works in C++.
#include<stdio.h>
struct test {
static int i; // Error in C, but works in C++.
};
int main()
{
struct test t;
getchar();
return 0;
}

discussed above.
G-Fact 15
Atomic Operation
What is an atomic operation? An idea of atomic operation helps in understanding reentrancy, critical
section, thread safety, synchronization primitives, etc… (we will have upcoming articles on each).
Atomicity, Atomic Operation:
In simple terms, atomicity is unbreakability, i.e. an uninterrupted operation. If two users issue a print
command, each print should go in single attempt. If the printer driver is sending parts of data from two
users, the printout will not be as expected. Hence, the printer driver must send the print command as
unbreakable operation from one application at a time (in other words synchronize the access to printer).
Note that the data base terminology on atomicity would be different, yet the concept is same.
With an example we can understand the atomicity in programming well. Consider in a multi-threaded
application, a function is incrementing a global/static variable,
count++; // count has permanent storage in RAM
The above statement can be decomposed into, atleast three operations.
1. Fetching count value

2. Incrementing count value
3. Storing the updated value
If a thread executing the function containing the above statement is fetching its value (say 2). It is possible
that at this point of execution, the thread can be preempted and another thread may invoke the same
function. Consequently, the value of count will be incremented to 3 by that thread. When the former thread
is resumed, it still retains the previous value (2), instead of latest value (3), and ends up in writing back 3
again. Infact, the value of count should be 4 due to affect of both the threads.
Such kind of bugs are quite difficult to recreate and locate.
An example of atomic operation is instruction execution, usually an instruction feed to the execution unit
can’t be stopped in the middle. Yet, a statement in high level language results in multiple instructions. It is
the root cause of non-atomic operations.
discussed above.
The OFFSETOF() macro
We know that the elements in a structure will be stored in sequential order of their declaration.
How to extract the displacement of an element in a structure? We can make use of offsetof macro.
Usually we call structure and union types (or classes with trivial constructors) as plain old data (POD)
types, which will be used to aggregate other data types. The following non-standard macro can be used to
get the displacement of an element in bytes from the base address of the structure variable.

#define OFFSETOF(TYPE, ELEMENT) ((size_t)&(((TYPE *)0)->ELEMENT))

Zero is casted to type of structure and required element’s address is accessed, which is casted to
size_t. As
per standard size_t is of type unsigned int. The overall expression results in the number of bytes after which
the ELEMENT being placed in the structure.
For example, the following code returns 16 bytes (padding is considered on 32 bit machine) as displacement
of the character variable c in the structure Pod.
#include <stdio.h>
#define OFFSETOF(TYPE, ELEMENT) ((size_t)&(((TYPE *)0)->ELEMENT))
typedef struct PodTag

{
int i;
double d;
char c;
} PodType;
int main()
{
printf("%d", OFFSETOF(PodType, c) );

getchar();
return 0;
}

In the above code, the following expression will return the displacement of element c in the structure
PodType.

OFFSETOF(PodType, c);

After preprocessing stage the above macro expands to
((size_t)&(((PodType *)0)->c))

Since we are considering 0 as address of the structure variable, c will be placed after 16 bytes of its base
address i.e. 0x00 + 0x10. Applying & on the structure element (in this case it is c) returns the address of the
element which is 0x10. Casting the address to unsigned int (size_t) results in number of bytes the element is
placed in the structure.
Note: We may consider the address operator & is redundant. Without address operator in macro, the code
de-references the element of structure placed at NULL address. It causes an access violation exception
(segmentation fault) at runtime.
Note that there are other ways to implement offsetof macro according to compiler behaviour. The ultimate
goal is to extract displacement of the element. We will see practical usage of offsetof macro in
liked lists to connect similar objects (for example thread pool) in another article.
Article compiled by Venki. Please write comments if you find anything incorrect, or you want to share more
References:
1. Linux Kernel code.
2. http://msdn.microsoft.com/en-us/library/dz4y9b9a.aspx
3. GNU C/C++ Compiler Documentation

G-Fact 16
#include <stdio.h>
int main()
{
int x = 012;
printf("%d", x);
getchar();
return 0;
}

The program prints 10. Putting a 0 before an integer constant makes it an octal number and
putting 0x (or 0X) makes it a hexadecimal number. It is easy to put a 0 by accident, or as a habit.
The mistake is very common with beginners.
discussed above.
Find the Minimum length Unsorted Subarray, sorting which makes the
complete array sorted
Given an unsorted array arr[0..n-1] of size n, find the minimum length subarray arr[s..e] such that sorting
this subarray makes the whole array sorted.
Examples:
1) If the input array is [10, 12, 20, 30, 25, 40, 32, 31, 35, 50, 60], your program should be able to find that the
subarray lies between the indexes 3 and 8.
2) If the input array is [0, 1, 15, 25, 6, 7, 30, 40, 50], your program should be able to find that the subarray
lies between the indexes 2 and 5.
Solution:
1) Find the candidate unsorted subarray
a) Scan from left to right and find the first element which is greater than the next element. Let s be the index
of such an element. In the above example 1, s is 3 (index of 30).
b) Scan from right to left and find the first element (first in right to left order) which is smaller than the next
element (next in right to left order). Let e be the index of such an element. In the above example 1, e is 7
(index of 31).
2) Check whether sorting the candidate unsorted subarray makes the complete array sorted
or not. If not, then include more elements in the subarray.
a) Find the minimum and maximum values in arr[s..e]. Let minimum and maximum values be min and
max. min and max for [30, 25, 40, 32, 31] are 25 and 40 respectively.
b) Find the first element (if there is any) in arr[0..s-1] which is greater than min, change s to index of this
element. There is no such element in above example 1.
c) Find the last element (if there is any) in arr[e+1..n-1] which is smaller than max, change e to index of this
element. In the above example 1, e is changed to 8 (index of 35)
3) Print s and e.
Implementation:
#include<stdio.h>

void printUnsorted(int arr[], int n)
{
int s = 0, e = n-1, i, max, min;

// step 1(a) of above algo
for (s = 0; s < n-1; s++)
{
if (arr[s] > arr[s+1])
break;
}
if (s == n-1)
{
printf("The complete array is sorted");
return;
}

// step 1(b) of above algo
for(e = n - 1; e > 0; e--)
{
if(arr[e] < arr[e-1])
if(arr[e] < arr[e-1])
break;
}

// step 2(a) of above algo
max = arr[s]; min = arr[s];
for(i = s + 1; i <= e; i++)
{
if(arr[i] > max)
max = arr[i];
if(arr[i] < min)
min = arr[i];
}

// step 2(b) of above algo
for( i = 0; i < s; i++)
{
if(arr[i] > min)
{
s = i;
break;
}
}

// step 2(c) of above algo
for( i = n -1; i >= e+1; i--)
{
if(arr[i] < max)
{
e = i;
break;
}
}

// step 3 of above algo
printf(" The unsorted subarray which makes the given array "
" sorted lies between the indees %d and %d", s, e);
return;
}

int main()
{
int arr[] = {10, 12, 20, 30, 25, 40, 32, 31, 35, 50, 60};
printUnsorted(arr, arr_size);
getchar();
return 0;
}

problem.
Comparison of Exception Handling in C++ and Java
Both languages use try, catch and throw keywords for exception handling, and meaning of try, catch and free
blocks is also same in both languages. Following are the differences between Java and C++ exception
handling.
1) In C++, all types (including primitive and pointer) can be thrown as exception. But in Java only throwable
objects (Throwable objects are instances of any subclass of the Throwable class) can be thrown as exception.
For example, following type of code works in C++, but similar code doesn’t work in Java.
#include <iostream>
int main()
{
int x = -1;
// some other stuff

try {
// some other stuff
if( x < 0 )
{
throw x;
}
}
catch (int x ) {
cout << "Exception occurred: thrown value is " << x << endl;
}
getchar();
return 0;
}

Output:
Exception occurred: thrown value is -1
2) In C++, there is a special catch called “catch all” that can catch all kind of exceptions.

#include <iostream>
int main()
{
int x = -1;
char *ptr;

ptr = new char[256];

// some other stuff
try {
// some other stuff
if( x < 0 )
{
throw x;
}
if(ptr == NULL)
{
throw " ptr is NULL ";
}
}
catch (...) // catch all
{
cout << "Exception occurred: exiting "<< endl;
exit(0);
}

getchar();
return 0;
}

Output:
Exception occurred: exiting
In Java, for all practical purposes, we can catch Exception object to catch all kind of exceptions. Because,
normally we do not catch Throwable(s) other than Exception(s) (which are Errors)
catch(Exception e){
…….
}

3) In Java, there is a block called finally that is always executed after the try-catch block. This block can be
used to do cleanup work. There is no such block in C++.

// creating an exception type

class Test extends Exception { }
class Main {
public static void main(String args[]) {
try {
throw new Test();
}
catch(Test t) {
System.out.println("Got the Test Exception");
}
finally {
System.out.println("Inside finally block ");
}
}
}

Output:
Got the error
Inside finally block
4) In C++, all exceptions are unchecked. In Java, there are two types of exceptions – checked and
unchecked. See this for more details on checked vs Unchecked exceptions.
5) In Java, a new keyword throws is used to list exceptions that can be thrown by a function. In C++, there is
no throws keyword, the same keyword throw is used for this purpose also.
discussed above.
Sorted order printing of a given array that represents a BST
Given an array that stores a complete Binary Search Tree, write a function that efficiently prints the given
array in ascending order.
For example, given an array [4, 2, 5, 1, 3], the function should print 1, 2, 3, 4, 5
Solution:
Inorder traversal of BST prints it in ascending order. The only trick is to modify recursion termination
condition in standard Inorder Tree Traversal.
Implementation:
#include<stdio.h>
void printSorted(int arr[], int start, int end)

{
if(start > end)
return;
// print left subtree

printSorted(arr, start*2 + 1, end);
// print root
printf("%d ", arr[start]);
// print right subtree

printSorted(arr, start*2 + 2, end);
}
int main()
{
int arr[] = {4, 2, 5, 1, 3};
int arr_size = sizeof(arr)/sizeof(int);
printSorted(arr, 0, arr_size-1);
getchar();
return 0;
}

Please write comments if you find the above solution incorrect, or find better ways to solve the same
problem.
Reentrant Function
What we mean by reentrancy and reentrant function? What is it’s significance in programming? What are
the conditions that a function to be reentrant?
Reentrancy is applicable in concurrent programming. Cooperative scheduling need not to consider

reentrancy. Prior to discussing on reentrant functions, we need to understand few keywords. Read atomicity
and critical section posts.
If one thread tries to change the value of shared data at the same time as another thread tries to read the
value, the result is not predictable. We call it as race condition.
A reentrant function guarantees it’s functionality even when the function is invoked (reentered) from
concurrent multiple threads. If the function is using variables with static extent, the results will
be unpredictable because of race conditions. A library developer need to care in writing reentrant code.
Sometimes the bug lies in the library rather than programmer’s code. It is not easy to recreate such bugs
during fix.
A Reentrant Function shall satisfy the following conditions,
1. Should not call another non-reentrant function

2. Should not access static life time variables (static/extern)
3. Should not include self modifying code
Thread safety and Reentrant functions
Thread safety and reentrant functions are connected. Every thread safe function is reentrant, but the
converse need not be true. A thread safe function can be called from multiple threads even when the
function accessing shared data. A thread safe function is guaranteed to serialize accessing any shared data.
An example is string class (C++). Most implementations of string class are reentrant but not thread safe.
One can create different instances of string class across multiple threads, but can’t access same instance
atomically from multiple threads. For more details of string class see QString.
Reentrancy is key while writing critical sections, signal handlers, interrupt service routines, etc…
Reentrant Function vs Functions with Reentrancy:
The above statement may look strange. There are different memory models of processors. Some
architectures use a common set of memory locations to pass arguments to functions. In such case the
functions can’t maintain reentrancy when invoked multiple times. Code development for such processors
must qualify the function prototype with compiler provided keywords to ensure reentrancy.
Critical Section
Critical Section:
In simple terms a critical section is group of instructions/statements or region of code that need to be
executed atomically (read this post for atomicity), such as accessing a resource (file, input or output port,
global data, etc.).
In concurrent programming, if one thread tries to change the value of shared data at the same time as
another thread tries to read the value (i.e. data race across threads), the result is unpredictable.
The access to such shared variable (shared memory, shared files, shared port, etc…) to be synchronized. Few
programming languages have built in support for synchronization.
It is critical to understand the importance of race condition while writing kernel mode programming (a
device driver, kernel thread, etc.). since the programmer can directly access and modifying kernel data
structures.
A simple solution to critical section can be thought as shown below,

acquireLock();
Process Critical Section
releaseLock();

A thread must acquire a lock prior to executing critical section. The lock can be acquired by only one thread.
There are various ways to implement locks in the above pseudo code. Let us discuss them in future articles.
discussed above.
Endian order and binary files
While working with binary files, how do you measure their endianness?
For example, if a programmer is making configuration file in binary format (e.g. on small systems it may not
be possible to use XML like text files for configuration, text files require another wrapper/layer over binary
files), the same binary file would need to be read on different architectures. In such case endianness issue to
be addressed.
Or consider, a binary file is created on little endian machine, can it be read on big endian machine without
altering byte order?
We can consider binary file as sequence of increasing addresses starting from low order to high order, each
address can store one byte. If we are writing some data to binary file on little endian machine it need not to
be altered. Where as if the binary file to be created on big endian machines, the data to be altered.
Note that some file formats define endian ordering. Example are JPEG (big endian) and BMP (little endian).
Related Posts:
1. Little and Big Endian Mystery

2. Output of C Programs | Set 14
Access specifier of methods in interfaces
In Java, all methods in an interface are public even if we do not specify public with method names. Also, data
fields are public static final even if we do not mention it with fields names. Therefore, data fields must be
initialized.
Consider the following example, x is by default public static final and foo() is public even if there are no
specifiers.
interface Test {
int x = 10; // x is public static final and must be initialized here
void foo(); // foo() is public
}

discussed above.
Structure Member Alignment, Padding and Data Packing
What do we mean by data alignment, structure packing and padding?
#include <stdio.h>
// Alignment requirements
// (typical 32 bit machine)
// char 1 byte
// short int 2 bytes
// int 4 bytes
// double 8 bytes
// structure A
typedef struct structa_tag
{
char c;
short int s;
} structa_t;
// structure B
typedef struct structb_tag
{
short int s;
char c;
int i;
} structb_t;
// structure C
typedef struct structc_tag
{
char c;
double d;
int s;
} structc_t;
// structure D
typedef struct structd_tag
{
double d;
int s;
char c;
} structd_t;
int main()
{
printf("sizeof(structa_t) = %d\n", sizeof(structa_t));
printf("sizeof(structb_t) = %d\n", sizeof(structb_t));
printf("sizeof(structc_t) = %d\n", sizeof(structc_t));
printf("sizeof(structd_t) = %d\n", sizeof(structd_t));
return 0;
}

Before moving further, write down your answer on a paper, and read on. If you urge to see explanation, you
may miss to understand any lacuna in your analogy. Also read the post by Kartik.
Data Alignment:
Every data type in C/C++ will have alignment requirement (infact it is mandated by processor architecture,
not by language). A processor will have processing word length as that of data bus size. On a 32 bit machine,
the processing word size will be 4 bytes.
Historically memory is byte addressable and arranged sequentially. If the memory is arranged as single bank
of one byte width, the processor needs to issue 4 memory read cycles to fetch an integer. It is more
economical to read all 4 bytes of integer in one memory cycle. To take such advantage, the memory will be
arranged as group of 4 banks as shown in the above figure.
The memory addressing still be sequential. If bank 0 occupies an address X, bank 1, bank 2 and bank 3 will
be at (X + 1), (X + 2) and (X + 3) addresses. If an integer of 4 bytes is allocated on X address (X is multiple of
4), the processor needs only one memory cycle to read entire integer.
Where as, if the integer is allocated at an address other than multiple of 4, it spans across two rows of the
banks as shown in the below figure. Such an integer requires two memory read cycle to fetch the data.
A variable’s data alignment deals with the way the data stored in these banks. For example, the natural
alignment of int on 32-bit machine is 4 bytes. When a data type is naturally aligned, the CPU fetches it in
minimum read cycles.
Similarly, the natural alignment of short int is 2 bytes. It means, a short int can be stored in bank 0 –
bank 1 pair or bank 2 – bank 3 pair. A double requires 8 bytes, and occupies two rows in the memory
banks. Any misalignment of double will force more than two read cycles to fetch double data.
Note that a double variable will be allocated on 8 byte boundary on 32 bit machine and requires two
memory read cycles. On a 64 bit machine, based on number of banks, double variable will be allocated on 8
byte boundary and requires only one memory read cycle.
Structure Padding:
In C/C++ a structures are used as data pack. It doesn’t provide any data encapsulation or data hiding
features (C++ case is an exception due to its semantic similarity with classes).
Because of the alignment requirements of various data types, every member of structure should be naturally
aligned. The members of structure allocated sequentially increasing order. Let us analyze each struct
declared in the above program.
Output of Above Program:
For the sake of convenience, assume every structure type variable is allocated on 4 byte
boundary (say 0x0000), i.e. the base address of structure is multiple of 4 (need not
necessary always, see explanation of structc_t).
structure A
The structa_t first element is char which is one byte aligned, followed by short int. short int is 2 byte
aligned. If the the short int element is immediately allocated after the char element, it will start at an odd
address boundary. The compiler will insert a padding byte after the char to ensure short int will have an
address multiple of 2 (i.e. 2 byte aligned). The total size of structa_t will be sizeof(char) + 1 (padding) +
sizeof(short), 1 + 1 + 2 = 4 bytes.
structure B
The first member of structb_t is short int followed by char. Since char can be on any byte boundary no
padding required in between short int and char, on total they occupy 3 bytes. The next member is int. If the
int is allocated immediately, it will start at an odd byte boundary. We need 1 byte padding after the char
member to make the address of next int member is 4 byte aligned. On total, the structb_t requires 2 + 1 + 1
(padding) + 4 = 8 bytes.
structure C – Every structure will also have alignment requirements
Applying same analysis, structc_t needs sizeof(char) + 7 byte padding + sizeof(double) + sizeof(int) = 1 + 7 +
8 + 4 = 20 bytes. However, the sizeof(structc_t) will be 24 bytes. It is because, along with structure
members, structure type variables will also have natural alignment. Let us understand it by an example. Say,
we declared an array of structc_t as shown below

structc_t structc_array[3];

Assume, the base address of structc_array is 0x0000 for easy calculations. If the structc_t occupies 20
(0x14) bytes as we calculated, the second structc_t array element (indexed at 1) will be at 0x0000 + 0x0014
= 0x0014. It is the start address of index 1 element of array. The double member of this structc_t will be
allocated on 0x0014 + 0x1 + 0x7 = 0x001C (decimal 28) which is not multiple of 8 and conflicting with the
alignment requirements of double. As we mentioned on the top, the alignment requirement of double is 8
bytes.
Inorder to avoid such misalignment, compiler will introduce alignment requirement to every structure. It
will be as that of the largest member of the structure. In our case alignment of structa_t is 2, structb_t is 4
and structc_t is 8. If we need nested structures, the size of largest inner structure will be the alignment of
immediate larger structure.
In structc_t of the above program, there will be padding of 4 bytes after int member to make the structure
size multiple of its alignment. Thus the sizeof (structc_t) is 24 bytes. It guarantees correct alignment even in
arrays. You can cross check.
structure D – How to Reduce Padding?

By now, it may be clear that padding is unavoidable. There is a way to minimize padding. The programmer
should declare the structure members in their increasing/decreasing order of size. An example is structd_t
given in our code, whose size is 16 bytes in lieu of 24 bytes of structc_t.
What is structure packing?
Some times it is mandatory to avoid padded bytes among the members of structure. For example, reading
contents of ELF file header or BMP or JPEG file header. We need to define a structure similar to that of the
header layout and map it. However, care should be exercised in accessing such members. Typically reading
byte by byte is an option to avoid misaligned exceptions. There will be hit on performance.
Most of the compilers provide non standard extensions to switch off the default padding like pragmas or
command line switches. Consult the documentation of respective compiler for more details.
Pointer Mishaps:
There is possibility of potential error while dealing with pointer arithmetic. For example, dereferencing a
generic pointer (void *) as shown below can cause misaligned exception,

// Deferencing a generic pointer (not safe)
// There is no guarantee that pGeneric is integer aligned
*(int *)pGeneric;

It is possible above type of code in programming. If the pointer pGeneric is not aligned as per the
requirements of casted data type, there is possibility to get misaligned exception.
Infact few processors will not have the last two bits of address decoding, and there is no way to access
misaligned address. The processor generates misaligned exception, if the programmer tries to access such
address.
A note on malloc() returned pointer
The pointer returned by malloc() is void *. It can be converted to any data type as per the need of
programmer. The implementer of malloc() should return a pointer that is aligned to maximum size of
primitive data types (those defined by compiler). It is usually aligned to 8 byte boundary on 32 bit machines.
Object File Alignment, Section Alignment, Page Alignment
These are specific to operating system implementer, compiler writers and are beyond the scope of this
article. Infact, I don’t have much information.
General Questions:
1. Is alignment applied for stack?
Yes. The stack is also memory. The system programmer should load the stack pointer with a memory
address that is properly aligned. Generally, the processor won’t check stack alignment, it is the
programmer’s responsibility to ensure proper alignment of stack memory. Any misalignment will cause run
time surprises.
For example, if the processor word length is 32 bit, stack pointer also should be aligned to be multiple of 4
bytes.
2. If char data is placed in a bank other bank 0, it will be placed on wrong data lines during memory read.
How the processor handles char type?
Usually, the processor will recognize the data type based on instruction (e.g. LDRB on ARM processor).
Depending on the bank it is stored, the processor shifts the byte onto least significant data lines.
3. When arguments passed on stack, are they subjected to alignment?
Yes. The compiler helps programmer in making proper alignment. For example, if a 16-bit value is pushed
onto a 32-bit wide stack, the value is automatically padded with zeros out to 32 bits. Consider the following
program.
void argument_alignment_check( char c1, char c2 )

{
// Considering downward stack
// (on upward stack the output will be negative)
printf("Displacement %d\n", (int)&c2 - (int)&c1);
}

The output will be 4 on a 32 bit machine. It is because each character occupies 4 bytes due to alignment
requirements.
4. What will happen if we try to access a misaligned data?
It depends on processor architecture. If the access is misaligned, the processor automatically issues sufficient
memory read cycles and packs the data properly onto the data bus. The penalty is on performance. Where as
few processors will not have last two address lines, which means there is no-way to access odd byte
boundary. Every data access must be aligned (4 bytes) properly. A misaligned access is critical exception on
such processors. If the exception is ignored, read data will be incorrect and hence the results.
5. Is there any way to query alignment requirements of a data type.
Yes. Compilers provide non standard extensions for such needs. For example, __alignof() in Visual Studio
helps in getting the alignment requirements of data type. Read MSDN for details.
6. When memory reading is efficient in reading 4 bytes at a time on 32 bit machine, why should a double
type be aligned on 8 byte boundary?
It is important to note that most of the processors will have math co-processor, called Floating Point Unit
(FPU). Any floating point operation in the code will be translated into FPU instructions. The main processor
is nothing to do with floating point execution. All this will be done behind the scenes.
As per standard, double type will occupy 8 bytes. And, every floating point operation performed in FPU will
be of 64 bit length. Even float types will be promoted to 64 bit prior to execution.
The 64 bit length of FPU registers forces double type to be allocated on 8 byte boundary. I am assuming (I
don’t have concrete information) in case of FPU operations, data fetch might be different, I mean the data
bus, since it goes to FPU. Hence, the address decoding will be different for double types (which is expected
to be on 8 byte boundary). It means, the address decoding circuits of floating point unit will not have last 3
pins.
Answers:

sizeof(structa_t) = 4
sizeof(structb_t) = 8
sizeof(structc_t) = 24
sizeof(structd_t) = 16

Update: 1-May-2013
It is observed that on latest processors we are getting size of struct_c as 16 bytes. I yet to
read relevant documentation. I will update once I got proper information (written to few experts in
hardware).
On older processors (AMD Athlon X2) using same set of tools (GCC 4.7) I got struct_c size as 24 bytes. The
size depends on how memory banking organized at the hardware level.
– – – by Venki. Please write comments if you find anything incorrect, or you want to share more
Find duplicates in O(n) time and O(1) extra space
Given an array of n elements which contains elements from 0 to n-1, with any of these numbers appearing
any number of times. Find these repeating numbers in O(n) and using only constant memory space.
For example, let n be 7 and array be {1, 2, 3, 1, 3, 6, 6}, the answer should be 1, 3 and 6.
This problem is an extended version of following problem.
Find the two repeating elements in a given array
Method 1 and Method 2 of the above link are not applicable as the question says O(n) time complexity and
O(1) constant space. Also, Method 3 and Method 4 cannot be applied here because there can be more than 2
repeating elements in this problem. Method 5 can be extended to work for this problem. Below is the
solution that is similar to the Method 5.
Algorithm:

traverse the list for i= 0 to n-1 elements
{
check for sign of A[abs(A[i])] ;
if positive then
make it negative by A[abs(A[i])]=-A[abs(A[i])];
else // i.e., A[abs(A[i])] is negative
this element (ith element of list) is a repetition
}

Implementation:
#include <stdio.h>
#include <stdlib.h>

{
int i;
printf("The repeating elements are: \n");
for (i = 0; i < size; i++)
{
if (arr[abs(arr[i])] >= 0)
arr[abs(arr[i])] = -arr[abs(arr[i])];
else
}
}
int main()
{
int arr[] = {1, 2, 3, 1, 3, 6, 6};
getchar();
return 0;
}

Note: The above program doesn’t handle 0 case (If 0 is present in array). The program can be easily
modified to handle that also. It is not handled to keep the code simple.
Output:
The repeating elements are:
1 3 6

same problem.
Equilibrium index of an array
Equilibrium index of an array is an index such that the sum of elements at lower indexes is equal to the sum
of elements at higher indexes. For example, in an arrya A:
A[0] = -7, A[1] = 1, A[2] = 5, A[3] = 2, A[4] = -4, A[5] = 3, A[6]=0
3 is an equilibrium index, because:

A[0] + A[1] + A[2] = A[4] + A[5] + A[6]
6 is also an equilibrium index, because sum of zero elements is zero, i.e., A[0] + A[1] + A[2] + A[3] + A[4] +
A[5]=0
7 is not an equilibrium index, because it is not a valid index of array A.
Write a function int equilibrium(int[] arr, int n); that given a sequence arr[] of size n, returns an equilibrium
index (if any) or -1 if no equilibrium indexes exist.
Method 1 (Simple but inefficient)

Use two loops. Outer loop iterates through all the element and inner loop finds out whether the current index
picked by the outer loop is equilibrium index or not. Time complexity of this solution is O(n^2).

#include <stdio.h>
int equilibrium(int arr[], int n)

{
int i, j;
int leftsum, rightsum;
/* Check for indexes one by one until an equilibrium

index is found */
for ( i = 0; i < n; ++i)
{
leftsum = 0; // initialize left sum for current index i
rightsum = 0; // initialize right sum for current index i
/* get left sum */

for ( j = 0; j < i; j++)
leftsum += arr[j];
/* get right sum */

for( j = i+1; j < n; j++)
rightsum += arr[j];
/* if leftsum and rightsum are same, then we are done */

if (leftsum == rightsum)
return i;
}
/* return -1 if no equilibrium index is found */

return -1;
}
int main()
{
int arr[] = {-7, 1, 5, 2, -4, 3, 0};
printf("%d\n", equilibrium(arr, arr_size));
getchar();
return 0;
}


The idea is to get total sum of array first. Then Iterate through the array and keep updating the left sum
which is initialized as zero. In the loop, we can get right sum by subtracting the elements one by one. Thanks
to Sambasiva for suggesting this solution and providing code for this.

1) Initialize leftsum as 0
2) Get the total sum of the array as sum
3) Iterate through the array and for each index i, do following.
a) Update sum to get the right sum.
sum = sum - arr[i]
// sum is now right sum
b) If leftsum is equal to sum, then return current index.
c) leftsum = leftsum + arr[i] // update leftsum for next iteration.
4) return -1 // If we come out of loop without returning then
// there is no equilibrium index

#include <stdio.h>
int equilibrium(int arr[], int n)

{
int sum = 0; // initialize sum of whole array
int leftsum = 0; // initialize leftsum
int i;
/* Find sum of the whole array */

for (i = 0; i < n; ++i)
sum += arr[i];
for( i = 0; i < n; ++i)

{
sum -= arr[i]; // sum is now right sum for index i
if(leftsum == sum)
return i;
leftsum += arr[i];
}
/* If no equilibrium index found, then return 0 */

return -1;
}
int main()
{
int arr[] = {-7, 1, 5, 2, -4, 3, 0};
printf("First equilibrium index is %d\n", equilibrium(arr, arr_size));
getchar();
return 0;
}

As pointed out by Sameer, we can remove the return statement and add a print statement to print all
equilibrium indexes instead of returning only one.
same problem.
Predict the outputs of following program.
Question 1
#include <stdio.h>
int main()
{
int a = 10, b = 20, c = 30;
if (c > b > a)
{
printf("TRUE");
}
else
{
printf("FALSE");
}
getchar();
return 0;
}

Output: FALSE
Let us consider the condition inside the if statement. Since there are two greater than (>) operators in
expression “c > b > a”, associativity of > is considered. Associativity of > is left to right. So, expression c > b >
a is evaluated as ( (c > b) > a ) which is false.
When does the worst case of Quicksort occur?
The answer depends on strategy for choosing pivot. In early versions of Quick Sort where leftmost (or
rightmost) element is chosen as pivot, the worst occurs in following cases.
1) Array is already sorted in same order.

2) Array is already sorted in reverse order.
3) All elements are same (special case of case 1 and 2)
Since these cases are very common use cases, the problem was easily solved by choosing either a random
index for the pivot, choosing the middle index of the partition or (especially for longer partitions) choosing
the median of the first, middle and last element of the partition for the pivot. With these modifications, the
worst case of Quick sort has less chances to occur, but worst case can still occur if the input array is such that
the maximum (or minimum) element is always chosen as pivot.
References:
http://en.wikipedia.org/wiki/Quicksort
Stability in sorting algorithms
A sorting algorithm is said to be stable if two objects with equal keys appear in the same order in sorted
output as they appear in the input unsorted array. Some sorting algorithms are stable by nature like
Insertion sort, Merge Sort, Bubble Sort, etc. And some sorting algorithms are not, like Heap Sort, Quick
Sort, etc.
However, any given sorting algo which is not stable can be modified to be stable. There can be sorting algo
specific ways to make it stable, but in general, any comparison based sorting algorithm which is not stable by
nature can be modified to be stable by changing the key comparison operation so that the comparison of two
keys considers position as a factor for objects with equal keys.
References:
http://www.math.uic.edu/~leon/cs-mcs401-s08/handouts/stability.pdf
http://en.wikipedia.org/wiki/Sorting_algorithm#Stability
discussed above.
Applications of Heap Data Structure
Heap Data Structure is generally taught with Heapsort. Heapsort algorithm has limited uses because
Quicksort is better in practice. Nevertheless, the Heap data structure itself is enormously used. Following
are some uses other than Heapsort.
Priority Queues: Priority queues can be efficiently implemented using Binary Heap because it supports
insert(), delete() and extractmax(), decreaseKey() operations in O(logn) time. Binomoial Heap and
Fibonacci Heap are variations of Binary Heap. These variations perform union also in O(logn) time which is
a O(n) operation in Binary Heap. Heap Implemented priority queues are used in Graph algorithms like
Prim’s Algorithm and Dijkstra’s algorithm.
Order statistics: The Heap data structure can be used to efficiently find the kth smallest (or largest) element
in an array. See method 4 and 6 of this post for details.
References:
http://net.pku.edu.cn/~course/cs101/2007/resource/Intro2Algorithm/book6/chap07.htm
http://en.wikipedia.org/wiki/Heap_%28data_structure%29
discussed above.
Linked List vs Array
Both Arrays and Linked List can be used to store linear data of similar types, but they both have some
advantages and disadvantages over each other.
Following are the points in favour of Linked Lists.
(1) The size of the arrays is fixed: So we must know the upper limit on the number of elements in advance.
Also, generally, the allocated memory is equal to the upper limit irrespective of the usage, and in practical
uses, upper limit is rarely reached.
(2) Inserting a new element in an array of elements is expensive, because room has to be created for the new
elements and to create room existing elements have to shifted.
For example, suppose we maintain a sorted list of IDs in an array id[].
id[] = [1000, 1010, 1050, 2000, 2040, …..].
And if we want to insert a new ID 1005, then to maintain the sorted order, we have to move all the elements
after 1000 (excluding 1000).
Deletion is also expensive with arrays until unless some special techniques are used. For example, to delete
1010 in id[], everything after 1010 has to be moved.
So Linked list provides following two advantages over arrays

1) Dynamic size
2) Ease of insertion/deletion
Linked lists have following drawbacks:

1) Random access is not allowed. We have to access elements sequentially starting from the first node. So we
cannot do binary search with linked lists.
2) Extra memory space for a pointer is required with each element of the list.
3) Arrays have better cache locality that can make a pretty big difference in performance.
Please also see this thread.
References:
http://cslibrary.stanford.edu/103/LinkedListBasics.pdf
discussed above.
Access specifiers for classes or interfaces in Java
In Java, methods and data members of a class/interface can have one of the following four access specifiers.
The access specifiers are listed according to their restrictiveness order.
1) private
2) default (when no access specifier is specified)
3) protected
4) public
But, the classes and interfaces themselves can have only two access specifiers.
1) public
2) default (when no access specifier is specified)
We cannot declare class/interface with private or protected access specifiers. For example, following
program fails in compilation.
//filename: Main.java
protected class Test {}
public class Main {

}
}

discussed above.
Floating Point Representation – Basics
There are posts on representation of floating point format. The objective of this article is to provide a brief
introduction to floating point format.
The following description explains terminology and primary details of IEEE 754 binary floating point
representation. The discussion confines to single and double precision formats.
Usually, a real number in binary will be represented in the following format,
ImIm-1 …I2I1I0.F1F2…FnFn-1
Where Im and Fn will be either 0 or 1 of integer and fraction parts respectively.
A finite number can also represented by four integers components, a sign (s), a base (b), a significand (m),
and an exponent (e). Then the numerical value of the number is evaluated as
(-1)s x m x be ________ Where m < |b|
Depending on base and the number of bits used to encode various components, the IEEE 754 standard
defines five basic formats. Among the five formats, the binary32 and the binary64 formats are single
precision and double precision formats respectively in which the base is 2.
Table – 1 Precision Representation
Precision BaseSignExponentSignificand
Single precision 2 1 8 23+1
Double precision2 1 11 52+1
Single Precision Format:
As mentioned in Table 1 the single precision format has 23 bits for significand (1 represents implied bit,
details below), 8 bits for exponent and 1 bit for sign.
For example, the rational number 9÷2 can be converted to single precision float format as following,
9(10) ÷ 2(10) = 4.5(10) = 100.1(2)
The result said to be normalized, if it is represented with leading 1 bit, i.e. 1.001(2) x 22. (Similarly when
the number 0.000000001101(2) x 23 is normalized, it appears as 1.101(2) x 2-6). Omitting this implied 1 on
left extreme gives us the mantissa of float number. A normalized number provides more accuracy than
corresponding de-normalized number. The implied most significant bit can be used to represent even
more accurate significand (23 + 1 = 24 bits) which is called subnormal representation. The floating point
numbers are to be represented in normalized form.
The subnormal numbers fall into the category of de-normalized numbers. The subnormal representation
slightly reduces the exponent range and can’t be normalized since that would result in an exponent which
doesn’t fit in the field. Subnormal numbers are less accurate, i.e. they have less room for nonzero bits in the
fraction field, than normalized numbers. Indeed, the accuracy drops as the size of the subnormal number
decreases. However, the subnormal representation is useful in filing gaps of floating point scale near zero.
In other words, the above result can be written as (-1)0 x 1.001(2) x 22 which yields the integer components as
s = 0, b = 2, significand (m) = 1.001, mantissa = 001 and e = 2. The corresponding single precision floating
number can be represented in binary as shown below,
Where the exponent field is supposed to be 2, yet encoded as 129 (127+2) called biased exponent. The
exponent field is in plain binary format which also represents negative exponents with an encoding (like sign
magnitude, 1’s compliment, 2’s complement, etc.). The biased exponent is used for representation of
negative exponents. The biased exponent has advantages over other negative representations in performing
bitwise comparing of two floating point numbers for equality.
A bias of (2n-1 – 1), where n is # of bits used in exponent, is added to the exponent (e) to get biased
exponent (E). So, the biased exponent (E) of single precision number can be obtained as
E = e + 127
The range of exponent in single precision format is -126 to +127. Other values are used for special symbols.
Note: When we unpack a floating point number the exponent obtained is biased exponent. Subtracting 127
from the biased exponent we can extract unbiased exponent.
Float Scale:
The following figure represents floating point scale.
Double Precision Format:
As mentioned in Table – 1 the double precision format has 52 bits for significand (1 represents implied bit),
10 bits for exponent and 1 bit for sign. All other definitions are same for double precision format, except for
the size of various components.
Precision:
The smallest change that can be represented in floating point representation is called as precision. The
fractional part of a single precision normalized number has exactly 23 bits of resolution, (24 bits with the
implied bit). This corresponds to log(10) (223) = 6.924 = 7 (the characteristic of logarithm) decimal digits of
accuracy. Similarly, in case of double precision numbers the precision is log(10) (252) = 15.654 = 16 decimal
digits.
Accuracy:
Accuracy in floating point representation is governed by number of significand bits, whereas range is limited
by exponent. Not all real numbers can exactly be represented in floating point format. For any numberwhich
is not floating point number, there are two options for floating point approximation, say, the closest floating
point number less than x as x_ and the closest floating point number greater than x as x+. A rounding
operation is performed on number of significant bits in the mantissa field based on the selected mode. The
round down mode causes x set to x_, the round up mode causes x set to x+, the round towards zero
mode causes x is either x_ or x+ whichever is between zero and. The round to nearest mode sets x to x_
or x+ whichever is nearest to x. Usually round to nearest is most used mode. The closeness of floating
point representation to the actual value is called as accuracy.
Special Bit Patterns:
The standard defines few special floating point bit patterns. Zero can’t have most significant 1 bit, hence
can’t be normalized. The hidden bit representation requires a special technique for storing zero. We will have
two different bit patterns +0 and -0 for the same numerical value zero. For single precision floating point
representation, these patterns are given below,
0 00000000 00000000000000000000000 = +0
1 00000000 00000000000000000000000 = -0
Similarly, the standard represents two different bit patters for +INF and -INF. The same are given below,
0 11111111 00000000000000000000000 = +INF
1 11111111 00000000000000000000000 = -INF
All of these special numbers, as well as other special numbers (below) are subnormal numbers, represented
through the use of a special bit pattern in the exponent field. This slightly reduces the exponent range, but
this is quite acceptable since the range is so large.
An attempt to compute expressions like 0 x INF, 0 ÷ INF, etc. make no mathematical sense. The standard
calls the result of such expressions as Not a Number (NaN). Any subsequent expression with NaN yields
NaN. The representation of NaN has non-zero significand and all 1s in the exponent field. These are shown
below for single precision format (x is don’t care bits),
x 11111111 1m0000000000000000000000
Where m can be 0 or 1. This gives us two different representations of NaN.
0 11111111 110000000000000000000000 _____________ Signaling NaN (SNaN)
0 11111111 100000000000000000000000 _____________Quiet NaN (QNaN)
Usually QNaN and SNaN are used for error handling. QNaN do not raise any exceptions as they propagate
through most operations. Whereas SNaN are which when consumed by most operations will raise an invalid
exception.
Overflow and Underflow:
Overflow is said to occur when the true result of an arithmetic operation is finite but larger in magnitude
than the largest floating point number which can be stored using the given precision. Underflow is said to
occur when the true result of an arithmetic operation is smaller in magnitude (infinitesimal) than the
smallest normalized floating point number which can be stored. Overflow can’t be ignored in calculations
whereas underflow can effectively be replaced by zero.
Endianness:
The IEEE 754 standard defines a binary floating point format. The architecture details are left to the
hardware manufacturers. The storage order of individual bytes in binary floating point number varies from
architecture to architecture.
Thanks to Venki for writing the above article. Please write comments if you find anything incorrect, or you
Which sorting algorithm makes minimum number of memory writes?
Minimizing the number of writes is useful when making writes to some huge data set is very expensive, such
as with EEPROMs or Flash memory, where each write reduces the lifespan of the memory.
Among the sorting algorithms that we generally study in our data structure and algorithm courses, Selection
Sort makes least number of writes (it makes O(n) swaps). But, Cycle Sort almost always makes less number
of writes compared to Selection Sort. In Cycle Sort, each value is either written zero times, if it’s already in
its correct position, or written one time to its correct position. This matches the minimal number of
overwrites required for a completed in-place sort.
Sources:
http://en.wikipedia.org/wiki/Cycle_sort
http://en.wikipedia.org/wiki/Selection_sort
discussed above.
Turn an image by 90 degree
Given an image, how will you turn it by 90 degrees? A vague question. Minimize the browser and try your
solution before going further.
An image can be treated as 2D matrix which can be stored in a buffer. We are provided with matrix
dimensions and it’s base address. How can we turn it?
For example see the below picture,

* * * ^ * * *
* * * | * * *
* * * | * * *
* * * | * * *

After rotating right, it appears (observe arrow direction)

* * * *
* * * *
* * * *
-- - - >
* * * *
* * * *
* * * *

The idea is simple. Transform each row of source matrix into required column of final image. We will use
an auxiliary buffer to transform the image.
From the above picture, we can observe that

first row of source ------> last column of destination
second row of source ------> last but-one column of destination
so ... on
last row of source ------> first column of destination

In pictorial form, we can represent the above transformations of an (m x n) matrix into (n x m) matrix,
Transformations
If you have not attempted, atleast try your pseudo code now.
It will be easy to write our pseudo code. In C/C++ we will usually traverse matrix on row major order. Each
row is transformed into different column of final image. We need to construct columns of final image. See
the following algorithm (transformation)

for(r = 0; r < m; r++)
{
for(c = 0; c < n; c++)
{
// Hint: Map each source element indices into
// indices of destination matrix element.
dest_buffer [ c ] [ m - r - 1 ] = source_buffer [ r ] [ c ];
}
}

Note that there are various ways to implement the algorithm based on traversal of matrix, row major or
column major order. We have two matrices and two ways (row and column major) to traverse each matrix.
Hence, there can atleast be 4 different ways of transformation of source matrix into final matrix.
Code:

#include <stdio.h>
#include <stdlib.h>
void displayMatrix(unsigned int const *p, unsigned int row, unsigned int col);
void rotate(unsigned int *pS, unsigned int *pD, unsigned int row, unsigned int col);
int main()
{
// declarations
unsigned int image[][4] = {{1,2,3,4}, {5,6,7,8}, {9,10,11,12}};
unsigned int *pSource;
unsigned int *pDestination;
unsigned int m, n;
// setting initial values and memory allocation

m = 3, n = 4, pSource = (unsigned int *)image;
pDestination = (unsigned int *)malloc(sizeof(int)*m*n);
// process each buffer

displayMatrix(pSource, m, n);
rotate(pSource, pDestination, m, n);
displayMatrix(pDestination, n, m);
free(pDestination);
getchar();
return 0;
}
void displayMatrix(unsigned int const *p, unsigned int r, unsigned int c)

{
unsigned int row, col;
printf("\n\n");
for(row = 0; row < r; row++)

{
for(col = 0; col < c; col++)
{
printf("%d\t", *(p + row * c + col));
}
printf("\n");
}
printf("\n\n");
}
void rotate(unsigned int *pS, unsigned int *pD, unsigned int row, unsigned int col)
{
unsigned int r, c;
for(r = 0; r < row; r++)
{
for(c = 0; c < col; c++)
{
*(pD + c * row + (row - r - 1)) = *(pS + r * col + c);
}
}
}

Compiled by Venki. Please write comments if you find anything incorrect, or you want to share more
Question 1
#include<iostream>

class P {
public:
void print()
{ cout <<" Inside P::"; }
};
class Q : public P {
public:
void print()
{ cout <<" Inside Q"; }
};
class R: public Q {
};
int main(void)
{
R r;
r.print();
return 0;
}

Output:
Inside Q
The print function is not defined in class R. So it is looked up in the inheritance hierarchy. print() is present
in both classes P and Q, which of them should be called? The idea is, if there is multilevel inheritance, then
function is linearly searched up in the inheritance heirarchy until a matching function is found.
Question 2

#include<iostream>
#include<stdio.h>
class Base
{
public:
Base()
{
fun(); //note: fun() is virtual
}
virtual void fun()
{
cout<<"\nBase Function";
}
};
class Derived: public Base

{
public:
Derived(){}
virtual void fun()
{
cout<<"\nDerived Function";
}
};
int main()
{
Base* pBase = new Derived();
delete pBase;
return 0;
}

Output:
Base Function
See following excerpt from C++ standard for explanation.
When a virtual function is called directly or indirectly from a constructor (including from the mem-
initializer for a data member) or from a destructor, and the object to which the call applies is the object
under construction or destruction, the function called is the one defined in the constructor or destructor’s
own class or in one of its bases, but not a function overriding it in a class derived from the constructor or
destructor’s class, or overriding it in one of the other base classes of the most derived object.
Because of this difference in behavior, it is recommended that object’s virtual function is not invoked while it
is being constructed or destroyed. See this for more details.
Applications of tree data structure
Why Tree?
Unlike Array and Linked List, which are linear data structures, tree is hierarchical (or non-linear) data
structure.
1) One reason to use trees might be because you want to store information that naturally forms a hierarchy.
For example, the file system on a computer:
file system
———–
/
2) If we organize keys in form of a tree (with some ordering e.g., BST), we can search f
or a given key in moderate time (quicker than Linked List and slower than arrays). Self-
balancing search trees like AVL and Red-Black trees guarantee an upper bound of O(Logn)
for search.
3) We can insert/delete keys in moderate time (quicker than Arrays and slower than
Unordered Linked Lists). Self-balancing search trees like AVL and Red-Black trees guaran
tee an upper bound of O(Logn) for insertion/deletion.
4) Like Linked Lists and unlike Arrays, Pointer implementation of trees don’t have an u
pper limit on number of nodes as nodes are linked using pointers.
As per Wikipedia, following are the common uses of tree.
1. Manipulate hierarchical data.
2. Make information easy to search (see tree traversal).
3. Manipulate sorted lists of data.
4. As a workflow for compositing digital images for visual effects.
5. Router algorithms
References:
http://www.cs.bu.edu/teaching/c/tree/binary/
http://en.wikipedia.org/wiki/Tree_%28data_structure%29#Common_uses

Next higher number with same number of set bits
Given a number x, find next number with same number of 1 bits in it’s binary representation.
For example, consider x = 12, whose binary representation is 1100 (excluding leading zeros on 32 bit
machine). It contains two logic 1 bits. The next higher number with two logic 1 bits is 17 (100012).
Algorithm:
When we observe the binary sequence from 0 to 2n – 1 (n is # of bits), right most bits (least significant) vary
rapidly than left most bits. The idea is to find right most string of 1’s in x, and shift the pattern to right
extreme, except the left most bit in the pattern. Shift the left most bit in the pattern (omitted bit) to left part
of x by one position. An example makes it more clear,

x = 156

10

x = 10011100

(2)

10011100
00011100 - right most string of 1's in x
00000011 - right shifted pattern except left most bit ------> [A]
00010000 - isolated left most bit of right most 1's pattern
00100000 - shiftleft-ed the isolated bit by one position ------> [B]
10000000 - left part of x, excluding right most 1's pattern ------> [C]
10100000 - add B and C (OR operation) ------> [D]
10100011 - add A and D which is required number 163

(10)
After practicing with few examples, it easy to understand. Use the below given program for generating more
sets.
Program Design:
We need to note few facts of binary numbers. The expression x & -x will isolate right most set bit in x
(ensuring x will use 2’s complement form for negative numbers). If we add the result to x, right most string of
1’s in x will be reset, and the immediate ‘0’ left to this pattern of 1’s will be set, which is part [B] of above
explanation. For example if x = 156, x & -x will result in 00000100, adding this result to x yields 10100000
(see part D). We left with the right shifting part of pattern of 1’s (part A of above explanation).
There are different ways to achieve part A. Right shifting is essentially a division operation. What should be
our divisor? Clearly, it should be multiple of 2 (avoids 0.5 error in right shifting), and it should shift the right
most 1’s pattern to right extreme. The expression (x & -x) will serve the purpose of divisor. An EX-OR
operation between the number X and expression which is used to reset right most bits, will isolate the
rightmost 1’s pattern.
A Correction Factor:
Note that we are adding right most set bit to the bit pattern. The addition operation causes a shift in the bit
positions. The weight of binary system is 2, one shift causes an increase by a factor of 2. Since the increased
number (rightOnesPattern in the code) being used twice, the error propagates twice. The error needs to be
corrected. A right shift by 2 positions will correct the result.
The popular name for this program is same number of one bits.

#include<iostream>
typedef unsigned int uint_t;
// this function returns next higher number with same number of set bits as x.
uint_t snoob(uint_t x)
{
uint_t rightOne;
uint_t nextHigherOneBit;
uint_t rightOnesPattern;
uint_t next = 0;
if(x)
{
// right most set bit

rightOne = x & -(signed)x;
// reset the pattern and set next higher bit

// left part of x will be here
nextHigherOneBit = x + rightOne;
// nextHigherOneBit is now part [D] of the above explanation.
// isolate the pattern

rightOnesPattern = x ^ nextHigherOneBit;
// right adjust pattern

rightOnesPattern = (rightOnesPattern)/rightOne;
// correction factor
rightOnesPattern >>= 2;
// rightOnesPattern is now part [A] of the above explanation.
// integrate new pattern (Add [D] and [A])

next = nextHigherOneBit | rightOnesPattern;
}
return next;
}
int main()
{
int x = 156;
cout<<"Next higher number with same number of set bits is "<<snoob(x);
getchar();
return 0;
}

Usage: Finding/Generating subsets.
Variations:
1. Write a program to find a number immediately smaller than given, with same number of logic 1 bits?
(Pretty simple)
2. How to count or generate the subsets available in the given set?
References:
1. A nice presentation here.

2. Hackers Delight by Warren (An excellent and short book on various bit magic algorithms, a must
for enthusiasts)
3. C A Reference Manual by Harbison and Steele (A good book on standard C, you can access code part
of this post here).
– Venki. Please write comments if you find anything incorrect, or you want to share more information
about the topic discussed above.
Inorder Successor in Binary Search Tree
In Binary Tree, Inorder successor of a node is the next node in Inorder traversal of the Binary Tree. Inorder
Successor is NULL for the last node in Inoorder traversal.
In Binary Search Tree, Inorder Successor of an input node can also be defined as the node with the smallest
key greater than the key of input node. So, it is sometimes important to find next node in sorted order.
In the above diagram, inorder successor of 8 is 10, inorder successor of 10 is 12 and inorder successor of 14
is 20.
Method 1 (Uses Parent Pointer)

In this method, we assume that every node has parent pointer.
The Algorithm is divided into two cases on the basis of right subtree of the input node being empty or not.
Input: node, root // node is the node whose Inorder successor is needed.
output: succ // succ is Inorder successor of node.
1) If right subtree of node is not NULL, then succ lies in right subtree. Do following.
Go to right subtree and return the node with minimum key value in right subtree.
2) If right sbtree of node is NULL, then succ is one of the ancestors. Do following.
Travel up using the parent pointer until you see a node which is left child of it’s parent. The parent of such a
node is the succ.
Implementation
Note that the function to find InOrder Successor is highlighted (with gray background) in below code.
#include <stdio.h>
#include <stdlib.h>

struct node
{
int data;
struct node* left;
struct node* right;
struct node* parent;
};
struct node * minValue(struct node* node);
struct node * inOrderSuccessor(struct node *root, struct node *n)

{
// step 1 of the above algorithm
if( n->right != NULL )
return minValue(n->right);

struct node *p = n->parent;
while(p != NULL && n == p->right)
{
n = p;
p = p->parent;
}
return p;
}
/* Given a non-empty binary search tree, return the minimum data

value found in that tree. Note that the entire tree does not need
to be searched. */
struct node * minValue(struct node* node) {

while (current->left != NULL) {
}
return current;
}
/* Helper function that allocates a new node with the given data and
NULL left and right pointers. */
{
node->data = data;
node->left = NULL;
node->right = NULL;
node->parent = NULL;

return(node);
}
/* Give a binary search tree and a number, inserts a new node with
the given number in the correct place in the tree. Returns the new
root pointer which the caller should then use (the standard trick to
avoid using reference parameters). */
{
/* 1. If the tree is empty, return a new,
single node */
if (node == NULL)
return(newNode(data));
else
{
struct node *temp;
/* 2. Otherwise, recur down the tree */

{
temp = insert(node->left, data);
node->left = temp;
temp->parent= node;
}
else
{
temp = insert(node->right, data);
temp = insert(node->right, data);
node->right = temp;
temp->parent = node;
}

return node;
}
}

int main()
{
struct node* root = NULL, *temp, *succ, *min;
//creating the tree given in the above diagram

temp = root->left->right->right;
succ = inOrderSuccessor(root, temp);

if(succ != NULL)
printf("\n Inorder Successor of %d is %d ", temp->data, succ->data);
else
printf("\n Inorder Successor doesn't exit");
getchar();
return 0;
}

Output of the above program:

Inorder Successor of 14 is 20
Time Complexity: O(h) where h is height of tree.
Method 2 (Search from root)

Parent pointer is NOT needed in this algorithm. The Algorithm is divided into two cases on the basis of right
subtree of the input node being empty or not.
Input: node, root // node is the node whose Inorder successor is needed.
output: succ // succ is Inorder successor of node.
1) If right subtree of node is not NULL, then succ lies in right subtree. Do following.
Go to right subtree and return the node with minimum key value in right subtree.
2) If right sbtree of node is NULL, then start from root and us search like technique. Do following.
Travel down the tree, if a node’s data is greater than root’s data then go right side, otherwise go to left side.

struct node * inOrderSuccessor(struct node *root, struct node *n)

{
if( n->right != NULL )
return minValue(n->right);
struct node *succ = NULL;
// Start from root and search for successor down the tree
{
if (n->data < root->data)
{
succ = root;
root = root->left;
}
else if (n->data > root->data)
root = root->right;
else
break;
}
return succ;
}

Thanks to R.Srinivasan for suggesting this method.
Time Complexity: O(h) where h is height of tree.
References:
discussed above.
Find k-th smallest element in BST (Order Statistics in BST)
Given root of binary search tree and K as input, find K-th smallest element in BST.
For example, in the following BST, if k = 3, then output should be 10, and if k = 5, then output should be 14.
Method 1: Using Inorder Traversal.
Inorder traversal of BST retrieves elements of tree in the sorted order. The inorder traversal uses stack to
store to be explored nodes of tree (threaded tree avoids stack and recursion for traversal, see this post). The
idea is to keep track of popped elements which participate in the order statics. Hypothetical algorithm is
provided below,
Time complexity: O(n) where n is total nodes in tree..
Algorithm:

/* initialization */
pCrawl = root
set initial stack element as NULL (sentinal)
/* traverse upto left extreme */

while(pCrawl is valid )
stack.push(pCrawl)
pCrawl = pCrawl.left
/* process other nodes */

while( pCrawl = stack.pop() is valid )
stop if sufficient number of elements are popped.
if( pCrawl.right is valid )
pCrawl = pCrawl.right
while( pCrawl is valid )
stack.push(pCrawl)
pCrawl = pCrawl.left

Implementation:

#include <stdio.h>
#include <stdlib.h>
#define ARRAY_SIZE(arr) sizeof(arr)/sizeof(arr[0])
/* just add elements to test */

/* NOTE: A sorted array results in skewed tree */
int ele[] = { 20, 8, 22, 4, 12, 10, 14 };
int ele[] = { 20, 8, 22, 4, 12, 10, 14 };
/* same alias */
typedef struct node_t node_t;
/* Binary tree node */

struct node_t
{
int data;
node_t* left;
node_t* right;
};
/* simple stack that stores node addresses */

typedef struct stack_t stack_t;
/* initial element always NULL, uses as sentinal */

struct stack_t
{
node_t* base[ARRAY_SIZE(ele) + 1];
int stackIndex;
};
/* pop operation of stack */

node_t *pop(stack_t *st)
{
node_t *ret = NULL;
if( st && st->stackIndex > 0 )

{
ret = st->base[st->stackIndex];
st->stackIndex--;
}
return ret;
}
/* push operation of stack */

void push(stack_t *st, node_t *node)
{
if( st )
{
st->stackIndex++;
st->base[st->stackIndex] = node;
}
}
/* Iterative insertion
Recursion is least preferred unless we gain something
*/
node_t *insert_node(node_t *root, node_t* node)
{
/* A crawling pointer */
node_t *pTraverse = root;
node_t *currentParent = root;
// Traverse till appropriate node

while(pTraverse)
{
currentParent = pTraverse;
if( node->data < pTraverse->data )

{
/* left subtree */
/* left subtree */
pTraverse = pTraverse->left;
}
else
{
/* right subtree */
pTraverse = pTraverse->right;
}
}
/* If the tree is empty, make it as root node */

if( !root )
{
root = node;
}
else if( node->data < currentParent->data )
{
/* Insert on left side */
currentParent->left = node;
}
else
{
/* Insert on right side */
currentParent->right = node;
}
return root;
}
/* Elements are in an array. The function builds binary tree */

node_t* binary_search_tree(node_t *root, int keys[], int const size)
{
int iterator;
node_t *new_node = NULL;
for(iterator = 0; iterator < size; iterator++)

{
new_node = (node_t *)malloc( sizeof(node_t) );
/* initialize */
new_node->data = keys[iterator];
new_node->left = NULL;
new_node->right = NULL;
/* insert into BST */

root = insert_node(root, new_node);
}
return root;
}
node_t *k_smallest_element_inorder(stack_t *stack, node_t *root, int k)

{
stack_t *st = stack;
node_t *pCrawl = root;
/* move to left extremen (minimum) */

while( pCrawl )
{
push(st, pCrawl);
pCrawl = pCrawl->left;
}
/* pop off stack and process each node */

while( pCrawl = pop(st) )
{
/* each pop operation emits one element
in the order
*/
if( !--k )
{
/* loop testing */
st->stackIndex = 0;
break;
}
/* there is right subtree */

if( pCrawl->right )
{
/* push the left subtree of right subtree */
pCrawl = pCrawl->right;
while( pCrawl )
{
push(st, pCrawl);
pCrawl = pCrawl->left;
}
/* pop off stack and repeat */

}
}
/* node having k-th element or NULL node */

return pCrawl;
}

int main(void)
{
node_t* root = NULL;
stack_t stack = { {0}, 0 };
node_t *kNode = NULL;
int k = 5;
/* Creating the tree given in the above diagram */

root = binary_search_tree(root, ele, ARRAY_SIZE(ele));
kNode = k_smallest_element_inorder(&stack, root, k);
if( kNode )
{
printf("kth smallest elment for k = %d is %d", k, kNode->data);
}
else
{
printf("There is no such element");
}
getchar();
return 0;
}

Method 2: Augmented Tree Data Structure.
The idea is to maintain rank of each node. We can keep track of elements in a subtree of any node while
building the tree. Since we need K-th smallest element, we can maintain number of elements of left subtree
in every node.
Assume that the root is having N nodes in its left subtree. If K = N + 1, root is K-th node. If K < N, we will
continue our search (recursion) for the Kth smallest element in the left subtree of root. If K > N + 1, we
continue our search in the right subtree for the (K – N – 1)-th smallest element. Note that we need the count
of elements in left subtree only.
Time complexity: O(h) where h is height of tree.
Algorithm:

start:
if K = root.leftElement + 1
root node is the K th node.
goto stop
else if K > root.leftElements
K = K - (root.leftElements + 1)
root = root.right
goto start
else
root = root.left
goto srart
stop:

Implementation:
#include <stdio.h>
#include <stdlib.h>
#define ARRAY_SIZE(arr) sizeof(arr)/sizeof(arr[0])
typedef struct node_t node_t;
/* Binary tree node */

struct node_t
{
int data;
int lCount;
node_t* left;
node_t* right;
};
/* Iterative insertion
Recursion is least preferred unless we gain something
*/
node_t *insert_node(node_t *root, node_t* node)
{
node_t *currentParent = root;
// Traverse till appropriate node

while(pTraverse)
{
currentParent = pTraverse;
if( node->data < pTraverse->data )
{
/* We are branching to left subtree
increment node count */
pTraverse->lCount++;
/* left subtree */
}
else
{
/* right subtree */
}
}
/* If the tree is empty, make it as root node */

if( !root )
{
root = node;
}
else if( node->data < currentParent->data )
{
/* Insert on left side */
currentParent->left = node;
}
else
{
/* Insert on right side */
currentParent->right = node;
}
return root;
}
/* Elements are in an array. The function builds binary tree */

node_t* binary_search_tree(node_t *root, int keys[], int const size)
{
int iterator;
node_t *new_node = NULL;
for(iterator = 0; iterator < size; iterator++)

{
new_node = (node_t *)malloc( sizeof(node_t) );
/* initialize */
new_node->data = keys[iterator];
new_node->lCount = 0;
new_node->left = NULL;
/* insert into BST */

root = insert_node(root, new_node);
}
return root;
}
int k_smallest_element(node_t *root, int k)

{
int ret = -1;
if( root )
{
/* Go to k-th smallest */
while(pTraverse)
{
if( (pTraverse->lCount + 1) == k )
{
ret = pTraverse->data;
break;
}
else if( k > pTraverse->lCount )
{
/* There are less nodes on left subtree
Go to right subtree */
k = k - (pTraverse->lCount + 1);
}
else
{
/* The node is on left subtree */
}
}
}
return ret;
}

int main(void)
{
/* just add elements to test */
/* NOTE: A sorted array results in skewed tree */
int ele[] = { 20, 8, 22, 4, 12, 10, 14 };
int i;
node_t* root = NULL;
/* Creating the tree given in the above diagram */

root = binary_search_tree(root, ele, ARRAY_SIZE(ele));
/* It should print the sorted array */

for(i = 1; i <= ARRAY_SIZE(ele); i++)
{
printf("\n kth smallest elment for k = %d is %d",
i, k_smallest_element(root, i));
}
getchar();
return 0;
}

Thanks to Venki for providing post. Please write comments if you find anything incorrect, or you want to
share more information about the topic discussed above.
OOD Principles | SOLID
Object Oriented Programming paradigm deals with centralizing data and associated behaviours in a single
entity. The entities will communicate by message passing.
The high level languages like C++, Java, C#, etc… provide rich features in designing applications. One can
learn the language constructs easily. However, few design principles guide the programmer for better
utilization of language features. The following principles help programmer to arrive at flexible class design.
1. Single Responsibility Principle

2. Open Closed Principle
3. Liskov Substitution Principle
4. Interface Segregation Principle
5. Dependency Inversion Principle
All the above five principles are collectively called as SOLID principles. We will have detailed explanation of
each principle.
Note that there are few more principles that will be useful in OOD. We will expand the post when
respective principles are published (We are sorry, at present the post is a moving target).
Contributed by Venki. Please write comments if you find anything incorrect, or you want to share more
Sorted insert for circular linked list
Write a C function to insert a new value in a sorted Circular Linked List (CLL). For example, if the input CLL
is following.
After insertion of 7, the above CLL should be changed to following
Algorithm:
Allocate memory for the newly inserted node and put data in the newly allocated node. Let the pointer to the
new node be new_node. After memory allocation, following are the three cases that need to be handled.
1) Linked List is empty:

a) since new_node is the only node in CLL, make a self loop.
new_node->next = new_node;
b) change the head pointer to point to new node.
2) New node is to be inserted just before the head node:
(a) Find out the last node using a loop.
while(current->next != *head_ref)
(b) Change the next of last node.
(c) Change next of new node to point to head.
(d) change the head pointer to point to new node.
3) New node is to be inserted somewhere after the head:
(a) Locate the node after which new node is to be inserted.
while ( current->next!= *head_ref &&
current->next->data data)
{ current = current->next; }
(b) Make next of new_node as next of the located pointer
(c) Change the next of the located pointer

#include<stdio.h>
#include<stdlib.h>

struct node
{
int data;
struct node *next;
};
/* function to insert a new_node in a list in sorted way.

Note that this function expects a pointer to head node
as this can modify the head of the input linked list */
void sortedInsert(struct node** head_ref, struct node* new_node)
{
// Case 1 of the above algo

if (current == NULL)
{
new_node->next = new_node;
}

else if (current->data >= new_node->data)
{
/* If value is smaller than head's value then
we need to change next of last node */
while(current->next != *head_ref)
}

else
{
/* Locate the node before the point of insertion */
while (current->next!= *head_ref && current->next->data < new_node->data)
}
}

void printList(struct node *start)
{
struct node *temp;
if(start != NULL)
{
temp = start;
printf("\n");
do {
temp = temp->next;
} while(temp != start);
}
}

int main()
{
int arr[] = {12, 56, 2, 11, 1, 90};
int arr[] = {12, 56, 2, 11, 1, 90};
int list_size, i;
/* start with empty linked list */

struct node *temp;
/* Create linked list from the array arr[].

Created linked list will be 1->2->11->56->12 */
for(i = 0; i< 6; i++)
{
temp = (struct node *)malloc(sizeof(struct node));
temp->data = arr[i];
sortedInsert(&start, temp);
}
printList(start);
getchar();
return 0;
}

Output:
1 2 11 12 56 90
Time Complexity: O(n) where n is the number of nodes in the given linked list.
Case 2 of the above algorithm/code can be optimized. Please see this comment from Pavan. To implement
the suggested change we need to modify the case 2 to following.

else if (current->data >= new_node->data)
{
// swap the data part of head node and new node
swap(&(current->data), &(new_node->data)); // assuming that we have a function
swap(int *, int *)
new_node->next = (*head_ref)->next;
(*head_ref)->next = new_node;
}

problem.
Get Level of a node in a Binary Tree
Given a Binary Tree and a key, write a function that returns level of the key.
For example, consider the following tree. If the input key is 3, then your function should return 1. If the
input key is 4, then your function should return 3. And for key which is not present in key, then your
function should return 0.
Thanks to prandeey for suggesting the following solution.
The idea is to start from the root and level as 1. If the key matches with root’s data, return level. Else
recursively call for left and right subtrees with level as level + 1.

#include<stdio.h>
/* A tree node structure */

struct node
{
int data;
struct node *left;
struct node *right;
};
/* Helper function for getLevel(). It returns level of the data if data is

present in tree, otherwise returns 0.*/
int getLevelUtil(struct node *node, int data, int level)
{
if (node == NULL)
return 0;
if (node->data == data)
return level;
int downlevel = getLevelUtil(node->left, data, level+1);

if (downlevel != 0)
return downlevel;
downlevel = getLevelUtil(node->right, data, level+1);

return downlevel;
}
/* Returns level of given data value */

int getLevel(struct node *node, int data)
{
return getLevelUtil(node,data,1);
}
/* Utility function to create a new Binary Tree node */

{
struct node *temp = new struct node;
temp->data = data;
temp->data = data;
temp->left = NULL;
temp->right = NULL;
return temp;
}

int main()
{
struct node *root = new struct node;
int x;
/* Constructing tree given in the above figure */

root = newNode(3);
for (x = 1; x <=5; x++)

{
int level = getLevel(root, x);
if (level)
printf(" Level of %d is %d\n", x, getLevel(root, x));
else
printf(" %d is not present in tree \n", x);
getchar();
return 0;
}

Output:

Level of 1 is 3
Level of 2 is 2
Level of 3 is 1
Level of 4 is 3
Level of 5 is 2

Time Complexity: O(n) where n is the number of nodes in the given Binary Tree.
discussed above.
Applications of Queue Data Structure
Queue is used when things don’t have to be processed immediatly, but have to be processed in First In First
Out order like Breadth First Search. This property of Queue makes it also useful in following kind of
scenarios.
1) When a resource is shared among multiple consumers. Examples include CPU scheduling, Disk
Scheduling.
2) When data is transferred asynchronously (data not necessarily received at same rate as sent) between two
processes. Examples include IO Buffers, pipes, file IO, etc.
See this for more detailed applications of Queue and Stack.
References:
http://introcs.cs.princeton.edu/43stack/
Print Ancestors of a given node in Binary Tree
Given a Binary Tree and a key, write a function that prints all the ancestors of the key in the given binary
tree.
For example, if the given tree is following Binary Tree and key is 7, then your function should print 4, 2 and
1.
1
/ \
2 3
/ \
4 5
/
7

Thanks to Mike , Sambasiva and wgpshashank for their contribution.
#include<iostream>
#include<stdio.h>
#include<stdlib.h>

struct node
{
int data;
struct node* left;
struct node* right;
};
/* If target is present in tree, then prints the ancestors

and returns true, otherwise returns false. */
bool printAncestors(struct node *root, int target)
{
/* base cases */
if (root == NULL)
return false;
if (root->data == target)
return true;
/* If target is present in either left or right subtree of this node,

then print this node */
if ( printAncestors(root->left, target) ||
printAncestors(root->right, target) )
{
cout << root->data << " ";
return true;
}
/* Else return false */

return false;
}
}

{
node->data = data;
node->left = NULL;
node->right = NULL;
return(node);
}

int main()
{
/* Construct the following binary tree

1
/ \
2 3
/ \
4 5
/
7
*/
root->left->left->left = newnode(7);
printAncestors(root, 7);
getchar();
return 0;
}

Output:
4 2 1
discussed above.
Lower bound for comparison based sorting algorithms
The problem of sorting can be viewed as following.
Input: A sequence of n numbers <a1, a2, . . . , an>.

Output: A permutation (reordering) <a‘1, a‘2, . . . , a‘n> of the input sequence such that a‘1 a‘2 ….. ‘n.
A sorting algorithm is comparison based if it uses comparison operators to find the order between two
numbers. Comparison sorts can be viewed abstractly in terms of decision trees. A decision tree is a full
binary tree that represents the comparisons between elements that are performed by a particular sorting
algorithm operating on an input of a given size. The execution of the sorting algorithm corresponds to
tracing a path from the root of the decision tree to a leaf. At each internal node, a comparison ai
aj is made. The left subtree then dictates subsequent comparisons for ai
aj, and the right subtree dictates subsequent comparisons for ai > aj. When we come to a leaf, the sorting
algorithm has established the ordering. So we can say following about the decison tree.
1) Each of the n! permutations on n elements must appear as one of the leaves of the decision tree for the
sorting algorithm to sort properly.
2) Let x be the maximum number of comparisons in a sorting algorithm. The maximum height of the
decison tree would be x. A tree with maximum height x has at most 2^x leaves.
After combining the above two facts, we get following relation.

n! <= 2^x
Taking Log on both sides.

log 2(n!) <= x
Since log 2(n!) = Θ(nLogn), we can say

x = Ω(nLog 2n)

Therefore, any comparison based sorting algorithm must make at least nLog2n comparisons to sort the input
array, and Heapsort and merge sort are asymptotically optimal comparison sorts.
References:
Introduction to Algorithms, by Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest and Clifford Stein
Print BST keys in the given range
Given two values k1 and k2 (where k1
For example, if k1 = 10 and k2 = 22, then your function should print 12, 20 and 22.
Thanks to bhasker for suggesting the following solution.
Algorithm:
1) If value of root’s key is greater than k1, then recursively call in left subtree.
2) If value of root’s key is in range, then print the root’s key.
3) If value of root’s key is smaller than k2, then recursively call in right subtree.
Implementation:

#include<stdio.h>

struct node
{
int data;
struct node *left;
struct node *right;
};
/* The functions prints all the keys which in the given range [k1..k2].
The function assumes than k1 < k2 */
void Print(struct node *root, int k1, int k2)
{
/* base case */
if ( NULL == root )
return;
/* Since the desired o/p is sorted, recurse for left subtree first
If root->data is greater than k1, then only we can get o/p keys
in left subtree */
if ( k1 < root->data )
Print(root->left, k1, k2);
/* if root's data lies in range, then prints root's data */

if ( k1 <= root->data && k2 >= root->data )
printf("%d ", root->data );
/* If root->data is smaller than k2, then only we can get o/p keys
in right subtree */
if ( k2 > root->data )
Print(root->right, k1, k2);
}

{
temp->data = data;
temp->left = NULL;
temp->right = NULL;
return temp;
}

int main()
{
struct node *root = new struct node;
int k1 = 10, k2 = 25;

root = newNode(20);
Print(root, k1, k2);
getchar();
return 0;
}

Output:
12 20 22
Time Complexity: O(n) where n is the total number of keys in tree.
discussed above.
Applications of Minimum Spanning Tree Problem
Minimum Spanning Tree (MST) problem: Given connected graph G with positive edge weights, find a min
weight set of edges that connects all of the vertices.
MST is fundamental problem with diverse applications.
Network design.
– telephone, electrical, hydraulic, TV cable, computer, road
The standard application is to a problem like phone network design. You have a business with several
offices; you want to lease phone lines to connect them up with each other; and the phone company charges
different amounts of money to connect different pairs of cities. You want a set of lines that connects all your
offices with a minimum total cost. It should be a spanning tree, since if a network isn’t a tree you can always
remove some edges and save money.
Approximation algorithms for NP-hard problems.

– traveling salesperson problem, Steiner tree
A less obvious application is that the minimum spanning tree can be used to approximately solve the
traveling salesman problem. A convenient formal way of defining this problem is to find the shortest path
that visits each point at least once.
Note that if you have a path visiting all points exactly once, it’s a special kind of tree. For instance in the
example above, twelve of sixteen spanning trees are actually paths. If you have a path visiting some vertices
more than once, you can always drop some edges to get a tree. So in general the MST weight is less than the
TSP weight, because it’s a minimization over a strictly larger set.
On the other hand, if you draw a path tracing around the minimum spanning tree, you trace each edge twice
and visit all points, so the TSP weight is less than twice the MST weight. Therefore this tour is within a factor
of two of optimal.
Indirect applications.
– max bottleneck paths
– LDPC codes for error correction
– image registration with Renyi entropy
– learning salient features for real-time face verification
– reducing data storage in sequencing amino acids in a protein
– model locality of particle interactions in turbulent fluid flows
– autoconfig protocol for Ethernet bridging to avoid cycles in a network
Cluster analysis
k clustering problem can be viewed as finding an MST and deleting the k-1 most
expensive edges.
Sources:
http://www.cs.princeton.edu/courses/archive/spr07/cos226/lectures/mst.pdf
http://www.ics.uci.edu/~eppstein/161/960206.html
Program for Fibonacci numbers
The Fibonacci numbers are the numbers in the following integer sequence.
0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 141, ……..
In mathematical terms, the sequence Fn of Fibonacci numbers is defined by the recurrence relation
Fn = Fn-1 + Fn-2

with seed values
F0 = 0 and F1 = 1.

Write a function int fib(int n) that returns Fn. For example, if n = 0, then fib() should return 0. If n = 1, then
it should return 1. For n > 1, it should return Fn-1 + Fn-2
Following are different methods to get the nth Fibonacci number.
Method 1 ( Use recursion )

A simple method that is a direct recusrive implementation mathematical recurance relation given above.
#include<stdio.h>
int fib(int n)
{
if (n <= 1)
return n;
return fib(n-1) + fib(n-2);
}
int main ()
{
int n = 9;
printf("%d", fib(n));
getchar();
return 0;
}

Time Complexity: T(n) = T(n-1) + T(n-2) which is exponential.

We can observe that this implementation does a lot of repeated work (see the following recursion tree). So
this is a bad implementation for nth Fibonacci number.

fib(5)
/ \
fib(4) fib(3)
/ \ / \
fib(3) fib(2) fib(2) fib(1)
/ \ / \ / \
fib(2) fib(1) fib(1) fib(0) fib(1) fib(0)
/ \
fib(1) fib(0)

Extra Space: O(n) if we consider the function call stack size, otherwise O(1).
Method 2 ( Use Dynamic Programming )

We can avoid the repeated work done is the method 1 by storing the Fibonacci numbers calculated so far.
#include<stdio.h>
int fib(int n)
{
/* Declare an array to store Fibonacci numbers. */
int f[n+1];
int i;
/* 0th and 1st number of the series are 0 and 1*/

f[0] = 0;
f[1] = 1;
for (i = 2; i <= n; i++)

{
/* Add the previous 2 numbers in the series
and store it */
f[i] = f[i-1] + f[i-2];
}
return f[n];
}
int main ()
{
int n = 9;
getchar();
return 0;
}


Extra Space: O(n)
Method 3 ( Space Otimized Method 2 )

We can optimize the space used in method 2 by storing the previous two numbers only because that is all we
need to get the next Fibannaci number in series.

#include<stdio.h>
int fib(int n)
{
int a = 0, b = 1, c, i;
if( n == 0)
return a;
for (i = 2; i <= n; i++)
{
c = a + b;
a = b;
b = c;
}
return b;
}
int main ()
{
int n = 9;
getchar();
return 0;
}


Extra Space: O(1)
Method 4 ( Using power of the matrix {{1,1},{1,0}} )

This another O(n) which relies on the fact that if we n times multiply the matrix M = {{1,1},{1,0}} to itself (in
other words calculate power(M, n )), then we get the (n+1)th Fibonacci number as the element at row and
column (0, 0) in the resultant matrix.
The matrix representation gives the following closed expression for the Fibonacci numbers:

#include <stdio.h>
/* Helper function that multiplies 2 matricies F and M of size 2*2, and

puts the multiplication result back to F[][] */
void multiply(int F[2][2], int M[2][2]);
/* Helper function that calculates F[][] raise to the power n and puts the
result in F[][]
Note that this function is desinged only for fib() and won't work as general
power function */
void power(int F[2][2], int n);
int fib(int n)
{
int F[2][2] = {{1,1},{1,0}};
if (n == 0)
return 0;
power(F, n-1);
return F[0][0];
}
void multiply(int F[2][2], int M[2][2])

{
int x = F[0][0]*M[0][0] + F[0][1]*M[1][0];
int y = F[0][0]*M[0][1] + F[0][1]*M[1][1];
int z = F[1][0]*M[0][0] + F[1][1]*M[1][0];
int w = F[1][0]*M[0][1] + F[1][1]*M[1][1];
F[0][0] = x;
F[0][1] = y;
F[1][0] = z;
F[1][1] = w;
}
void power(int F[2][2], int n)

{
int i;
int M[2][2] = {{1,1},{1,0}};
// n - 1 times multiply the matrix to {{1,0},{0,1}}

for (i = 2; i <= n; i++)
multiply(F, M);
}

int main()
{
int n = 9;
getchar();
return 0;
}


Extra Space: O(1)
Method 5 ( Optimized Method 4 )
The method 4 can be optimized to work in O(Logn) time complexity. We can do recursive multiplication to
get power(M, n) in the prevous method (Similar to the optimization done in this post)
#include <stdio.h>
void multiply(int F[2][2], int M[2][2]);
void power(int F[2][2], int n);
/* function that returns nth Fibonacci number */

int fib(int n)
{
int F[2][2] = {{1,1},{1,0}};
if (n == 0)
return 0;
power(F, n-1);
return F[0][0];
}
/* Optimized version of power() in method 4 */

void power(int F[2][2], int n)
{
if( n == 0 || n == 1)
return;
int M[2][2] = {{1,1},{1,0}};
power(F, n/2);
multiply(F, F);
if (n%2 != 0)
multiply(F, M);
}
void multiply(int F[2][2], int M[2][2])

{
int x = F[0][0]*M[0][0] + F[0][1]*M[1][0];
int y = F[0][0]*M[0][1] + F[0][1]*M[1][1];
int z = F[1][0]*M[0][0] + F[1][1]*M[1][0];
int w = F[1][0]*M[0][1] + F[1][1]*M[1][1];
F[0][0] = x;
F[0][1] = y;
F[1][0] = z;
F[1][1] = w;
}

int main()
{
int n = 9;
printf("%d", fib(9));
getchar();
return 0;
}


Extra Space: O(Logn) if we consider the function call stack size, otherwise O(1).
same problem.
References:
http://en.wikipedia.org/wiki/Fibonacci_number
Find the smallest window in a string containing all characters of another
string
Given two strings string1 and string2, find the smallest substring in string1 containing all characters of
string2 efficiently.
For Example:
Input string1: “this is a test string”

Input string2: “tist”
Output string: “t stri”
Method 1 ( Brute force solution )

a) Generate all substrings of string1 (“this is a test string”)
b) For each substring, check whether the substring contains all characters of string2 (“tist”)
c) Finally print the smallest substring containing all characters of string2.
Method 2 ( Efficient Solution )

1) Build a count array count[] for string 2. The count array stores counts of characters.
count[‘i’] = 1
count[‘t’] = 2
count[‘s’] = 1
2) Scan the string1 from left to right until we find all the characters of string2. To check if all the characters
are there, use count[] built in step 1. So we have substring “this is a t” containing all characters of string2.
Note that the first and last characters of the substring must be present in string2. Store the length of this
substring as min_len.
3) Now move forward in string1 and keep adding characters to the substring “this is a t”. Whenever a
character is added, check if the added character matches the left most character of substring. If matches,
then add the new character to the right side of substring and remove the leftmost character and all other
extra characters after left most character. After removing the extra characters, get the length of this substring
and compare with min_len and update min_len accordingly.
Basically we add ‘e’ to the substring “this is a t”, then add ‘s’ and then’t’. ‘t’ matches the left most character, so
remove ‘t’ and ‘h’ from the left side of the substring. So our current substring becomes “is a test”. Compare
length of it with min_len and update min_len.
Again add characters to current substring “is a test”. So our string becomes “is a test str”. When we add ‘i’, we
remove leftmost extra characters, so current substring becomes “t stri”. Again, compare length of it with
min_len and update min_len. Finally add ‘n’ and ‘g’. Adding these characters doesn’t decrease min_len, so
the smallest window remains “t stri”.
4) Return min_len.
Please write comments if you find the above algorithms incorrect, or find other ways to solve the same
problem.
Source: http://geeksforgeeks.org/forum/topic/find-smallest-substring-containing-all-characters-of-a-given-
word
Search in a row wise and column wise sorted matrix
Given an n x n matrix, where every row and column is sorted in increasing order. Given a number x, how to
decide whether this x is in the matrix. The designed algorithm should have linear time complexity.
Thanks to devendraiiit for suggesting below approach.
1) Start with top right element

2) Loop: compare this element e with x
….i) if they are equal then return its position
…ii) e x then move it to left (if out of bound of matrix then break return false)
3) repeat the i), ii) and iii) till you find element or returned false
Implementation:

#include<stdio.h>
/* Searches the element x in mat[][]. If the element is found,

then prints its position and returns true, otherwise prints
"not found" and returns false */
int search(int mat[4][4], int n, int x)
{
int i = 0, j = n-1; //set indexes for top right element
while ( i < n && j >= 0 )
{
if ( mat[i][j] == x )
{
printf("\n Found at %d, %d", i, j);
return 1;
}
if ( mat[i][j] > x )
j--;
else // if mat[i][j] < x
i++;
}
printf("\n Element not found");

return 0; // if ( i==n || j== -1 )
}
// driver program to test above function

int main()
{
int mat[4][4] = { {10, 20, 30, 40},
{15, 25, 35, 45},
{27, 29, 37, 48},
{32, 33, 39, 50},
};
search(mat, 4, 29);
getchar();
return 0;
}
The above approach will also work for m x n matrix (not only for n x n). Complexity would be O(m + n).
same problem.
Program to count number of set bits in an (big) array
Given an integer array of length N (an arbitrarily large number). How to count number of set bits in the
array?
The simple approach would be, create an efficient method to count set bits in a word (most prominent size,
usually equal to bit length of processor), and add bits from individual elements of array.
Various methods of counting set bits of an integer exists, see this for example. These methods run at best
O(logN) where N is number of bits. Note that on a processor N is fixed, count can be done in O(1) time on 32
bit machine irrespective of total set bits. Overall, the bits in array can be computed in O(n) time, where ‘n’ is
array size.
However, a table look up will be more efficient method when array size is large. Storing table look up that
can handle 232 integers will be impractical.
The following code illustrates simple program to count set bits in a randomly generated 64 K integer array.
The idea is to generate a look up for first 256 numbers (one byte), and break every element of array at byte
boundary. A meta program using C/C++ preprocessor generates the look up table for counting set bits in a
byte.
The mathematical derivation behind meta program is evident from the following table (Add the column and
row indices to get the number, then look into the table to get set bits in that number. For example, to get set
bits in 10, it can be extracted from row named as 8 and column named as 2),

0, 1, 2, 3
0 - 0, 1, 1, 2 -------- GROUP_A(0)
4 - 1, 2, 2, 3 -------- GROUP_A(1)
8 - 1, 2, 2, 3 -------- GROUP_A(1)
12 - 2, 3, 3, 4 -------- GROUP_A(2)
16 - 1, 2, 2, 3 -------- GROUP_A(1)
20 - 2, 3, 3, 4 -------- GROUP_A(2)
24 - 2, 3, 3, 4 -------- GROUP_A(2)
28 - 3, 4, 4, 5 -------- GROUP_A(3) ... so on

From the table, there is a patten emerging in multiples of 4, both in the table as well as in the
group parameter. The sequence can be generalized as shown in the code.
Complexity:
All the operations takes O(1) except iterating over the array. The time complexity is O(n) where ‘n’ is size of
array. Space complexity depends on the meta program that generates look up.
Code:
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
/* Size of array 64 K */
#define SIZE (1 << 16)
/* Meta program that generates set bit count

array of first 256 integers */
/* GROUP_A - When combined with META_LOOK_UP

/* GROUP_A - When combined with META_LOOK_UP
generates count for 4x4 elements */
#define GROUP_A(x) x, x + 1, x + 1, x + 2
/* GROUP_B - When combined with META_LOOK_UP

generates count for 4x4x4 elements */
#define GROUP_B(x) GROUP_A(x), GROUP_A(x+1), GROUP_A(x+1), GROUP_A(x+2)
/* GROUP_C - When combined with META_LOOK_UP

generates count for 4x4x4x4 elements */
#define GROUP_C(x) GROUP_B(x), GROUP_B(x+1), GROUP_B(x+1), GROUP_B(x+2)
/* Provide appropriate letter to generate the table */
#define META_LOOK_UP(PARAMETER) \
GROUP_##PARAMETER(0), \
GROUP_##PARAMETER(2) \
int countSetBits(int array[], size_t array_size)

{
int count = 0;
/* META_LOOK_UP(C) - generates a table of 256 integers whose

sequence will be number of bits in i-th position
where 0 <= i < 256
*/
/* A static table will be much faster to access */

static unsigned char const look_up[] = { META_LOOK_UP(C) };
/* No shifting funda (for better readability) */

unsigned char *pData = NULL;
for(size_t index = 0; index < array_size; index++)

{
/* It is fine, bypass the type system */
pData = (unsigned char *)&array[index];
/* Count set bits in individual bytes */

count += look_up[pData[0]];
}
return count;
}
/* Driver program, generates table of random 64 K numbers */

int main()
{
int index;
int random[SIZE];
/* Seed to the random-number generator */

srand((unsigned)time(0));
/* Generate random numbers. */

for( index = 0; index < SIZE; index++ )
{
{
random[index] = rand();
}
printf("Total number of bits = %d\n", countSetBits(random, SIZE));

return 0;
}

Contributed by Venki. Please write comments if you find anything incorrect, or you want to share more
Reverse alternate K nodes in a Singly Linked List
Given a linked list, write a function to reverse every alternate k nodes (where k is an input to the function) in
an efficient way. Give the complexity of your algorithm.
Example:
Inputs: 1->2->3->4->5->6->7->8->9->NULL and k = 3
Output: 3->2->1->4->5->6->9->8->7->NULL.

Method 1 (Process 2k nodes and recursively call for rest of the list)
This method is basically an extension of the method discussed in this post.
kAltReverse(struct node *head, int k)

1) Reverse first k nodes.
2) In the modified list head points to the kth node. So change next
of head to (k+1)th node
3) Move the current pointer to skip next k nodes.
4) Call the kAltReverse() recursively for rest of the n - 2k nodes.
5) Return new head of the list.

#include<stdio.h>
#include<stdlib.h>

struct node
{
int data;
struct node* next;
};
/* Reverses alternate k nodes and

returns the pointer to the new head node */
struct node *kAltReverse(struct node *head, int k)
{
struct node* next;
int count = 0;
/*1) reverse first k nodes of the linked list */

while (current != NULL && count < k)
{
prev = current;
current = next;
count++;
}

/* 2) Now head points to the kth node. So change next
of head to (k+1)th node*/
if(head != NULL)
if(head != NULL)
head->next = current;
/* 3) We do not want to reverse next k nodes. So move the current

pointer to skip next k nodes */
count = 0;
while(count < k-1 && current != NULL )
{
count++;
}
/* 4) Recursively call for the list starting from current->next.

And make rest of the list as next of first node */
if(current != NULL)
current->next = kAltReverse(current->next, k);
/* 5) prev is new head of the input list */

return prev;
}
{
/* allocate node */



}

{
int count = 0;
while(node != NULL)
{
node = node->next;
count++;
}
}

int main(void)
{
// create a list 1->2->3->4->5...... ->20

for(int i = 20; i > 0; i--)
push(&head, i);

printList(head);
head = kAltReverse(head, 3);
printf("\n Modified Linked list \n");
printList(head);
getchar();
return(0);
}

Output:
Given linked list
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
Modified Linked list
3 2 1 4 5 6 9 8 7 10 11 12 15 14 13 16 17 18 20 19
Method 2 (Process k nodes and recursively call for rest of the list)
The method 1 reverses the first k node and then moves the pointer to k nodes ahead. So method 1 uses two
while loops and processes 2k nodes in one recursive call.
This method processes only k nodes in a recursive call. It uses a third bool parameter b which decides
whether to reverse the k elements or simply move the pointer.
_kAltReverse(struct node *head, int k, bool b)

1) If b is true, then reverse first k nodes.
2) If b is false, then move the pointer k nodes ahead.
3) Call the kAltReverse() recursively for rest of the n - k nodes and link
rest of the modified list with end of first k nodes.
4) Return new head of the list.

#include<stdio.h>
#include<stdlib.h>

struct node
{
int data;
struct node* next;
};
/* Helper function for kAltReverse() */

struct node * _kAltReverse(struct node *node, int k, bool b);
/* Alternatively reverses the given linked list in groups of

given size k. */
struct node *kAltReverse(struct node *head, int k)
{
return _kAltReverse(head, k, true);
}

/* Helper function for kAltReverse(). It reverses k nodes of the list only if
the third parameter b is passed as true, otherwise moves the pointer k
nodes ahead and recursively calls iteself */
struct node * _kAltReverse(struct node *node, int k, bool b)
{
{
if(node == NULL)
return NULL;
int count = 1;
struct node *prev = NULL;
struct node *current = node;
struct node *next;

/* The loop serves two purposes
1) If b is true, then it reverses the k nodes
2) If b is false, then it moves the current pointer */
while(current != NULL && count <= k)
{
/* Reverse the nodes only if b is true*/

if(b == true)

prev = current;
current = next;
count++;
}

/* 3) If b is true, then node is the kth node.
So attach rest of the list after node.
4) After attaching, return the new head */
if(b == true)
{
node->next = _kAltReverse(current,k,!b);
return prev;
}

/* If b is not true, then attach rest of the list after prev.
So attach rest of the list after prev */
else
{
prev->next = _kAltReverse(current, k, !b);
return node;
}
}

{
/* allocate node */



}

{
{
int count = 0;
while(node != NULL)
{
node = node->next;
count++;
}
}

int main(void)
{
int i;

// create a list 1->2->3->4->5...... ->20
for(i = 20; i > 0; i--)
push(&head, i);

printList(head);
head = kAltReverse(head, 3);

printf("\n Modified Linked list \n");
printList(head);

getchar();
return(0);
}

Output:
Given linked list
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
Modified Linked list
3 2 1 4 5 6 9 8 7 10 11 12 15 14 13 16 17 18 20 19
Source:
http://geeksforgeeks.org/forum/topic/amazon-interview-question-2
problem.
Next Greater Element
Given an array, print the Next Greater Element (NGE) for every element. The Next greater Element for an
element x is the first greater element on the right side of x in array. Elements for which no greater element
exist, consider next greater element as -1.
Examples:
a) For any array, rightmost element always has next greater element as -1.
b) For an array which is sorted in decreasing order, all elements have next greater element as -1.
c) For the input array [4, 5, 2, 25}, the next greater elements for each element are as follows.
Element NGE
4 --> 5
5 --> 25
2 --> 25
25 --> -1

d) For the input array [13, 7, 6, 12}, the next greater elements for each element are as follows.
Element NGE
13 --> -1
7 --> 12
6 --> 12
12 --> -1

Method 1 (Simple)
Use two loops: The outer loop picks all the elements one by one. The inner loop looks for the first greater
element for the element picked by outer loop. If a greater element is found then that element is printed as
next, otherwise -1 is printed.
Thanks to Sachin for providing following code.

#include<stdio.h>
/* prints element and NGE pair for all elements of
arr[] of size n */
void printNGE(int arr[], int n)
{
int next = -1;
int i = 0;
int j = 0;
for (i=0; i<n; i++)
{
next = -1;
for (j = i+1; j<n; j++)
{
if (arr[i] < arr[j])
{
next = arr[j];
break;
}
}
printf("%d -- %d\n", arr[i], next);
}
}
int main()
{
int arr[]= {11, 13, 21, 3};
printNGE(arr, n);
getchar();
return 0;
}

Output:
11 -- 13
13 -- 21
21 -- -1
3 -- -1

Time Complexity: O(n^2). The worst case occurs when all elements are sorted in decreasing order.
Method 2 (Using Stack)

Thanks to pchild for suggesting following approach.
1) Push the first element to stack.
2) Pick rest of the elements one by one and follow following steps in loop.
….a) Mark the current element as next.
….b) If stack is not empty, then pop an element from stack and compare it with next.
….c) If next is greater than the popped element, then next is the next greater element fot the popped element.
….d) Keep poppoing from the stack while the popped element is smaller than next. next becomes the next
greater element for all such popped elements
….g) If next is smaller than the popped element, then push the popped element back.
3) After the loop in step 2 is over, pop all the elements from stack and print -1 as next element for them.
#include<stdio.h>
#include<stdlib.h>
#define STACKSIZE 100
// stack structure
struct stack
{
int top;
int items[STACKSIZE];
};
// Stack Functions to be used by printNGE()

void push(struct stack *ps, int x)
{
if (ps->top == STACKSIZE-1)
{
printf("Error: stack overflow\n");
getchar();
exit(0);
}
else
{
ps->top += 1;
int top = ps->top;
ps->items [top] = x;
}
}
bool isEmpty(struct stack *ps)

{
return (ps->top == -1)? true : false;
}
int pop(struct stack *ps)

{
int temp;
if (ps->top == -1)
{
printf("Error: stack underflow \n");
getchar();
exit(0);
}
else
{
int top = ps->top;
temp = ps->items [top];
ps->top -= 1;
return temp;
}
}
/* prints element and NGE pair for all elements of

arr[] of size n */
void printNGE(int arr[], int n)
{
int i = 0;
struct stack s;
s.top = -1;
int element, next;
/* push the first element to stack */
push(&s, arr[0]);
// iterate for rest of the elements

for (i=1; i<n; i++)
{
next = arr[i];
if (isEmpty(&s) == false)
{
// if stack is not empty, then pop an element from stack
element = pop(&s);
/* If the popped element is smaller than next, then

a) print the pair
b) keep popping while elements are smaller and
stack is not empty */
while (element < next)
{
printf("\n %d --> %d", element, next);
if(isEmpty(&s) == true)
break;
element = pop(&s);
}
/* If element is greater than next, then push

the element back */
if (element > next)
push(&s, element);
}
/* push next to stack so that we can find

next greater for it */
push(&s, next);
}
/* After iterating over the loop, the remaining

elements in stack do not have the next greater
element, so print -1 for them */
while (isEmpty(&s) == false)
{
element = pop(&s);
next = -1;
printf("\n %d -- %d", element, next);
}
}

int main()
{
int arr[]= {11, 13, 21, 3};
printNGE(arr, n);
getchar();
return 0;
}

Output:

11 -- 13
13 -- 21
3 -- -1
21 -- -1

Time Complexity: O(n). The worst case occurs when all elements are sorted in decreasing order. If elements
are sorted in decreasing order, then every element is processed at most 4 times.
a) Initialy pushed to the stack.
b) Popped from the stack when next element is being processed.
c) Pushed back to the stack because next element is smaller.
d) Popped from the stack in step 3 of algo.
Source:
http://geeksforgeeks.org/forum/topic/next-greater-element#post-60
same problem.
Question 1
#include<stdio.h>
int fun(int a, int b)

{
if (b == 0)
return 0;
if (b % 2 == 0)
return fun(a+a, b/2);
return fun(a+a, b/2) + a;

}
int main()
{
printf("%d", fun(4, 3));
getchar();
return 0;
}

Output: 12
It calulates a*b (a multipied b).
Question 2
In question 1, if we replace + with * and replace return 0 with return 1, then what does the changed function
do? Following is the changed function.

#include<stdio.h>
int fun(int a, int b)

{
if (b == 0)
return 1;
if (b % 2 == 0)
return fun(a*a, b/2);
return fun(a*a, b/2)*a;

}
int main()
{
printf("%d", fun(4, 3));
getchar();
return 0;
}

Output: 64
It calulates a^b (a raised to power b).
Question 3

#include<stdio.h>
int fun(int n)
{
if (n > 100)
return n - 10;
return fun(fun(n+11));
}
int main()
{
printf(" %d ", fun(99));
getchar();
return 0;
}

Output: 91
fun(99) = fun(fun(110)) since 99 ? 100

= fun(100) since 110 > 100
= fun(fun(111)) since 100 ? 100
= fun(101) since 111 > 100
= 91 since 101 > 100

Returned value of fun() is 91 for all integer rguments n 101. This function is known as McCarthy 91 function.
Delete nodes which have a greater value on right side
Given a singly linked list, remove all the nodes which have a greater value on right side.
Examples:
a) The list 12->15->10->11->5->6->2->3->NULL should be changed to 15->11->6->3->NULL. Note that 12,
10, 5 and 2 have been deleted because there is a greater value on the right side.
When we examine 12, we see that after 12 there is one node with value greater than 12 (i.e. 15), so we delete
12.
When we examine 15, we find no node after 15 that has value greater than 15 so we keep this node.
When we go like this, we get 15->6->3
b) The list 10->20->30->40->50->60->NULL should be changed to 60->NULL. Note that 10, 20, 30, 40
and 50 have been deleted because they all have a greater value on the right side.
c) The list 60->50->40->30->20->10->NULL should not be changed.
Method 1 (Simple)
Use two loops. In the outer loop, pick nodes of the linked list one by one. In the inner loop, check if there
exist a node whose value is greater than the picked node. If there exists a node whose value is greater, then
delete the picked node.
Method 2 (Use Reverse)

Thanks to Paras for providing the below algorithm.
1. Reverse the list.
2. Traverse the reversed list. Keep max till now. If next node R.Srinivasan for providing below code.
#include <stdio.h>
#include <stdlib.h>
/* structure of a linked list node */

struct node
{
int data;
struct node *next;
};
/* prototype for utility functions */

void reverseList(struct node **headref);
void _delLesserNodes(struct node *head);
/* Deletes nodes which have a node with greater value node

on left side */
void delLesserNodes(struct node **head_ref)
{
/* 1) Reverse the linked list */
reverseList(head_ref);
/* 2) In the reversed list, delete nodes which have a node

with greater value node on left side. Note that head
node is never deleted because it is the leftmost node.*/
_delLesserNodes(*head_ref);
/* 3) Reverse the linked list again to retain the

original order */
reverseList(head_ref);
}
}
/* Deletes nodes which have greater value node(s) on left side */

void _delLesserNodes(struct node *head)
{
struct node *current = head;
/* Initialize max */
struct node *maxnode = head;
struct node *temp;
while (current != NULL && current->next != NULL)

{
/* If current is smaller than max, then delete current */
if(current->next->data < maxnode->data)
{
temp = current->next;
current->next = temp->next;
free(temp);
}
/* If current is greater than max, then update max and

move current */
else
{
maxnode = current;
}
}
}
/* Utility function to insert a node at the begining */

void push(struct node **head_ref, int new_data)
{
struct node *new_node =
(struct node *)malloc(sizeof(struct node));
}
/* Utility function to reverse a linked list */

void reverseList(struct node **headref)
{
struct node *current = *headref;
struct node *next;
while(current != NULL)
{
prev = current;
current = next;
}
*headref = prev;
}
/* Utility function to print a linked list */

{
while(head!=NULL)
{
printf("%d ",head->data);
head=head->next;
head=head->next;
}
printf("\n");
}

int main()
{
/* Create following linked list

12->15->10->11->5->6->2->3 */
push(&head,3);
push(&head,2);
push(&head,6);
push(&head,5);
push(&head,11);
push(&head,10);
push(&head,15);
push(&head,12);
printf("Given Linked List: ");

printList(head);
delLesserNodes(&head);
printf("\nModified Linked List: ");

printList(head);
getchar();
return 0;
}

Output:
Given Linked List: 12 15 10 11 5 6 2 3

Modified Linked List: 15 11 6 3

Source:
http://geeksforgeeks.org/forum/topic/amazon-interview-question-for-software-engineerdeveloper-about-
linked-lists-6
problem.
Tournament Tree (Winner Tree) and Binary Heap
Given a team of N players. How many minimum games are required to find second best player?
We can use adversary arguments based on tournament tree (Binary Heap).
Tournament tree is a form of min (max) heap which is a complete binary tree. Every external node
represents a player and internal node represents winner. In a tournament tree every internal node contains
winner and every leaf node contains one player.
There will be N – 1 internal nodes in a binary tree with N leaf (external) nodes. For details see
this post (put
n = 2 in equation given in the post).
It is obvious that to select the best player among N players, (N – 1) players to be eliminated, i.e. we need
minimum of (N – 1) games (comparisons). Mathematically we can prove it. In a binary tree I = E – 1, where I
is number of internal nodes and E is number of external nodes. It means to find maximum or minimum
element of an array, we need N – 1 (internal nodes) comparisons.
Second Best Player
The information explored during best player selection can be used to minimize the number of comparisons
in tracing the next best players. For example, we can pick second best player in (N + log 2N – 2)
comparisons. For details read this comment.
The following diagram displays a tournament tree (winner tree) as a max heap. Note that the concept of
loser tree is different.
The above tree contains 4 leaf nodes that represent players and have 3 levels 0, 1 and 2. Initially 2 games are
conducted at level 2, one between 5 and 3 and another one between 7 and 8. In the next move, one more
game is conducted between 5 and 8 to conclude the final winner. Overall we need 3 comparisons. For second
best player we need to trace the candidates participated with final winner, that leads to 7 as second best.
Median of Sorted Arrays
Tournament tree can effectively be used to find median of sorted arrays. Assume, given M sorted arrays of
equal size L (for simplicity). We can attach all these sorted arrays to the tournament tree, one array per leaf.
We need a tree of height CEIL (log 2M) to have atleast M external nodes.
Consider an example. Given 3 (M = 3) sorted integer arrays of maximum size 5 elements.

{ 2, 5, 7, 11, 15 } ---- Array1
{1, 3, 4} ---- Array2
{6, 8, 12, 13, 14} ---- Array3

What should be the height of tournament tree? We need to construct a tournament tree of height log3 .=2
1.585 = 2 rounded to next integer. A binary tree of height 2 will have 4 leaves to which we can attach the
arrays as shown in the below figure.
After the first tournament, the tree appears as below,
We can observe that the winner is from Array2. Hence the next element from Array2 will dive-in and games
will be played along the winner path of previous tournament.
Note that infinity is used as sentinel element. Based on data being hold in nodes we can select the sentinel
character. For example we usually store the pointers in nodes rather than keys, so NULL can serve as
sentinel. If any of the array exhausts we will fill the corresponding leaf and upcoming internal nodes
with sentinel.
After the second tournament, the tree appears as below,
The next winner is from Array1, so next element of Array1 array which is 5 will dive-in to the next round, and
next tournament played along the path of 2.
The tournaments can be continued till we get median element which is (5+3+5)/2 = 7th element. Note that
there are even better algorithms for finding median of union of sorted arrays, for details see the related links
given below.
In general with M sorted lists of size L1, L2 … Lm requires time complexity of O((L 1 + L 2 + … + L m) *
logM) to merge all the arrays, and O(m*logM) time to find median, where m is median position.
Select smallest one million elements from one billion unsorted elements:
As a simple solution, we can sort the billion numbers and select first one million.
On a limited memory system sorting billion elements and picking the first one million seems to be
impractical. We can use tournament tree approach. At any time only elements of tree to be in memory.
Split the large array (perhaps stored on disk) into smaller size arrays of size one million each (or even smaller
that can be sorted by the machine). Sort these 1000 small size arrays and store them on disk as individual
files. Construct a tournament tree which can have atleast 1000 leaf nodes (tree to be of height 10 since 29
< 1000 < 210, if the individual file size is even smaller we will need more leaf nodes). Every leaf node will
have an engine that picks next element from the sorted file stored on disk. We can play the tournament tree
game to extract first one million elements.
Total cost = sorting 1000 lists of one million each + tree construction + tournaments
Implementation
We need to build the tree (heap) in bottom-up manner. All the leaf nodes filled first. Start at the left extreme
of tree and fill along the breadth (i.e. from 2k-1 to 2k – 1 where k is depth of tree) and play the game. After
practicing with few examples it will be easy to write code. We will have code in an upcoming article.
Related Posts
Link 1, Link 2, Link 3, Link 4, Link 5, Link 6, Link 7.
— by Venki. Please write comments if you find anything incorrect, or you want to share more information
Applications of Depth First Search
Depth-first search (DFS) is an algorithm (or technique) for traversing a graph.
Following are the problems that use DFS as a bulding block.
1) For an unweighted graph, DFS traversal of the graph produces the minimum spanning tree and all pair
shortest path tree.
2) Detecting cycle in a graph

A graph has cycle if and only if we see a back edge during DFS. So we can run DFS for the graph and check
for back edges. (See this for details)
3) Path Finding
We can specialize the DFS algorithm to find a path between two given vertices u and z.
i) Call DFS(G, u) with u as the start vertex.
ii) Use a stack S to keep track of the path between the start vertex and the current vertex.
iii) As soon as destination vertex z is encountered, return the path as the
contents of the stack
See this for details.
4) Topological Sorting
See this for details.
5) To test if a graph is bipartite

We can augment either BFS or DFS when we first discover a new vertex, color it opposited its parents, and
for each other edge, check it doesn’t link two vertices of the same color. The first vertex in any connected
component can be red or black! See this for details.
6) Finding Strongly Connected Components of a graph A directed graph is called strongly

connected if there is a path from each vertex in the graph to every other vertex. (See this for DFS based algo
for finding Strongly Connected Components)
7) Solving puzzles with only one solution, such as mazes. (DFS can be adapted to find all solutions to a
maze by only including nodes on the current path in the visited set.)
Sources:
http://www8.cs.umu.se/kurser/TDBAfl/VT06/algorithms/LEC/LECTUR16/NODE16.HTM
http://en.wikipedia.org/wiki/Depth-first_search
http://www.personal.kent.edu/~rmuhamma/Algorithms/MyAlgorithms/GraphAlgor/depthSearch.htm
http://ww3.algorithmdesign.net/handouts/DFS.pdf
Boruvka’s algorithm for Minimum Spanning Tree
Following two algorithms are generally taught for Minimum Spanning Tree (MST) problem.
Prim’s algorithm
Kruskal’s algorithm
There is a third algorithm called Boruvka’s algorithm for MST which (like the above two) is also Greedy
algorithm. The Boruvka’s algorithm is the oldest minimum spanning tree algorithm was discovered by
Boruuvka in 1926, long before computers even existed. The algorithm was published as a method of
constructing an efficient electricity network. See following links for the working and applications of the
algorithm.
Sources:
http://en.wikipedia.org/wiki/Bor%C5%AFvka%27s_algorithm
Searching for Patterns | Set 1 (Naive Pattern Searching)
Given a text txt[0..n-1] and a pattern pat[0..m-1], write a function search(char pat[], char txt[]) that prints
all occurrences of pat[] in txt[]. You may assume that n > m.
Examples:
1) Input:
txt[] = "THIS IS A TEST TEXT"

pat[] = "TEST"

Output:

Pattern found at index 10

2) Input:
txt[] = "AABAACAADAABAAABAA"
pat[] = "AABA"

Output:


Pattern searching is an important problem in computer science. When we do search for a string in
notepad/word file or browser or database, pattern searching algorithms are used to show the search results.
Naive Pattern Searching:

Slide the pattern over text one by one and check for a match. If a match is found, then slides by 1 again to
check for subsequent matches.

#include<stdio.h>
#include<string.h>
void search(char *pat, char *txt)
{
int M = strlen(pat);
int N = strlen(txt);

/* A loop to slide pat[] one by one */
for (int i = 0; i <= N - M; i++)
{
int j;

/* For current index i, check for pattern match */
for (j = 0; j < M; j++)
{
if (txt[i+j] != pat[j])
break;
}
if (j == M) // if pat[0...M-1] = txt[i, i+1, ...i+M-1]
{
printf("Pattern found at index %d \n", i);
}
}
}

int main()
{
char *txt = "AABAACAADAABAAABAA";
char *pat = "AABA";
search(pat, txt);
getchar();
return 0;
}

What is the best case?

The best case occurs when the first character of the pattern is not present in text at all.

txt[] = "AABCCAADDEE"
pat[] = "FAA"

The number of comparisons in best case is O(n).
What is the worst case ?

The worst case of Naive Pattern Searching occurs in following scenarios.
1) When all characters of the text and pattern are same.

txt[] = "AAAAAAAAAAAAAAAAAA"
pat[] = "AAAAA".

2) Worst case also occurs when only the last character is different.

txt[] = "AAAAAAAAAAAAAAAAAB"
pat[] = "AAAAB"

Number of comparisons in worst case is O(m*(n-m+1)). Although strings which have repeated characters
are not likely to appear in English text, they may well occur in other applications (for example, in binary
texts). The KMP matching algorithm improves the worst case to O(n). We will be covering KMP in the next
post. Also, we will be writing more posts to cover all pattern searching algorithms and data structures.
discussed above.
Searching for Patterns | Set 2 (KMP Algorithm)
Examples:
1) Input:

pat[] = "TEST"

Output:


2) Input:
pat[] = "AABA"

Output:


We have discussed Naive pattern searching algorithm in the previous post. The worst case complexity of
Naive algorithm is O(m(n-m+1)). Time complexity of KMP algorithm is O(n) in worst case.
KMP (Knuth Morris Pratt) Pattern Searching

The Naive pattern searching algorithm doesn’t work well in cases where we see many matching characters
followed by a mismatching character. Following are some examples.
txt[] = "AAAAAAAAAAAAAAAAAB"
pat[] = "AAAAB"
txt[] = "ABABABCABABABCABABABC"
pat[] = "ABABAC" (not a worst case, but a bad case for Naive)

The KMP matching algorithm uses degenerating property (pattern having same sub-patterns appearing
more than once in the pattern) of the pattern and improves the worst case complexity to O(n). The basic idea
behind KMP’s algorithm is: whenever we detect a mismatch (after some matches), we already know some of
the characters in the text (since they matched the pattern characters prior to the mismatch). We take
advantage of this information to avoid matching the characters that we know will anyway match.
KMP algorithm does some preprocessing over the pattern pat[] and constructs an auxiliary array lps[] of size
m (same as size of pattern). Here name lps indicates longest proper prefix which is also suffix. . For
each sub-pattern pat[0…i] where i = 0 to m-1, lps[i] stores length of the maximum matching proper prefix
which is also a suffix of the sub-pattern pat[0..i].

lps[i] = the longest proper prefix of pat[0..i]
which is also a suffix of pat[0..i].

Examples:
For the pattern “AABAACAABAA”, lps[] is [0, 1, 0, 1, 2, 0, 1, 2, 3, 4, 5]
For the pattern “ABCDE”, lps[] is [0, 0, 0, 0, 0]
For the pattern “AAAAA”, lps[] is [0, 1, 2, 3, 4]
For the pattern “AAABAAA”, lps[] is [0, 1, 2, 0, 1, 2, 3]
For the pattern “AAACAAAAAC”, lps[] is [0, 1, 2, 0, 1, 2, 3, 3, 3, 4]
Searching Algorithm:
Unlike the Naive algo where we slide the pattern by one, we use a value from lps[] to decide the next sliding
position. Let us see how we do that. When we compare pat[j] with txt[i] and see a mismatch, we know that
characters pat[0..j-1] match with txt[i-j+1…i-1], and we also know that lps[j-1] characters of pat[0…j-1] are
both proper prefix and suffix which means we do not need to match these lps[j-1] characters with txt[i-j…i-1]
because we know that these characters will anyway match. See KMPSearch() in the below code for details.
Preprocessing Algorithm:
In the preprocessing part, we calculate values in lps[]. To do that, we keep track of the length of the longest
prefix suffix value (we use len variable for this purpose) for the previous index. We initialize lps[0] and len as
0. If pat[len] and pat[i] match, we increment len by 1 and assign the incremented value to lps[i]. If pat[i] and
pat[len] do not match and len is not 0, we update len to lps[len-1]. See computeLPSArray () in the below
code for details.
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
void computeLPSArray(char *pat, int M, int *lps);
void KMPSearch(char *pat, char *txt)

{
// create lps[] that will hold the longest prefix suffix values for pattern
int *lps = (int *)malloc(sizeof(int)*M);
int j = 0; // index for pat[]
// Preprocess the pattern (calculate lps[] array)

computeLPSArray(pat, M, lps);
int i = 0; // index for txt[]

int i = 0; // index for txt[]
while (i < N)
{
if (pat[j] == txt[i])
{
j++;
i++;
}
if (j == M)
{
printf("Found pattern at index %d \n", i-j);
j = lps[j-1];
}
// mismatch after j matches

else if (i < N && pat[j] != txt[i])
{
// Do not match lps[0..lps[j-1]] characters,
// they will match anyway
if (j != 0)
j = lps[j-1];
else
i = i+1;
}
}
free(lps); // to avoid memory leak
}
void computeLPSArray(char *pat, int M, int *lps)

{
int len = 0; // lenght of the previous longest prefix suffix
int i;
lps[0] = 0; // lps[0] is always 0

i = 1;
// the loop calculates lps[i] for i = 1 to M-1

while (i < M)
{
if (pat[i] == pat[len])
{
len++;
lps[i] = len;
i++;
}
else // (pat[i] != pat[len])
{
if (len != 0)
{
// This is tricky. Consider the example AAACAAAA and i = 7.
len = lps[len-1];
// Also, note that we do not increment i here

}
else // if (len == 0)
{
lps[i] = 0;
i++;
}
}
}
}
// Driver program to test above function
int main()
{
char *txt = "ABABDABACDABABCABAB";
char *pat = "ABABCABAB";
KMPSearch(pat, txt);
return 0;
}

discussed above.
Check if array elements are consecutive | Added Method 3
Given an unsorted array of numbers, write a function that returns true if array consists of consecutive
numbers.
Examples:
a) If array is {5, 2, 3, 1, 4}, then the function should return true because the array has consecutive numbers
from 1 to 5.
b) If array is {83, 78, 80, 81, 79, 82}, then the function should return true because the array has consecutive
numbers from 78 to 83.
c) If the array is {34, 23, 52, 12, 3 }, then the function should return false because the elements are not
consecutive.
d) If the array is {7, 6, 5, 5, 3, 4}, then the function should return false because 5 and 5 are not consecutive.
Method 1 (Use Sorting)

1) Sort all the elements.
2) Do a linear scan of the sorted array. If the difference between current element and next element is
anything other than 1, then return false. If all differences are 1, then return true.
Method 2 (Use visited array)

The idea is to check for following two conditions. If following two conditions are true, then return true.
1) max – min + 1 = n where max is the maximum element in array, min is minimum element in array and n
is the number of elements in array.
2) All elements are distinct.
To check if all elements are distinct, we can create a visited[] array of size n. We can map the ith element of
input array arr[] to visited array by using arr[i] – min as index in visited[].

#include<stdio.h>
#include<stdlib.h>
/* Helper functions to get minimum and maximum in an array */

int getMin(int arr[], int n);
int getMax(int arr[], int n);
/* The function checks if the array elements are consecutive

If elements are consecutive, then returns true, else returns
false */
bool areConsecutive(int arr[], int n)
{
if ( n < 1 )
return false;
/* 1) Get the minimum element in array */

int min = getMin(arr, n);
/* 2) Get the maximum element in array */

int max = getMax(arr, n);
/* 3) max - min + 1 is equal to n, then only check all elements */

if (max - min + 1 == n)
{
/* Create a temp array to hold visited flag of all elements.
Note that, calloc is used here so that all values are initialized
as false */
as false */
bool *visited = (bool *) calloc (n, sizeof(bool));
int i;
for (i = 0; i < n; i++)
{
/* If we see an element again, then return false */
if ( visited[arr[i] - min] != false )
return false;
/* If visited first time, then mark the element as visited */

visited[arr[i] - min] = true;
}
/* If all elements occur once, then return true */

return true;
}
return false; // if (max - min + 1 != n)

}
int getMin(int arr[], int n)
{
int min = arr[0];
for (int i = 1; i < n; i++)
if (arr[i] < min)
min = arr[i];
return min;
}

{
int max = arr[0];
for (int i = 1; i < n; i++)
if (arr[i] > max)
max = arr[i];
return max;
}

int main()
{
int arr[]= {5, 4, 2, 3, 1, 6};
if(areConsecutive(arr, n) == true)
printf(" Array elements are consecutive ");
else
printf(" Array elements are not consecutive ");
getchar();
return 0;
}


Extra Space: O(n)
Method 3 (Mark visited array elements as negative)

This method is O(n) time complexity and O(1) extra space, but it changes the original array and it works only
if all numbers are positive. We can get the original array by adding an extra step though. It is an extension of
method 2 and it has the same two steps.
1) max – min + 1 = n where max is the maximum element in array, min is minimum element in array and n
is the number of elements in array.
2) All elements are distinct.
In this method, the implementation of step 2 differs from method 2. Instead of creating a new array, we
modify the input array arr[] to keep track of visited elements. The idea is to traverse the array and for each
index i (where 0 #include<stdio.h> #include<stdlib.h> /* Helper functions to get minimum and maximum
in an array */ int getMin(int arr[], int n); int getMax(int arr[], int n); /* The function checks if the array
elements are consecutive If elements are consecutive, then returns true, else returns false */ bool
areConsecutive(int arr[], int n) { if ( n < 1 ) return false; /* 1) Get the minimum element in array */ int min =
getMin(arr, n); /* 2) Get the maximum element in array */ int max = getMax(arr, n); /* 3) max – min + 1 is
equal to n then only check all elements */ if (max – min + 1 == n) { int i; for(i = 0; i < n; i++) { int j; if (arr[i]
< 0) j = -arr[i] – min; else j = arr[i] – min; // if the value at index j is negative then // there is repitition if
(arr[j] > 0) arr[j] = -arr[j]; else return false; } /* If we do not see a negative value then all elements are
distinct */ return true; } return false; // if (max – min + 1 != n) } /* UTILITY FUNCTIONS */ int getMin(int
arr[], int n) { int min = arr[0]; for (int i = 1; i < n; i++) if (arr[i] < min) min = arr[i]; return min; } int
getMax(int arr[], int n) { int max = arr[0]; for (int i = 1; i < n; i++) if (arr[i] > max) max = arr[i]; return max;
} /* Driver program to test above functions */ int main() { int arr[]= {1, 4, 5, 3, 2, 6}; int n =
sizeof(arr)/sizeof(arr[0]); if(areConsecutive(arr, n) == true) printf(" Array elements are consecutive "); else
printf(" Array elements are not consecutive "); getchar(); return 0; }
Note that this method might not work for negative numbers. For example, it returns false for {2, 1, 0, -3, -1, -
2}.

Extra Space: O(1)
Source: http://geeksforgeeks.org/forum/topic/amazon-interview-question-for-software-engineerdeveloper-
fresher-9
same problem.
Mutex vs Semaphore
What are the differences between Mutex vs Semaphore? When to use mutex and when to use semaphore?
Concrete understanding of Operating System concepts is required to design/develop smart applications. Our
objective is to educate the reader on these concepts and learn from other expert geeks.
As per operating system terminology, mutex and semaphore are kernel resources that provide
synchronization services (also called as synchronization primitives). Why do we need such synchronization
primitives? Won’t be only one sufficient? To answer these questions, we need to understand few keywords.
Please read the posts on atomicity and critical section. We will illustrate with examples to understand these
concepts well, rather than following usual OS textual description.
The producer-consumer problem:
Note that the content is generalized explanation. Practical details vary with implementation.
Consider the standard producer-consumer problem. Assume, we have a buffer of 4096 byte length. A
producer thread collects the data and writes it to the buffer. A consumer thread processes the collected data
from the buffer. Objective is, both the threads should not run at the same time.
Using Mutex:
A mutex provides mutual exclusion, either producer or consumer can have the key (mutex) and proceed
with their work. As long as the buffer is filled by producer, the consumer needs to wait, and vice versa.
At any point of time, only one thread can work with the entire buffer. The concept can be generalized using
semaphore.
Using Semaphore:
A semaphore is a generalized mutex. In lieu of single buffer, we can split the 4 KB buffer into four 1 KB
buffers (identical resources). A semaphore can be associated with these four buffers. The consumer and
producer can work on different buffers at the same time.
Misconception:
There is an ambiguity between binary semaphore and mutex. We might have come across that a mutex is
binary semaphore. But they are not! The purpose of mutex and semaphore are different. May be, due to
similarity in their implementation a mutex would be referred as binary semaphore.
Strictly speaking, a mutex is locking mechanism used to synchronize access to a resource. Only one task
(can be a thread or process based on OS abstraction) can acquire the mutex. It means there is ownership
associated with mutex, and only the owner can release the lock (mutex).
Semaphore is signaling mechanism (“I am done, you can carry on” kind of signal). For example, if you
are listening songs (assume it as one task) on your mobile and at the same time your friend calls you,
an interrupt is triggered upon which an interrupt service routine (ISR) signals the call processing task to
wakeup.
General Questions:
1. Can a thread acquire more than one lock (Mutex)?
Yes, it is possible that a thread is in need of more than one resource, hence the locks. If any lock is not
available the thread will wait (block) on the lock.
2. Can a mutex be locked more than once?
A mutex is a lock. Only one state (locked/unlocked) is associated with it. However, a recursive mutex can be
locked more than once (POSIX complaint systems), in which a count is associated with it, yet retains only
one state (locked/unlocked). The programmer must unlock the mutex as many number times as it was
locked.
3. What happens if a non-recursive mutex is locked more than once.
Deadlock. If a thread which had already locked a mutex, tries to lock the mutex again, it will enter into
the waiting list of that mutex, which results in deadlock. It is because no other thread can unlock the mutex.
An operating system implementer can exercise care in identifying the owner of mutex and return if it is
already locked by same thread to prevent deadlocks.
4. Are binary semaphore and mutex same?
No. We suggest to treat them separately, as it is explained signalling vs locking mechanisms. But a binary
semaphore may experience the same critical issues (e.g. priority inversion) associated with mutex. We will
cover these in later article.
A programmer can prefer mutex rather than creating a semaphore with count 1.
5. What is a mutex and critical section?
Some operating systems use the same word critical section in the API. Usually a mutex is
costly operation due to protection protocols associated with it. At last, the objective of mutex is atomic
access. There are other ways to achieve atomic access like disabling interrupts which can be much faster but
ruins responsiveness. The alternate API makes use of disabling interrupts.
6. What are events?
The semantics of mutex, semaphore, event, critical section, etc… are same. All are synchronization
primitives. Based on their cost in using them they are different. We should consult the OS documentation for
exact details.
7. Can we acquire mutex/semaphore in an Interrupt Service Routine?
An ISR will run asynchronously in the context of current running thread. It is not recommended to query
(blocking call) the availability of synchronization primitives in an ISR. The ISR are meant be short, the call
to mutex/semaphore may block the current running thread. However, an ISR can signal a semaphore or
unlock a mutex.
8. What we mean by “thread blocking on mutex/semaphore” when they are not available?
Every synchronization primitive has a waiting list associated with it. When the resource is not available, the
requesting thread will be moved from the running list of processor to the waiting list of the synchronization
primitive. When the resource is available, the higher priority thread on the waiting list gets the resource
(more precisely, it depends on the scheduling policies).
9. Is it necessary that a thread must block always when resource is not available?
Not necessary. If the design is sure ‘what has to be done when resource is not available‘, the thread can take
up that work (a different code branch). To support application requirements the OS provides non-blocking
API.
For example POSIX pthread_mutex_trylock() API. When mutex is not available the function returns
immediately whereas the API pthread_mutex_lock() blocks the thread till resource is available.
References:
http://www.netrino.com/node/202
http://doc.trolltech.com/4.7/qsemaphore.html
Also compare mutex/semaphores with Peterson’s algorithm and Dekker’s algorithm. A good reference is
the Art of Concurrency book. Also explore reader locks and writer locks in Qt documentation.
Exercise:
Implement a program that prints a message “An instance is running” when executed more than once in the
same session. For example, if we observe word application or Adobe reader in Windows, we can see only one
instance in the task manager. How to implement it?
Find the smallest missing number
Given a sorted array of n integers where each integer is in the range from 0 to m-1 and m > n.
Find the
smallest number that is missing from the array.
Examples
Input: {0, 1, 2, 6, 9}, n = 5, m = 10
Output: 3
Input: {4, 5, 10, 11}, n = 4, m = 12

Output: 0
Input: {0, 1, 2, 3}, n = 4, m = 5

Output: 4
Input: {0, 1, 2, 3, 4, 5, 6, 7, 10}, n = 9, m = 11

Output: 8
Thanks to Ravichandra for suggesting following two methods.
Method 1 (Use Binary Search)

For i = 0 to m-1, do binary search for i in the array. If i is not present in the array then return i.
Time Complexity: O(m log n)

If arr[0] is not 0, return 0. Otherwise traverse the input array starting from index 1, and for each pair of
elements a[i] and a[i+1], find the difference between them. if the difference is greater than 1 then a[i]+1 is
the missing number.
Method 3 (Use Modified Binary Search)

Thanks to yasein and Jams for suggesting this method.
In the standard Binary Search process, the element to be searched is compared with the middle element and
on the basis of comparison result, we decide whether to search is over or to go to left half or right half.
In this method, we modify the standard Binary Search algorithm to compare the middle element with its
index and make decision on the basis of this comparison.
…1) If the first element is not same as its index then return first index
…2) Else get the middle index say mid
…………a) If arr[mid] greater than mid then the required element lies in left half.
…………b) Else the required element lies in right half.

#include<stdio.h>
int findFirstMissing(int array[], int start, int end) {
if(start > end)

return end + 1;
if (start != array[start])
return start;
int mid = (start + end) / 2;
if (array[mid] > mid)

return findFirstMissing(array, start, mid);
else
return findFirstMissing(array, mid + 1, end);
}

int main()
{
int arr[] = {0, 1, 2, 3, 4, 5, 6, 7, 10};
printf(" First missing element is %d",
findFirstMissing(arr, 0, n-1));
getchar();
return 0;
}

Note: This method doesn’t work if there are duplicate elements in the array.
Source: http://geeksforgeeks.org/forum/topic/commvault-interview-question-for-software-
engineerdeveloper-2-5-years-about-algorithms
same problem.
Segregate even and odd nodes in a Linked List
Given a Linked List of integers, write a function to modify the linked list such that all even numbers appear
before all the odd numbers in the modified linked list. Also, keep the order of even and odd numbers same.
Examples:
Input: 17->15->8->12->10->5->4->1->7->6->NULL
Output: 8->12->10->4->6->17->15->5->1->7->NULL
Input: 8->12->10->5->4->1->6->NULL
Output: 8->12->10->4->6->5->1->NULL
// If all numbers are even then do not change the list

Input: 8->12->10->NULL
Output: 8->12->10->NULL
// If all numbers are odd then do not change the list

Input: 1->3->5->7->NULL
Output: 1->3->5->7->NULL
Method 1
The idea is to get pointer to the last node of list. And then traverse the list starting from the head node and
move the odd valued nodes from their current position to end of the list.
Thanks to blunderboy for suggesting this method.
Algorithm:
…1) Get pointer to the last node.
…2) Move all the odd nodes to the end.
……..a) Consider all odd nodes before the first even node and move them to end.
……..b) Change the head pointer to point to the first even node.
……..b) Consider all odd nodes after the first even node and move them to the end.
#include <stdio.h>
#include <stdlib.h>
/* a node of the singly linked list */

struct node
{
int data;
struct node *next;
};
void segregateEvenOdd(struct node **head_ref)

{
struct node *end = *head_ref;

struct node *curr = *head_ref;
/* Get pointer to the last node */

while (end->next != NULL)
end = end->next;
struct node *new_end = end;
/* Consider all odd nodes before the first even node

and move then after end */
while (curr->data %2 != 0 && curr != end)
while (curr->data %2 != 0 && curr != end)
{
new_end->next = curr;
curr = curr->next;
new_end->next->next = NULL;
new_end = new_end->next;
}
// 10->8->17->17->15
/* Do following steps only if there is any even node */
if (curr->data%2 == 0)
{
/* Change the head pointer to point to first even node */
*head_ref = curr;
/* now current points to the first even node */

while (curr != end)
{
if ( (curr->data)%2 == 0 )
{
prev = curr;
curr = curr->next;
}
else
{
/* break the link between prev and current */
prev->next = curr->next;
/* Make next of curr as NULL */

curr->next = NULL;
/* Move curr to end */

new_end->next = curr;
/* make curr as new end of list */

new_end = curr;
/* Update current pointer to next of the moved node */

curr = prev->next;
}
}
}
/* We must have prev set before executing lines following this

statement */
else prev = curr;
/* If there are more than 1 odd nodes and end of original list is
odd then move this node to end to maintain same order of odd
numbers in modified list */
if (new_end!=end && (end->data)%2 != 0)
{
prev->next = end->next;
end->next = NULL;
new_end->next = end;
}
return;
}
{
/* allocate node */



}

{
while (node!=NULL)
{
node = node->next;
}
}

int main()
{
/* Let us create a sample linked list as following

0->2->4->6->8->10->11 */
push(&head, 11);
push(&head, 10);
push(&head, 8);
push(&head, 6);
push(&head, 4);
push(&head, 2);
push(&head, 0);

printList(head);
segregateEvenOdd(&head);
printf("\n Modified Linked list ");

printList(head);
return 0;
}

Output:
Original Linked list 0 2 4 6 8 10 11

Modified Linked list 0 2 4 6 8 10 11

Method 2
The idea is to split the linked list into two: one containing all even nodes and other containing all odd nodes.
And finally attach the odd node linked list after the even node linked list.
To split the Linked List, traverse the original Linked List and move all odd nodes to a separate Linked List of
all odd nodes. At the end of loop, the original list will have all the even nodes and the odd node list will have
all the odd nodes. To keep the ordering of all nodes same, we must insert all the odd nodes at the end of the
odd node list. And to do that in constant time, we must keep track of last pointer in the odd node list.
problem.
Predict the outputs of following C programs.
Question 1
int main()
{
int x = 10;
static int y = x;
if(x == y)
printf("Equal");
else if(x > y)
printf("Greater");
else
printf("Less");
getchar();
return 0;
}

Output: Compiler Error

In C, static variables can only be initialized using constant literals. See this GFact for details.
Question 2
#include <stdio.h>
int main()
{
int i;
for (i = 1; i != 10; i += 2)
{
printf(" GeeksforGeeks ");
}
getchar();
return 0;
}

Output: Infinite times GeeksforGeeks
The loop termination condition never becomes true and the loop prints GeeksforGeeks infinite times. In
general, if a for or while statement uses a loop counter, then it is safer to use a relational operator (such as
this for details.
Question 3

#include<stdio.h>
struct st
{
int x;
struct st next;
};
int main()
{
struct st temp;
temp.x = 10;
temp.next = temp;
printf("%d", temp.next.x);
getchar();
return 0;
}


A C structure cannot contain a member of its own type because if this is allowed then it becomes impossible
for compiler to know size of such struct. Although a pointer of same type can be a member because pointers
of all types are of same size and compiler can calculate size of struct.
Count the number of occurrences in a sorted array
Given a sorted array arr[] and a number x, write a function that counts the occurrences of x in arr[]. Expected
time complexity is O(Logn)
Examples:

Input: arr[] = {1, 1, 2, 2, 2, 2, 3,}, x = 2
Output: 4 // x (or 2) occurs 4 times in arr[]
Input: arr[] = {1, 1, 2, 2, 2, 2, 3,}, x = 3

Output: 1
Input: arr[] = {1, 1, 2, 2, 2, 2, 3,}, x = 1

Output: 2
Input: arr[] = {1, 1, 2, 2, 2, 2, 3,}, x = 4

Output: -1 // 4 doesn't occur in arr[]


Linearly search for x, count the occurrences of x and return the count.
Method 2 (Use Binary Search)

1) Use Binary search to get index of the first occurrence of x in arr[]. Let the index of the first occurrence be i.
2) Use Binary search to get index of the last occurrence of x in arr[]. Let the index of the last occurrence be j.
3) Return (j – i + 1);
/* if x is present in arr[] then returns the count of occurrences of x,

otherwise returns -1. */
int count(int arr[], int x, int n)
{
int i; // index of first occurrence of x in arr[0..n-1]
int j; // index of last occurrence of x in arr[0..n-1]

/* get the index of first occurrence of x */
i = first(arr, 0, n-1, x, n);
/* If x doesn't exist in arr[] then return -1 */

if(i == -1)
return i;

/* Else get the index of last occurrence of x. Note that we
are only looking in the subarray after first occurrence */
j = last(arr, i, n-1, x, n);

/* return count */
return j-i+1;
}
/* if x is present in arr[] then returns the index of FIRST occurrence

of x in arr[0..n-1], otherwise returns -1 */
int first(int arr[], int low, int high, int x, int n)
{
if(high >= low)
{
{
if( ( mid == 0 || x > arr[mid-1]) && arr[mid] == x)
return mid;
else if(x > arr[mid])
return first(arr, (mid + 1), high, x, n);
else
return first(arr, low, (mid -1), x, n);
}
return -1;
}
/* if x is present in arr[] then returns the index of LAST occurrence

of x in arr[0..n-1], otherwise returns -1 */
int last(int arr[], int low, int high, int x, int n)
{
if(high >= low)
{
if( ( mid == n-1 || x < arr[mid+1]) && arr[mid] == x )
return mid;
else if(x < arr[mid])
return last(arr, low, (mid -1), x, n);
else
return last(arr, (mid + 1), high, x, n);
}
return -1;
}

int main()
{
int arr[] = {1, 2, 2, 3, 3, 3, 3};
int x = 3; // Element to be counted in arr[]
int c = count(arr, x, n);
printf(" %d occurs %d times ", x, c);
getchar();
return 0;
}


Programming Paradigm: Divide & Conquer
same problem.
Check if a given Binary Tree is SumTree
Write a function that returns true if the given Binary Tree is SumTree else false. A SumTree is a Binary Tree
where the value of a node is equal to sum of the nodes present in its left subtree and right subtree. An empty
tree is SumTree and sum of an empty tree can be considered as 0. A leaf node is also considered as SumTree.
Following is an example of SumTree.
26
/ \
10 3
/ \ \
4 6 3

Method 1 ( Simple )
Get the sum of nodes in left subtree and right subtree. Check if the sum calculated is equal to root’s data.
Also, recursively check if the left and right subtrees are SumTrees.
#include <stdio.h>
#include <stdlib.h>
struct node
{
int data;
struct node* left;
struct node* right;
};
/* A utility function to get the sum of values in tree with root

as root */
int sum(struct node *root)
{
if(root == NULL)
return 0;
return sum(root->left) + root->data + sum(root->right);
}
/* returns 1 if sum property holds for the given

node and both of its children */
int isSumTree(struct node* node)
{
int ls, rs;

return true */
if(node == NULL ||
return 1;
/* Get sum of nodes in left and right subtrees */

ls = sum(node->left);
rs = sum(node->right);

if((node->data == ls + rs)&&
isSumTree(node->left) &&
isSumTree(node->right))
return 1;
return 0;
}
/*
Helper function that allocates a new node
pointers.
*/
{
struct node* node =
node->data = data;
node->left = NULL;
node->right = NULL;
return(node);
}

int main()
{
if(isSumTree(root))
printf("The given tree is a SumTree ");
else
printf("The given tree is not a SumTree ");
getchar();
return 0;
}

Time Complexity: O(n^2) in worst case. Worst case occurs for a skewed tree.
Method 2 ( Tricky )
The Method 1 uses sum() to get the sum of nodes in left and right subtrees. The method 2 uses following
rules to get the sum directly.
1) If the node is a leaf node then sum of subtree rooted with this node is equal to value of this node.
2) If the node is not a leaf node then sum of subtree rooted with this node is twice the value of this node
(Assuming that the tree rooted with this node is SumTree).
#include <stdio.h>
#include <stdlib.h>
struct node
{
int data;
struct node* left;
struct node* right;
struct node* right;
};
/* Utillity function to check if the given node is leaf or not */

int isLeaf(struct node *node)
{
if(node == NULL)
return 0;
if(node->left == NULL && node->right == NULL)
return 1;
return 0;
}
/* returns 1 if SumTree property holds for the given

tree */
int isSumTree(struct node* node)
{
int ls; // for sum of nodes in left subtree
int rs; // for sum of nodes in right subtree

return true */
if(node == NULL || isLeaf(node))
return 1;
if( isSumTree(node->left) && isSumTree(node->right))

{
// Get the sum of nodes in left subtree
if(node->left == NULL)
ls = 0;
else if(isLeaf(node->left))
ls = node->left->data;
else
ls = 2*(node->left->data);
// Get the sum of nodes in right subtree

if(node->right == NULL)
rs = 0;
else if(isLeaf(node->right))
rs = node->right->data;
else
rs = 2*(node->right->data);
/* If root's data is equal to sum of nodes in left

and right subtrees then return 1 else return 0*/
return(node->data == ls + rs);
}
return 0;
}

pointers.
*/
{
struct node* node =
node->data = data;
node->left = NULL;
node->right = NULL;
return(node);
}
int main()
{
if(isSumTree(root))
printf("The given tree is a SumTree ");
else
printf("The given tree is not a SumTree ");
getchar();
return 0;
}

same problem.
Detect and Remove Loop in a Linked List
Write a function detectAndRemoveLoop() that checks whether a given Linked List contains loop and if loop
is present then removes the loop and returns true. And if the list doesn’t contain loop then returns false.
Below diagram shows a linked list with a loop. detectAndRemoveLoop() must change the below list to 1->2-
>3->4->5->NULL.
We recommend to read following post as a prerequisite.
Write a C function to detect loop in a linked list
Before trying to remove the loop, we must detect it. Techniques discussed in the above post can be used to
detect loop. To remove loop, all we need to do is to get pointer to the last node of the loop. For example, node
with value 5 in the above diagram. Once we have pointer to the last node, we can make the next of this node
as NULL and loop is gone.
We can easily use Hashing or Visited node techniques (discussed in the aobve mentioned post) to get the
pointer to the last node. Idea is simple: the very first node whose next is already visited (or hashed) is the
last node.
We can also use Floyd Cycle Detection algorithm to detect and remove the loop. In the Floyd’s algo, the slow
and fast pointers meet at a loop node. We can use this loop node to remove cycle. There are following two
different ways of removing loop when Floyd’s algorithm is used for Loop detection.
Method 1 (Check one by one)

We know that Floyd’s Cycle detection algorithm terminates when fast and slow pointers meet at a common
point. We also know that this common point is one of the loop nodes (2 or 3 or 4 or 5 in the above diagram).
We store the address of this in a pointer variable say ptr2. Then we start from the head of the Linked List and
check for nodes one by one if they are reachable from ptr2. When we find a node that is reachable, we know
that this node is the starting node of the loop in Linked List and we can get pointer to the previous of this
node.
#include<stdio.h>
#include<stdlib.h>

struct node
{
int data;
struct node* next;
};
/* Function to remove loop. Used by detectAndRemoveLoop() */

void removeLoop(struct node *, struct node *);
/* This function detects and removes loop in the list

If loop was there in the list then it returns 1,
otherwise returns 0 */
int detectAndRemoveLoop(struct node *list)
{
while (slow_p && fast_p && fast_p->next)

{
/* If slow_p and fast_p meet at some point then there

is a loop */
{
removeLoop(slow_p, list);
/* Return 1 to indicate that loop is found */

return 1;
}
}
/* Return 0 to indeciate that ther is no loop*/

return 0;
}
/* Function to remove loop.

loop_node --> Pointer to one of the loop nodes
head --> Pointer to the start node of the linked list */
void removeLoop(struct node *loop_node, struct node *head)
{
struct node *ptr1;
struct node *ptr2;
/* Set a pointer to the beging of the Linked List and

move it one by one to find the first node which is
part of the Linked List */
ptr1 = head;
while(1)
{
/* Now start a pointer from loop_node and check if it ever
reaches ptr2 */
ptr2 = loop_node;
while(ptr2->next != loop_node && ptr2->next != ptr1)
{
ptr2 = ptr2->next;
}
/* If ptr2 reahced ptr1 then there is a loop. So break the

loop */
if(ptr2->next == ptr1)
break;
/* If ptr2 did't reach ptr1 then try the next node after ptr1 */
else
ptr1 = ptr1->next;
}
/* After the end of loop ptr2 is the last node of the loop. So
make next of ptr2 as NULL */
ptr2->next = NULL;
}
of a list and an int, pushes a new node on the front
of the list. */
of the list. */
{
/* allocate node */



}

{
while(node != NULL)
{
node = node->next;
}
}

int main()
{
push(&head, 10);
push(&head, 4);
push(&head, 15);
push(&head, 20);
push(&head, 50);

head->next->next->next->next->next = head->next->next;
detectAndRemoveLoop(head);
printf("Linked List after removing loop \n");

printList(head);
getchar();
return 0;
}

Method 2 (Efficient Solution)

This method is also dependent on Floyd’s Cycle detection algorithm.
1) Detect Loop using Floyd’s Cycle detection algo and get the pointer to a loop node.
2) Count the number of nodes in loop. Let the count be k.
3) Fix one pointer to the head and another to kth node from head.
4) Move both pointers at the same pace, they will meet at loop starting node.
5) Get pointer to the last node of loop and make next of it as NULL.
Thanks to WgpShashank for suggesting this method.

#include<stdio.h>
#include<stdlib.h>

struct node
{
int data;
struct node* next;
};
/* Function to remove loop. */

void removeLoop(struct node *, struct node *);
/* This function detects and removes loop in the list

If loop was there in the list then it returns 1,
otherwise returns 0 */
{
while (slow_p && fast_p && fast_p->next)

{
/* If slow_p and fast_p meet at some point then there

is a loop */
{
removeLoop(slow_p, list);
/* Return 1 to indicate that loop is found */

return 1;
}
}
/* Return 0 to indeciate that ther is no loop*/

return 0;
}
/* Function to remove loop.

loop_node --> Pointer to one of the loop nodes
head --> Pointer to the start node of the linked list */
void removeLoop(struct node *loop_node, struct node *head)
{
struct node *ptr1 = loop_node;
struct node *ptr2 = loop_node;
// Count the number of nodes in loop

unsigned int k = 1, i;
while (ptr1->next != ptr2)
{
ptr1 = ptr1->next;
k++;
}
// Fix one pointer to head

ptr1 = head;
// And the other pointer to k nodes after head

ptr2 = head;
for(i = 0; i < k; i++)
for(i = 0; i < k; i++)
ptr2 = ptr2->next;
/* Move both pointers at the same pace,

they will meet at loop starting node */
while(ptr2 != ptr1)
{
ptr1 = ptr1->next;
ptr2 = ptr2->next;
}
// Get pointer to the last node

ptr2 = ptr2->next;
while(ptr2->next != ptr1)
ptr2 = ptr2->next;
/* Set the next node of the loop ending node

to fix the loop */
ptr2->next = NULL;
}
of a list and an int, pushes a new node on the front
of the list. */
{
/* allocate node */



}

{
while(node != NULL)
{
node = node->next;
}
}

int main()
{
push(&head, 10);
push(&head, 4);
push(&head, 15);
push(&head, 20);
push(&head, 50);

detectAndRemoveLoop(head);
printf("Linked List after removing loop \n");

printList(head);
getchar();
return 0;
}

same problem.
Interpolation search vs Binary search
Interpolation search works better than Binary Search for a sorted and uniformly distributed array.
On average the interpolation search makes about log(log(n)) comparisons (if the elements are uniformly
distributed), where n is the number of elements to be searched. In the worst case (for instance where the
numerical values of the keys increase exponentially) it can make up to O(n) comparisons.
Sources:
http://en.wikipedia.org/wiki/Interpolation_search
Searching for Patterns | Set 3 (Rabin-Karp Algorithm)
Examples:
1) Input:

pat[] = "TEST"

Output:
2) Input:

pat[] = "AABA"

Output:


The Naive String Matching algorithm slides the pattern one by one. After each slide, it one by one checks
characters at the current shift and if all characters match then prints the match.
Like the Naive Algorithm, Rabin-Karp algorithm also slides the pattern one by one. But unlike the Naive
algorithm, Rabin Karp algorithm matches the hash value of the pattern with the hash value of current
substring of text, and if the hash values match then only it starts matching individual characters. So Rabin
Karp algorithm needs to calculate hash values for following strings.
1) Pattern itself.
2) All the substrings of text of length m.
Since we need to efficiently calculate hash values for all the substrings of size m of text, we must have a hash
function which has following property.
Hash at the next shift must be efficiently computable from the current hash value and next character in text
or we can say hash(txt[s+1 .. s+m]) must be efficiently computable from hash(txt[s .. s+m-1]) and txt[s+m]
i.e., hash(txt[s+1 .. s+m])= rehash(txt[s+m], hash(txt[s .. s+m-1]) and rehash must be O(1) operation.
The hash function suggested by Rabin and Karp calculates an integer value. The integer value for a string is
numeric value of a string. For example, if all possible characters are from 1 to 10, the numeric value of “122”
will be 122. The number of possible characters is higher than 10 (256 in general) and pattern length can be
large. So the numeric values cannot be practically stored as an integer. Therefore, the numeric value is
calculated using modular arithmetic to make sure that the hash values can be stored in an integer variable
(can fit in memory words). To do rehashing, we need to take off the most significant digit and add the new
least significant digit for in hash value. Rehashing is done using the following formula.
hash( txt[s+1 .. s+m] ) = d ( hash( txt[s .. s+m-1]) – txt[s]*h ) + txt[s + m] ) mod q
hash( txt[s .. s+m-1] ) : Hash value at shift s.

hash( txt[s+1 .. s+m] ) : Hash value at next shift (or shift s+1)
d: Number of characters in the alphabet
q: A prime number
h: d^(m-1)
/* Following program is a C implementation of the Rabin Karp Algorithm

given in the CLRS book */
#include<stdio.h>
#include<string.h>
// d is the number of characters in input alphabet

#define d 256

/* pat -> pattern
txt -> text
q -> A prime number
*/
void search(char *pat, char *txt, int q)
{
int i, j;
int p = 0; // hash value for pattern
int t = 0; // hash value for txt
int h = 1;

// The value of h would be "pow(d, M-1)%q"
for (i = 0; i < M-1; i++)
h = (h*d)%q;

// Calculate the hash value of pattern and first window of text
for (i = 0; i < M; i++)
{
p = (d*p + pat[i])%q;
t = (d*t + txt[i])%q;
}

// Slide the pattern over text one by one
for (i = 0; i <= N - M; i++)
{

// Check the hash values of current window of text and pattern
// If the hash values match then only check for characters on by one
if ( p == t )
{
/* Check for characters one by one */
for (j = 0; j < M; j++)
{
break;
}
if (j == M) // if p == t and pat[0...M-1] = txt[i, i+1, ...i+M-1]
{
}
}

// Calculate hash value for next window of text: Remove leading digit,
// add trailing digit
if ( i < N-M )
{
t = (d*(t - txt[i]*h) + txt[i+M])%q;

// We might get negative value of t, converting it to positive
if(t < 0)
t = (t + q);
}
}
}

int main()
{
char *txt = "GEEKS FOR GEEKS";
char *pat = "GEEK";
int q = 101; // A prime number
search(pat, txt, q);
getchar();
return 0;
}
The average and best case running time of the Rabin-Karp algorithm is O(n+m), but its worst-case time is
O(nm). Worst case of Rabin-Karp algorithm occurs when all characters of pattern and text are same as the
hash values of all the substrings of txt[] match with hash value of pat[]. For example pat[] = “AAA” and txt[]
= “AAAAAAA”.
discussed above.
References:
http://www.cs.princeton.edu/courses/archive/fall04/cos226/lectures/string.4up.pdf
http://en.wikipedia.org/wiki/Rabin-Karp_string_search_algorithm
Related Posts:
Searching for Patterns | Set 1 (Naive Pattern Searching)
Searching for Patterns | Set 2 (KMP Algorithm)
Given an array arr[], find the maximum j – i such that arr[j] > arr[i]
Given an array arr[], find the maximum j – i such that arr[j] > arr[i].
Examples:

Input: {34, 8, 10, 3, 2, 80, 30, 33, 1}
Output: 6 (j = 7, i = 1)
Input: {9, 2, 3, 4, 5, 6, 7, 8, 18, 0}

Output: 8 ( j = 8, i = 0)
Input: {1, 2, 3, 4, 5, 6}
Output: 5 (j = 5, i = 0)
Input: {6, 5, 4, 3, 2, 1}
Output: -1

Method 1 (Simple but Inefficient)

Run two loops. In the outer loop, pick elements one by one from left. In the inner loop, compare the picked
element with the elements starting from right side. Stop the inner loop when you see an element greater
than the picked element and keep updating the maximum j-i so far.
#include <stdio.h>
/* For a given array arr[], returns the maximum j – i such that
arr[j] > arr[i] */
int maxIndexDiff(int arr[], int n)
{
int maxDiff = -1;
int i, j;
for (i = 0; i < n; ++i)

{
for (j = n-1; j > i; --j)
{
if(arr[j] > arr[i] && maxDiff < (j - i))
maxDiff = j - i;
}
}
return maxDiff;
}
int main()
{
int arr[] = {9, 2, 3, 4, 5, 6, 7, 8, 18, 0};
int maxDiff = maxIndexDiff(arr, n);
printf("\n %d", maxDiff);
getchar();
return 0;
}


Method 2 (Efficient)
To solve this problem, we need to get two optimum indexes of arr[]: left index i and right index j. For an
element arr[i], we do not need to consider arr[i] for left index if there is an element smaller than arr[i] on
left side of arr[i]. Similarly, if there is a greater element on right side of arr[j] then we do not need to consider
this j for right index. So we construct two auxiliary arrays LMin[] and RMax[] such that LMin[i] holds the
smallest element on left side of arr[i] including arr[i], and RMax[j] holds the greatest element on right side
of arr[j] including arr[j]. After constructing these two auxiliary arrays, we traverse both of these arrays from
left to right. While traversing LMin[] and RMa[] if we see that LMin[i] is greater than RMax[j], then we
must move ahead in LMin[] (or do i++) because all elements on left of LMin[i] are greater than or equal to
LMin[i]. Otherwise we must move ahead in RMax[j] to look for a greater j – i value.
Thanks to celicom for suggesting the algorithm for this method.
#include <stdio.h>
/* Utility Functions to get max and minimum of two integers */

{
return x > y? x : y;
}

{
return x < y? x : y;
}
/* For a given array arr[], returns the maximum j – i such that

arr[j] > arr[i] */
int maxIndexDiff(int arr[], int n)
{
int maxDiff;
int i, j;
int *LMin = (int *)malloc(sizeof(int)*n);

int *RMax = (int *)malloc(sizeof(int)*n);
/* Construct LMin[] such that LMin[i] stores the minimum value

from (arr[0], arr[1], ... arr[i]) */
LMin[0] = arr[0];
for (i = 1; i < n; ++i)
LMin[i] = min(arr[i], LMin[i-1]);
/* Construct RMax[] such that RMax[j] stores the maximum value

from (arr[j], arr[j+1], ..arr[n-1]) */
RMax[n-1] = arr[n-1];
for (j = n-2; j >= 0; --j)
RMax[j] = max(arr[j], RMax[j+1]);
/* Traverse both arrays from left to right to find optimum j - i

This process is similar to merge() of MergeSort */
i = 0, j = 0, maxDiff = -1;
while (j < n && i < n)
{
if (LMin[i] < RMax[j])
{
maxDiff = max(maxDiff, j-i);
j = j + 1;
}
else
i = i+1;
}
return maxDiff;
}

int main()
{
int arr[] = {9, 2, 3, 4, 5, 6, 7, 8, 18, 0};
int maxDiff = maxIndexDiff(arr, n);
printf("\n %d", maxDiff);
getchar();
return 0;
}


same problem.
XOR Linked List – A Memory Efficient Doubly Linked List | Set 1
An ordinary Doubly Linked List requires space for two address fields to store the addresses of previous and
next nodes. A memory efficient version of Doubly Linked List can be created using only one space for
address field with every node. This memory efficient Doubly Linked List is called XOR Linked List or
Memory Efficient as the list uses bitwise XOR operation to save space for one address. In the XOR linked
list, instead of storing actual memory addresses, every node stores the XOR of addresses of previous and
next nodes.
Consider the above Doubly Linked List. Following are the Ordinary and XOR (or Memory Effiecient)
representations of the Doubly Linked List.
Ordinary Representation:
Node A:
prev = NULL, next = add(B) // previous is NULL and next is address of B
Node B:
prev = add(A), next = add(C) // previous is address of A and next is address of C
Node C:
prev = add(B), next = add(D) // previous is address of B and next is address of D
Node D:
prev = add(C), next = NULL // previous is address of C and next is NULL
XOR List Representation:

Let us call the address variable in XOR representation npx (XOR of next and previous)
Node A:
npx = 0 XOR add(B) // bitwise XOR of zero and address of B
Node B:
npx = add(A) XOR add(C) // bitwise XOR of address of A and address of C
Node C:
npx = add(B) XOR add(D) // bitwise XOR of address of B and address of D
Node D:
npx = add(C) XOR 0 // bitwise XOR of address of C and 0
Traversal of XOR Linked List:

We can traverse the XOR list in both forward and reverse direction. While traversing the list we need to
remember the address of the previously accessed node in order to calculate the next node’s address. For
example when we are at node C, we must have address of B. XOR of add(B) and npx of C gives us the add(D).
The reason is simple: npx(C) is “add(B) XOR add(D)”. If we do xor of npx(C) with add(B), we get the result
as “add(B) XOR add(D) XOR add(B)” which is “add(D) XOR 0″ which is “add(D)”. So we have the address of
next node. Similarly we can traverse the list in backward direction.
We have covered more on XOR Linked List in the following post.

References:
http://en.wikipedia.org/wiki/XOR_linked_list
http://www.linuxjournal.com/article/6828?page=0,0
Maximum of all subarrays of size k (Added a O(n) method)
Given an array and an integer k, find the maximum for each and every contiguous subarray of size k.
Examples:
Input :
arr[] = {1, 2, 3, 1, 4, 5, 2, 3, 6}
k = 3
Output :
3 3 4 5 5 5 6
Input :
arr[] = {8, 5, 10, 7, 9, 4, 15, 12, 90, 13}
k = 4
Output :
10 10 10 15 15 90 90
Method 1 (Simple)
Run two loops. In the outer loop, take all subarrays of size k. In the inner loop, get the maximum of the
current subarray.
#include<stdio.h>
void printKMax(int arr[], int n, int k)

{
int j, max;
for (int i = 0; i <= n-k; i++)

{
max = arr[i];
for (j = 1; j < k; j++)

{
if (arr[i+j] > max)
max = arr[i+j];
}
printf("%d ", max);
}
}
int main()
{
int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int k = 3;
printKMax(arr, n, k);
return 0;
}

Time Complexity: The outer loop runs n-k+1 times and the inner loop runs k times for every iteration of
outer loop. So time complexity is O((n-k+1)*k) which can also be written as O(nk).
Method 2 (Use Self-Balancing BST)

1) Pick first k elements and create a Self-Balancing Binary Search Tree (BST) of size k.
2) Run a loop for i = 0 to n – k
…..a) Get the maximum element from the BST, and print it.
…..b) Search for arr[i] in the BST and delete it from the BST.
…..c) Insert arr[i+k] into the BST.
Time Complexity: Time Complexity of step 1 is O(kLogk). Time Complexity of steps 2(a), 2(b) and 2(c) is
O(Logk). Since steps 2(a), 2(b) and 2(c) are in a loop that runs n-k+1 times, time complexity of the complete
algorithm is O(kLogk + (n-k+1)*Logk) which can also be written as O(nLogk).
Method 3 (A O(n) method: use Dequeue)

We create a Dequeue, Qi of capacity k, that stores only useful elements of current window of k elements. An
element is useful if it is in current window and is greater than all other elements on left side of it in current
window. We process all array elements one by one and maintain Qi to contain useful elements of current
window and these useful elements are maintained in sorted order. The element at front of the Qi is the
largest and element at rear of Qi is the smallest of current window. Thanks to Aashish for suggesting this
method.
Following is C++ implementation of this method.
#include <iostream>
#include <deque>
// A Dequeue (Double ended queue) based method for printing maixmum element of
// all subarrays of size k
void printKMax(int arr[], int n, int k)
{
// Create a Double Ended Queue, Qi that will store indexes of array elements
// The queue will store indexes of useful elements in every window and it will
// maintain decreasing order of values from front to rear in Qi, i.e.,
// arr[Qi.front[]] to arr[Qi.rear()] are sorted in decreasing order
std::deque<int> Qi(k);
/* Process first k (or first window) elements of array */

int i;
for (i = 0; i < k; ++i)
{
// For very element, the previous smaller elements are useless so
// remove them from Qi
while ( (!Qi.empty()) && arr[i] >= arr[Qi.back()])
Qi.pop_back(); // Remove from rear
// Add new element at rear of queue

Qi.push_back(i);
}
// Process rest of the elements, i.e., from arr[k] to arr[n-1]

for ( ; i < n; ++i)
{
// The element at the front of the queue is the largest element of
// previous window, so print it
cout << arr[Qi.front()] << " ";
// Remove the elements which are out of this window

while ( (!Qi.empty()) && Qi.front() <= i - k)
Qi.pop_front(); // Remove from front of queue
Qi.pop_front(); // Remove from front of queue
// Remove all elements smaller than the currently

// being added element (remove useless elements)
while ( (!Qi.empty()) && arr[i] >= arr[Qi.back()])
Qi.pop_back();
// Add current element at the rear of Qi

Qi.push_back(i);
}
// Print the maximum element of last window

cout << arr[Qi.front()];
}

int main()
{
int arr[] = {12, 1, 78, 90, 57, 89, 56};
int k = 3;
printKMax(arr, n, k);
return 0;
}

Output:

78 90 90 90 89

Time Complexity: O(n). It seems more than O(n) at first look. If we take a closer look, we can observe that
every element of array is added and removed at most once. So there are total 2n operations.
Auxiliary Space: O(k)
same problem.
Time Complexity of building a heap
Consider the following algorithm for building a Heap of an input array A.
BUILD-HEAP(A)
heapsize := size(A);
for i := floor(heapsize/2) downto 1
do HEAPIFY(A, i);
end for
END

What is the worst case time complexity of the above algo?

Although the worst case complexity looks like O(nLogn), upper bound of time complexity is O(n). See
following links for the proof of time complexity.
http://www.cse.iitk.ac.in/users/sbaswana/Courses/ESO211/heap.pdf/
http://www.cs.sfu.ca/CourseCentral/307/petra/2009/SLN_2.pdf
Dynamic Programming | Set 1 (Overlapping Subproblems Property)
Dynamic Programming is an algorithmic paradigm that solves a given complex problem by breaking it into
subproblems and stores the results of subproblems to avoid computing the same results again. Following are
the two main properties of a problem that suggest that the given problem can be solved using Dynamic
programming.
1) Overlapping Subproblems
2) Optimal Substructure
1) Overlapping Subproblems:
Like Divide and Conquer, Dynamic Programming combines solutions to sub-problems. Dynamic
Programming is mainly used when solutions of same subproblems are needed again and again. In dynamic
programming, computed solutions to subproblems are stored in a table so that these don’t have to
recomputed. So Dynamic Programming is not useful when there are no common (overlapping) subproblems
because there is no point storing the solutions if they are not needed again. For example, Binary Search
doesn’t have common subproblems. If we take example of following recursive program for Fibonacci
Numbers, there are many subproblems which are solved again and again.
/* simple recursive program for Fibonacci numbers */

int fib(int n)
{
if ( n <= 1 )
return n;
}

Recursion tree for execution of fib(5)

fib(5)
/ \
fib(4) fib(3)
/ \ / \
fib(3) fib(2) fib(2) fib(1)
/ \ / \ / \
fib(2) fib(1) fib(1) fib(0) fib(1) fib(0)
/ \
fib(1) fib(0)

We can see that the function f(3) is being called 2 times. If we would have stored the value of f(3), then
instead of computing it again, we would have reused the old stored value. There are following two different
ways to store the values so that these values can be reused.
a) Memoization (Top Down):

b) Tabulation (Bottom Up):
a) Memoization (Top Down): The memoized program for a problem is similar to the recursive version with
a small modification that it looks into a lookup table before computing solutions. We initialize a lookup array
with all initial values as NIL. Whenever we need solution to a subproblem, we first look into the lookup table.
If the precomputed value is there then we return that value, otherwise we calculate the value and put the
result in lookup table so that it can be reused later.
Following is the memoized version for nth Fibonacci Number.
/* Memoized version for nth Fibonacci number */

#include<stdio.h>
#define NIL -1
#define MAX 100
int lookup[MAX];
/* Function to initialize NIL values in lookup table */

void _initialize()
{
int i;
for (i = 0; i < MAX; i++)
lookup[i] = NIL;
}
/* function for nth Fibonacci number */

int fib(int n)
{
if(lookup[n] == NIL)
{
if ( n <= 1 )
lookup[n] = n;
else
lookup[n] = fib(n-1) + fib(n-2);
}
return lookup[n];
}
int main ()
{
int n = 40;
_initialize();
printf("Fibonacci number is %d ", fib(n));
getchar();
return 0;
}

b) Tabulation (Bottom Up): The tabulated program for a given problem builds a table in bottom up fashion
and returns the last entry from table.

/* tabulated version */
#include<stdio.h>
int fib(int n)
{
int f[n+1];
int i;
f[0] = 0; f[1] = 1;
for (i = 2; i <= n; i++)
f[i] = f[i-1] + f[i-2];
return f[n];
}

int main ()
{
int n = 9;
printf("Fibonacci number is %d ", fib(n));
getchar();
return 0;
}

Both tabulated and Memoized store the solutions of subproblems. In Memoized version, table is filled on
demand while in tabulated version, starting from the first entry, all entries are filled one by one. Unlike the
tabulated version, all entries of the lookup table are not necessarily filled in memoized version. For example,
memoized solution of LCS problem doesn’t necessarily fill all entries.
To see the optimization achieved by memoized and tabulated versions over the basic recursive version, see
the time taken by following runs for 40th Fibonacci number.
Simple recursive program

Memoized version
tabulated version
Also see method 2 of Ugly Number post for one more simple example where we have overlapping
subproblems and we store the results of subproblems.
We will be covering Optimal Substructure Property and some more example problems in future posts on
Dynamic Programming.
Try following questions as an exercise of this post.

1) Write a memoized version for LCS problem. Note that the tabular version is given in the CLRS book.
2) How would you choose between Memoization and Tabulation?
discussed above.
References:
http://www.youtube.com/watch?v=V5hZoJ6uK-s
Dynamic Programming | Set 2 (Optimal Substructure Property)
As we discussed in Set 1, following are the two main properties of a problem that suggest that the given
problem can be solved using Dynamic programming.
We have already discussed Overlapping Subproblem property in the Set 1. Let us discuss Optimal
Substructure property here.
2) Optimal Substructure: A given problems has Optimal Substructure Property if optimal solution of the
given problem can be obtained by using optimal solutions of its subproblems.
For example the shortest path problem has following optimal substructure property: If a node x lies in the
shortest path from a source node u to destination node v then the shortest path from u to v is combination of
shortest path from u to x and shortest path from x to v. The standard All Pair Shortest Path algorithms like
Floyd–Warshall and Bellman–Ford are typical examples of Dynamic Programming.
On the other hand the Longest path problem doesn’t have the Optimal Substructure property. Here by
Longest Path we mean longest simple path (path without cycle) between two nodes. Consider the following
unweighted graph given in the CLRS book. There are two longest paths from q to t: q -> r ->t and q ->s->t.
Unlike shortest paths, these longest paths do not have the optimal substructure property. For example, the
longest path q->r->t is not a combination of longest path from q to r and longest path from r to t, because
the longest path from q to r is q->s->t->r.
We will be covering some example problems in future posts on Dynamic Programming.
discussed above.
References:
http://en.wikipedia.org/wiki/Optimal_substructure
CLRS book
Dynamic Programming | Set 3 (Longest Increasing Subsequence)
We have discussed Overlapping Subproblems and Optimal Substructure properties in Set 1 and Set 2
respectively.
Let us discuss Longest Increasing Subsequence (LIS) problem as an example problem that can be solved
using Dynamic Programming.
The longest Increasing Subsequence (LIS) problem is to find the length of the longest subsequence of a
given sequence such that all elements of the subsequence are sorted in increasing order. For example, length
of LIS for { 10, 22, 9, 33, 21, 50, 41, 60, 80 } is 6 and LIS is {10, 22, 33, 50, 60, 80}.
Optimal Substructure:
Let arr[0..n-1] be the input array and L(i) be the length of the LIS till index i such that arr[i] is part of LIS
and arr[i] is the last element in LIS, then L(i) can be recursively written as.
L(i) = { 1 + Max ( L(j) ) } where j
To get LIS of a given array, we need to return max(L(i)) where 0 Overlapping Subproblems:
Following is simple recursive implementation of the LIS problem. The implementation simply follows the
recursive structure mentioned above. The value of lis ending with every element is returned using
max_ending_here. The overall lis is returned using pointer to a variable max.
/* A Naive recursive implementation of LIS problem */

#include<stdio.h>
#include<stdlib.h>
/* To make use of recursive calls, this function must return two things:
1) Length of LIS ending with element arr[n-1]. We use max_ending_here
for this purpose
2) Overall maximum as the LIS may end with an element before arr[n-1]
max_ref is used this purpose.
The value of LIS of full array of size n is stored in *max_ref which is our final result
*/
int _lis( int arr[], int n, int *max_ref)
{
/* Base case */
if(n == 1)
return 1;
int res, max_ending_here = 1; // length of LIS ending with arr[n-1]
/* Recursively get all LIS ending with arr[0], arr[1] ... ar[n-2]. If
arr[i-1] is smaller than arr[n-1], and max ending with arr[n-1] needs
to be updated, then update it */
for(int i = 1; i < n; i++)
{
res = _lis(arr, i, max_ref);
if (arr[i-1] < arr[n-1] && res + 1 > max_ending_here)
max_ending_here = res + 1;
}
// Compare max_ending_here with the overall max. And update the

// overall max if needed
if (*max_ref < max_ending_here)
*max_ref = max_ending_here;
// Return length of LIS ending with arr[n-1]

return max_ending_here;
}
// The wrapper function for _lis()

// The wrapper function for _lis()
int lis(int arr[], int n)
{
// The max variable holds the result
int max = 1;
// The function _lis() stores its result in max

_lis( arr, n, &max );
// returns max
return max;
}

int main()
{
int arr[] = { 10, 22, 9, 33, 21, 50, 41, 60 };
printf("Length of LIS is %d\n", lis( arr, n ));
getchar();
return 0;
}

Considering the above implementation, following is recursion tree for an array of size 4. lis(n) gives us the
length of LIS for arr[].

lis(4)
/ | \
lis(3) lis(2) lis(1)
/ \ /
lis(2) lis(1) lis(1)
/
lis(1)

We can see that there are many subproblems which are solved again and again. So this problem has
Overlapping Substructure property and recomputation of same subproblems can be avoided by either using
Memoization or Tabulation. Following is a tabluated implementation for the LIS problem.

/* Dynamic Programming implementation of LIS problem */

#include<stdio.h>
#include<stdlib.h>
/* lis() returns the length of the longest increasing subsequence in

arr[] of size n */
int lis( int arr[], int n )
{
int *lis, i, j, max = 0;
lis = (int*) malloc ( sizeof( int ) * n );
/* Initialize LIS values for all indexes */

for ( i = 0; i < n; i++ )
lis[i] = 1;

/* Compute optimized LIS values in bottom up manner */
for ( i = 1; i < n; i++ )
for ( j = 0; j < i; j++ )
if ( arr[i] > arr[j] && lis[i] < lis[j] + 1)
lis[i] = lis[j] + 1;

/* Pick maximum of all LIS values */
for ( i = 0; i < n; i++ )
if ( max < lis[i] )
max = lis[i];
/* Free memory to avoid memory leak */

free( lis );
return max;
}

int main()
{
int arr[] = { 10, 22, 9, 33, 21, 50, 41, 60 };
printf("Length of LIS is %d\n", lis( arr, n ) );
getchar();
return 0;
}

Note that the time complexity of the above Dynamic Programmig (DP) solution is O(n^2) and there is a
O(nLogn) solution for the LIS problem (see this). We have not discussed the nLogn solution here as the
purpose of this post is to explain Dynamic Programmig with a simple example.
discussed above.
A Boolean Array Puzzle
Input: A array arr[] of two elements having value 0 and 1
Output: Make both elements 0.
Specifications: Following are the specifications to follow.

1) It is guaranteed that one element is 0 but we do not know its position.
2) We can’t say about another element it can be 0 or 1.
3) We can only complement array elements, no other operation like and, or, multi, division, …. etc.
4) We can’t use if, else and loop constructs.
5) Obviously, we can’t directly assign 0 to array elements.
There are several ways we can do it as we are sure that always one Zero is there. Thanks to devendraiiit for
suggesting following 3 methods.
Method 1
void changeToZero(int a[2])

{
a[ a[1] ] = a[ !a[1] ];
}
int main()
{
int a[] = {1, 0};
changeToZero(a);
printf(" arr[0] = %d \n", a[0]);

printf(" arr[1] = %d ", a[1]);
getchar();
return 0;
}

Method 2

{
a[ !a[0] ] = a[ !a[1] ]
}

Method 3
This method doesn’t even need complement.

{
a[ a[1] ] = a[ a[0] ]
}

Method 4
Thanks to purvi for suggesting this method.

{
a[0] = a[a[0]];
a[1] = a[0];
}

There may be many more methods.
Source: http://geeksforgeeks.org/forum/topic/google-challenge
Please write comments if you find the above codes incorrect, or find other ways to solve the same problem.
Find whether an array is subset of another array | Added Method 3
Given two arrays: arr1[0..m-1] and arr2[0..n-1]. Find whether arr2[] is a subset of arr1[] or not. Both the
arrays are not in sorted order.
Examples:
Input: arr1[] = {11, 1, 13, 21, 3, 7}, arr2[] = {11, 3, 7, 1}
Output: arr2[] is a subset of arr1[]
Input: arr1[] = {1, 2, 3, 4, 5, 6}, arr2[] = {1, 2, 4}

Output: arr2[] is a subset of arr1[]
Input: arr1[] = {10, 5, 2, 23, 19}, arr2[] = {19, 5, 3}

Output: arr2[] is not a subset of arr1[]
Method 1 (Simple)
Use two loops: The outer loop picks all the elements of arr2[] one by one. The inner loop linearly searches for
the element picked by outer loop. If all elements are found then return 1, else return 0.

#include<stdio.h>
/* Return 1 if arr2[] is a subset of arr1[] */

bool isSubset(int arr1[], int arr2[], int m, int n)
{
int i = 0;
int j = 0;
for (i=0; i<n; i++)
{
for (j = 0; j<m; j++)
{
if(arr2[i] == arr1[j])
break;
}

/* If the above inner loop was not broken at all then
arr2[i] is not present in arr1[] */
if (j == m)
return 0;
}

/* If we reach here then all elements of arr2[]
are present in arr1[] */
return 1;
}

int main()
{
int arr1[] = {11, 1, 13, 21, 3, 7};
int arr2[] = {11, 3, 7, 1};

if(isSubset(arr1, arr2, m, n))

printf("arr2[] is subset of arr1[] ");
else
printf("arr2[] is not a subset of arr1[]");
getchar();
return 0;
}

Time Complexity: O(m*n)
Method 2 (Use Sorting and Binary Search)
1) Sort arr1[] O(mLogm)

2) For each element of arr2[], do binary search for it in sorted arr1[].
a) If the element is not found then return 0.
3) If all elements are present then return 1.

#include<stdio.h>
#include<stdio.h>
/* Fucntion prototypes */
void quickSort(int *arr, int si, int ei);
int binarySearch(int arr[], int low, int high, int x);

{
int i = 0;

quickSort(arr1, 0, m-1);
for (i=0; i<n; i++)
{
if (binarySearch(arr1, 0, m-1, arr2[i]) == -1)
return 0;
}

/* If we reach here then all elements of arr2[]
are present in arr1[] */
return 1;
}

/* FOLLOWING FUNCTIONS ARE ONLY FOR SEARCHING AND SORTING PURPOSE */
/* Standard Binary Search function*/
int binarySearch(int arr[], int low, int high, int x)
{
if(high >= low)
{

/* Check if arr[mid] is the first occurrence of x.
arr[mid] is first occurrence if x is one of the following
is true:
(i) mid == 0 and arr[mid] == x
(ii) arr[mid-1] < x and arr[mid] == x
*/
if(( mid == 0 || x > arr[mid-1]) && (arr[mid] == x))
return mid;
else if(x > arr[mid])
return binarySearch(arr, (mid + 1), high, x);
else
return binarySearch(arr, low, (mid -1), x);
}
return -1;
}

{
int temp;
temp = *a;
*a = *b;
*b = temp;
}

{
int x = A[ei];
int i = (si - 1);
int j;

for (j = si; j <= ei - 1; j++)
{
if(A[j] <= x)
{
i++;
}
}
return (i + 1);
}

ei --> Ending index
*/
{
if(si < ei)
{
}
}

/*Driver program to test above functions */
int main()
{
int arr1[] = {11, 1, 13, 21, 3, 7};
int arr2[] = {11, 3, 7, 1};

if(isSubset(arr1, arr2, m, n))

printf("arr2[] is subset of arr1[] ");
else
printf("arr2[] is not a subset of arr1[] ");
getchar();
return 0;
}

Time Complexity: O(mLogm + nLogm). Please note that this will be the complexity if an mLogm algorithm is
used for sorting which is not the case in above code. In above code Quick Sort is sued and worst case time
complexity of Quick Sort is O(m^2)
Method 3 (Use Sorting and Merging )

1) Sort both arrays: arr1[] and arr2[] O(mLogm + nLogn)
2) Use Merge type of process to see if all elements of sorted arr2[] are present in sorted arr1[].
Thanks to Parthsarthi for suggesting this method.


{
int i = 0, j = 0;

if(m < n)
return 0;
quickSort(arr1, 0, m-1);
quickSort(arr2, 0, n-1);
while( i < n && j < m )
{
if( arr1[j] <arr2[i] )
j++;
else if( arr1[j] == arr2[i] )
{
j++;
i++;
}
else if( arr1[j] > arr2[i] )
return 0;
}

if( i < n )
return 0;
else
return 1;
}

Time Complexity: O(mLogm + nLogn) which is better than method 2. Please note that this will be the
complexity if an nLogn algorithm is used for sorting both arrays which is not the case in above code. In
above code Quick Sort is sued and worst case time complexity of Quick Sort is O(n^2)
Method 4 (Use Hashing)

1) Create a Hash Table for all the elements of arr1[].
2) Traverse arr2[] and search for each element of arr2[] in the Hash Table. If element is not found then
return 0.
3) If all elements are found then return 1.
Note that method 1, method 2 and method 4 don’t handle the cases when we have duplicates in arr2[]. For
example, {1, 4, 4, 2} is not a subset of {1, 4, 2}, but these methods will print it as a subset.
Source: http://geeksforgeeks.org/forum/topic/if-an-array-is-subset-of-another
same problem.
Dynamic Programming | Set 4 (Longest Common Subsequence)
We have discussed Overlapping Subproblems and Optimal Substructure properties in Set 1 and Set 2
respectively. We also discussed one example problem in Set 3. Let us discuss Longest Common Subsequence
(LCS) problem as one more example problem that can be solved using Dynamic Programming.
LCS Problem Statement: Given two sequences, find the length of longest subsequence present in both of
them. A subsequence is a sequence that appears in the same relative order, but not necessarily contiguous.
For example, “abc”, “abg”, “bdf”, “aeg”, ‘”acefg”, .. etc are subsequences of “abcdefg”. So a string of length n
has 2^n different possible subsequences.
It is a classic computer science problem, the basis of diff (a file comparison program that outputs the
differences between two files), and has applications in bioinformatics.
Examples:
LCS for input Sequences “ABCDGH” and “AEDFHR” is “ADH” of length 3.
LCS for input Sequences “AGGTAB” and “GXTXAYB” is “GTAB” of length 4.
The naive solution for this problem is to generate all subsequences of both given sequences and find the
longest matching subsequence. This solution is exponential in term of time complexity. Let us see how this
problem possesses both important properties of a Dynamic Programming (DP) Problem.
1) Optimal Substructure:
Let the input sequences be X[0..m-1] and Y[0..n-1] of lengths m and n respectively. And let L(X[0..m-1],
Y[0..n-1]) be the length of LCS of the two sequences X and Y. Following is the recursive definition of
L(X[0..m-1], Y[0..n-1]).
If last characters of both sequences match (or X[m-1] == Y[n-1]) then

L(X[0..m-1], Y[0..n-1]) = 1 + L(X[0..m-2], Y[0..n-2])
If last characters of both sequences do not match (or X[m-1] != Y[n-1]) then
L(X[0..m-1], Y[0..n-1]) = MAX ( L(X[0..m-2], Y[0..n-1]), L(X[0..m-1], Y[0..n-2])
Examples:
1) Consider the input strings “AGGTAB” and “GXTXAYB”. Last characters match for the strings. So length of
LCS can be written as:
L(“AGGTAB”, “GXTXAYB”) = 1 + L(“AGGTA”, “GXTXAY”)
2) Consider the input strings “ABCDGH” and “AEDFHR. Last characters do not match for the strings. So
length of LCS can be written as:
L(“ABCDGH”, “AEDFHR”) = MAX ( L(“ABCDG”, “AEDFHR”), L(“ABCDGH”, “AEDFH”) )
So the LCS problem has optimal substructure property as the main problem can be solved using solutions to
subproblems.
2) Overlapping Subproblems:
Following is simple recursive implementation of the LCS problem. The implementation simply follows the
recursive structure mentioned above.

/* A Naive recursive implementation of LCS problem */

#include<stdio.h>
#include<stdlib.h>
/* Returns length of LCS for X[0..m-1], Y[0..n-1] */

int lcs( char *X, char *Y, int m, int n )
{
if (m == 0 || n == 0)
return 0;
if (X[m-1] == Y[n-1])
return 1 + lcs(X, Y, m-1, n-1);
else
return max(lcs(X, Y, m, n-1), lcs(X, Y, m-1, n));
}
/* Utility function to get max of 2 integers */

{
return (a > b)? a : b;
}

int main()
{
char X[] = "AGGTAB";
char Y[] = "GXTXAYB";
int m = strlen(X);
int n = strlen(Y);
printf("Length of LCS is %d\n", lcs( X, Y, m, n ) );
getchar();
return 0;
}

Time complexity of the above naive recursive approach is O(2^n) in worst case and worst case happens
when all characters of X and Y mismatch i.e., length of LCS is 0.
Considering the above implementation, following is a partial recursion tree for input strings “AXYT” and
“AYZX”

lcs("AXYT", "AYZX")
/ \
lcs("AXY", "AYZX") lcs("AXYT", "AYZ")
/ \ / \
lcs("AX", "AYZX") lcs("AXY", "AYZ") lcs("AXY", "AYZ") lcs("AXYT", "AY")

In the above partial recursion tree, lcs(“AXY”, “AYZ”) is being solved twice. If we draw the complete
recursion tree, then we can see that there are many subproblems which are solved again and again. So this
problem has Overlapping Substructure property and recomputation of same subproblems can be avoided by
either using Memoization or Tabulation. Following is a tabulated implementation for the LCS problem.

/* Dynamic Programming implementation of LCS problem */

#include<stdio.h>
#include<stdlib.h>


{
int L[m+1][n+1];
int i, j;

/* Following steps build L[m+1][n+1] in bottom up fashion. Note
that L[i][j] contains length of LCS of X[0..i-1] and Y[0..j-1] */
for (i=0; i<=m; i++)
{
for (j=0; j<=n; j++)
{
if (i == 0 || j == 0)
L[i][j] = 0;

else if (X[i-1] == Y[j-1])
L[i][j] = L[i-1][j-1] + 1;

else
L[i][j] = max(L[i-1][j], L[i][j-1]);
}
}

/* L[m][n] contains length of LCS for X[0..n-1] and Y[0..m-1] */
return L[m][n];
}

{
}

int main()
{

int m = strlen(X);
int n = strlen(Y);

printf("Length of LCS is %d\n", lcs( X, Y, m, n ) );

getchar();
return 0;
}

Time Complexity of the above implementation is O(mn) which is much better than the worst case time
complexity of Naive Recursive implementation.
The above algorithm/code returns only length of LCS. Please see the following post for printing the LCS.
Printing Longest Common Subsequence
discussed above.
References:
http://www.youtube.com/watch?v=V5hZoJ6uK-s
http://www.algorithmist.com/index.php/Longest_Common_Subsequence
http://en.wikipedia.org/wiki/Longest_common_subsequence_problem
What does ‘Space Complexity’ mean?
Space Complexity:
The term Space Complexity is misused for Auxiliary Space at many places. Following are the correct
definitions of Auxiliary Space and Space Complexity.
Auxiliary Space is the extra space or temporary space used by an algorithm.
Space Complexity of an algorithm is total space taken by the algorithm with respect to the input size. Space
complexity includes both Auxiliary space and space used by input.
For example, if we want to compare standard sorting algorithms on the basis of space, then Auxiliary Space
would be a better criteria than Space Complexity. Merge Sort uses O(n) auxiliary space, Insertion sort and
Heap Sort use O(1) auxiliary space. Space complexity of all these sorting algorithms is O(n) though.
discussed above.
A Time Complexity Question
What is the time complexity of following function fun()? Assume that log(x) returns log value in base 2.
void fun()
{
int i, j;
for (i=1; i<=n; i++)
for (j=1; j<=log(i); j++)
printf("GeeksforGeeks");
}

Time Complexity of the above function can be written as Θ(log 1) + Θ(log 2) + Θ(log 3) + . . . . + Θ(log n)
which is Θ (log n!)
Order of growth of ‘log n!’ and ‘n log n’ is same for large values of n, i.e., Θ (log n!) = Θ(n log n). So time
complexity of fun() is Θ(n log n).
The expression Θ(log n!) = Θ(n log n) can be easily derived from following Stirling’s approximation (or
Stirling’s formula).
log n! = n log n - n + O(log(n))

discussed above.
Sources:
http://en.wikipedia.org/wiki/Stirling%27s_approximation
Find the minimum distance between two numbers
Given an unsorted array arr[] and two numbers x and y, find the minimum distance between x and y in arr[].
The array might also contain duplicates. You may assume that both x and y are different and present in
arr[].
Examples:
Input: arr[] = {1, 2}, x = 1, y = 2
Output: Minimum distance between 1 and 2 is 1.
Input: arr[] = {3, 4, 5}, x = 3, y = 5

Input: arr[] = {3, 5, 4, 2, 6, 5, 6, 6, 5, 4, 8, 3}, x = 3, y = 6

Input: arr[] = {2, 5, 3, 5, 4, 4, 2, 3}, x = 3, y = 2

Method 1 (Simple)
Use two loops: The outer loop picks all the elements of arr[] one by one. The inner loop picks all the elements
after the element picked by outer loop. If the elements picked by outer and inner loops have same values as x
or y then if needed update the minimum distance calculated so far.

#include <stdio.h>
#include <stdlib.h> // for abs()
#include <limits.h> // for INT_MAX
int minDist(int arr[], int n, int x, int y)

{
int i, j;
int min_dist = INT_MAX;
for (i = 0; i < n; i++)
{
for (j = i+1; j < n; j++)
{
if( (x == arr[i] && y == arr[j] ||
y == arr[i] && x == arr[j]) && min_dist > abs(i-j))
{
min_dist = abs(i-j);
}
}
}
return min_dist;
}
/* Driver program to test above fnction */

int main()
{
int arr[] = {3, 5, 4, 2, 6, 5, 6, 6, 5, 4, 8, 3};
int x = 3;
int y = 6;
printf("Minimum distance between %d and %d is %d\n", x, y,

minDist(arr, n, x, y));
return 0;
}

Output: Minimum distance between 3 and 6 is 4
Method 2 (Tricky)
1) Traverse array from left side and stop if either x or y is found. Store index of this first occurrence in a
variable say prev
2) Now traverse arr[] after the index prev. If the element at current index i matches with either x or y then
check if it is different from arr[prev]. If it is different then update the minimum distance if needed. If it is
same then update prev i.e., make prev = i.
Thanks to wgpshashank for suggesting this approach.

#include <stdio.h>
#include <limits.h> // For INT_MAX
int minDist(int arr[], int n, int x, int y)

{
int i = 0;
int min_dist = INT_MAX;
int prev;
// Find the first occurence of any of the two numbers (x or y)

// and store the index of this occurence in prev
for (i = 0; i < n; i++)
{
if (arr[i] == x || arr[i] == y)
{
prev = i;
break;
}
}
// Traverse after the first occurence

for ( ; i < n; i++)
{
if (arr[i] == x || arr[i] == y)
{
// If the current element matches with any of the two then
// check if current element and prev element are different
// Also check if this value is smaller than minimm distance so far
if ( arr[prev] != arr[i] && (i - prev) < min_dist )
{
min_dist = i - prev;
prev = i;
}
else
prev = i;
}
}
return min_dist;
}
/* Driver program to test above fnction */

int main()
{
int arr[] ={3, 5, 4, 2, 6, 3, 0, 0, 5, 4, 8, 3};
int x = 3;
int y = 6;
printf("Minimum distance between %d and %d is %d\n", x, y,

minDist(arr, n, x, y));
return 0;
}
Output: Minimum distance between 3 and 6 is 1

same problem.
Spaghetti Stack
Spaghetti stack
A spaghetti stack is an N-ary tree data structure in which child nodes have pointers to the parent nodes (but
not vice-versa)
Spaghetti stack structure is used in situations when records are dynamically pushed and popped onto a stack
as execution progresses, but references to the popped records remain in use. Following are some
applications of Spaghetti Stack.
Compilers for languages such as C create a spaghetti stack as it opens and closes symbol tables representing
block scopes. When a new block scope is opened, a symbol table is pushed onto a stack. When the closing
curly brace is encountered, the scope is closed and the symbol table is popped. But that symbol table is
remembered, rather than destroyed. And of course it remembers its higher level “parent” symbol table and
so on.
Spaghetti Stacks are also used to implement Disjoint-set data structure.
discussed above.
Sources:
http://en.wikipedia.org/wiki/Spaghetti_stack
Dynamic Programming | Set 5 (Edit Distance)
Continuing further on dynamic programming series, edit distance is an interesting algorithm.
Problem: Given two strings of size m, n and set of operations replace (R), insert (I) and delete (D) all at
equal cost. Find minimum number of edits (operations) required to convert one string into another.
Identifying Recursive Methods:
What will be sub-problem in this case? Consider finding edit distance of part of the strings, say small prefix.
Let us denote them as [1…i] and [1…j] for some 1< i < m and 1 < j < n. Clearly it is solving smaller instance of
final problem, denote it as E(i, j). Our goal is finding E(m, n) and minimizing the cost.
In the prefix, we can right align the strings in three ways (i, -), (-, j) and (i, j). The hyphen symbol (-)
representing no character. An example can make it more clear.
Given strings SUNDAY and SATURDAY. We want to convert SUNDAY into SATURDAY with minimum
edits. Let us pick i = 2 and j = 4 i.e. prefix strings are SUN and SATU respectively (assume the strings indices
start at 1). The right most characters can be aligned in three different ways.
Case 1: Align characters U and U. They are equal, no edit is required. We still left with the problem of i = 1
and j = 3, E(i-1, j-1).
Case 2: Align right character from first string and no character from second string. We need a deletion (D)
here. We still left with problem of i = 1 and j = 4, E(i-1, j).
Case 3: Align right character from second string and no character from first string. We need an insertion (I)
here. We still left with problem of i = 2 and j = 3, E(i, j-1).
Combining all the subproblems minimum cost of aligning prefix strings ending at i and j given by
E(i, j) = min( [E(i-1, j) + D], [E(i, j-1) + I], [E(i-1, j-1) + R if i,j characters are not same] )
We still not yet done. What will be base case(s)?
When both of the strings are of size 0, the cost is 0. When only one of the string is zero, we need edit
operations as that of non-zero length string. Mathematically,
E(0, 0) = 0, E(i, 0) = i, E(0, j) = j
Now it is easy to complete recursive method. Go through the code for recursive algorithm
(edit_distance_recursive).
Dynamic Programming Method:
We can calculate the complexity of recursive expression fairly easily.
T(m, n) = T(m-1, n-1) + T(m, n-1) + T(m-1, n) + C
The complexity of T(m, n) can be calculated by successive substitution method or solving homogeneous
equation of two variables. It will result in an exponential complexity algorithm. It is evident from the
recursion tree that it will be solving subproblems again and again. Few strings result in many overlapping
subproblems (try the below program with strings exponential and polynomial and note the delay in
recursive method).
We can tabulate the repeating subproblems and look them up when required next time (bottom up). A two
dimensional array formed by the strings can keep track of the minimum cost till the current
character comparison. The visualization code will help in understanding the construction of matrix.
The time complexity of dynamic programming method is O(mn) as we need to construct the table fully. The
space complexity is also O(mn). If we need only the cost of edit, we just need O(min(m, n)) space as it is
required only to keep track of the current row and previous row.
Usually the costs D, I and R are not same. In such case the problem can be represented as an acyclic directed
graph (DAG) with weights on each edge, and finding shortest path gives edit distance.
Applications:
There are many practical applications of edit distance algorithm, refer Lucene API for sample. Another
example, display all the words in a dictionary that are near proximity to a given word\incorrectly spelled
word.
// Dynamic Programming implementation of edit distance

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
// Change these strings to test the program

#define STRING_X "SUNDAY"
#define STRING_Y "SATURDAY"
#define SENTINEL (-1)

#define EDIT_COST (1)
inline
int min(int a, int b) {
return a < b ? a : b;
}
// Returns Minimum among a, b, c

int Minimum(int a, int b, int c)
{
return min(min(a, b), c);
}
// Strings of size m and n are passed.

// Construct the Table for X[0...m, m+1], Y[0...n, n+1]
int EditDistanceDP(char X[], char Y[])
{
// Cost of alignment
int cost = 0;
int leftCell, topCell, cornerCell;
int m = strlen(X)+1;
int n = strlen(Y)+1;
// T[m][n]
int *T = (int *)malloc(m * n * sizeof(int));
// Initialize table
for(int i = 0; i < m; i++)
for(int j = 0; j < n; j++)
*(T + i * n + j) = SENTINEL;
// Set up base cases

// T[i][0] = i
for(int i = 0; i < m; i++)
*(T + i * n) = i;
// T[0][j] = j
for(int j = 0; j < n; j++)
*(T + j) = j;
*(T + j) = j;
// Build the T in top-down fashion

for(int i = 1; i < m; i++)
{
for(int j = 1; j < n; j++)
{
// T[i][j-1]
leftCell = *(T + i*n + j-1);
leftCell += EDIT_COST; // deletion
// T[i-1][j]
topCell = *(T + (i-1)*n + j);
topCell += EDIT_COST; // insertion
// Top-left (corner) cell

// T[i-1][j-1]
cornerCell = *(T + (i-1)*n + (j-1) );
// edit[(i-1), (j-1)] = 0 if X[i] == Y[j], 1 otherwise

cornerCell += (X[i-1] != Y[j-1]); // may be replace
// Minimum cost of current cell

// Fill in the next cell T[i][j]
*(T + (i)*n + (j)) = Minimum(leftCell, topCell, cornerCell);
}
}
// Cost is in the cell T[m][n]

cost = *(T + m*n - 1);
free(T);
return cost;
}
// Recursive implementation
int EditDistanceRecursion( char *X, char *Y, int m, int n )
{
// Base cases
if( m == 0 && n == 0 )
return 0;
if( m == 0 )
return n;
if( n == 0 )
return m;
// Recurse
int left = EditDistanceRecursion(X, Y, m-1, n) + 1;
int right = EditDistanceRecursion(X, Y, m, n-1) + 1;
int corner = EditDistanceRecursion(X, Y, m-1, n-1) + (X[m-1] != Y[n-1]);
return Minimum(left, right, corner);

}
int main()
{
char X[] = STRING_X; // vertical
char Y[] = STRING_Y; // horizontal
printf("Minimum edits required to convert %s into %s is %d\n",

X, Y, EditDistanceDP(X, Y) );
printf("Minimum edits required to convert %s into %s is %d by recursion\n",
X, Y, EditDistanceRecursion(X, Y, strlen(X), strlen(Y)));
return 0;
}

— Venki. Please write comments if you find anything incorrect, or you want to share more information
Backtracking | Set 1 (The Knight’s tour problem)
Backtracking is an algorithmic paradigm that tries different solutions until finds a solution that “works”.
Problems which are typically solved using backtracking technique have following property in common.
These problems can only be solved by trying every possible configuration and each configuration is tried
only once. A Naive solution for these problems is to try all configurations and output a configuration that
follows given problem constraints. Backtracking works in incremental way and is an optimization over the
Naive solution where all possible configurations are generated and tried.
For example, consider the following Knight’s Tour problem.

The knight is placed on the first block of an empty board and, moving according to the rules of chess, must
visit each square exactly once.
Let us first discuss the Naive algorithm for this problem and then the Backtracking algorithm.
Naive Algorithm for Knight’s tour

The Naive Algorithm is to generate all tours one by one and check if the generated tour satisfies the
constraints.
while there are untried tours

{
generate the next tour
if this tour covers all squares
{
print this path;
}
}

Backtracking works in an incremental way to attack problems. Typically, we start from an empty solution
vector and one by one add items (Meaning of item varies from problem to problem. In context of Knight’s
tour problem, an item is a Knight’s move). When we add an item, we check if adding the current item violates
the problem constraint, if it does then we remove the item and try other alternatives. If none of the
alternatives work out then we go to previous stage and remove the item added in the previous stage. If we
reach the initial stage back then we say that no solution exists. If adding an item doesn’t violate constraints
then we recursively add items one by one. If the solution vector becomes complete then we print the
solution.
Backtracking Algorithm for Knight’s tour

Following is the Backtracking algorithm for Knight’s tour problem.

If all squares are visited

print the solution
Else
a) Add one of the next moves to solution vector and recursively
check if this move leads to a solution. (A Knight can make maximum
eight moves. We choose one of the 8 moves in this step).
b) If the move chosen in the above step doesn't lead to a solution
then remove this move from the solution vector and try other
alternative moves.
c) If none of the alternatives work then return false (Returning false
will remove the previously added item in recursion and if false is
returned by the initial call of recursion then "no solution exists" )

Following is C implementation for Knight’s tour problem. It prints one of the possible solutions in 2D matrix
form. Basically, the output is a 2D 8*8 matrix with numbers from 0 to 63 and these numbers show steps
made by Knight.
#include<stdio.h>
#define N 8
int solveKTUtil(int x, int y, int movei, int sol[N][N], int xMove[],

int yMove[]);
/* A utility function to check if i,j are valid indexes for N*N chessboard */
int isSafe(int x, int y, int sol[N][N])
{
if ( x >= 0 && x < N && y >= 0 && y < N && sol[x][y] == -1)
return 1;
return 0;
}
/* A utility function to print solution matrix sol[N][N] */

void printSolution(int sol[N][N])
{
for (int x = 0; x < N; x++)
{
for (int y = 0; y < N; y++)
printf(" %2d ", sol[x][y]);
printf("\n");
}
}
/* This function solves the Knight Tour problem using Backtracking. This
function mainly uses solveKTUtil() to solve the problem. It returns false if
no complete tour is possible, otherwise return true and prints the tour.
Please note that there may be more than one solutions, this function
prints one of the feasible solutions. */
bool solveKT()
{
int sol[N][N];
/* Initialization of solution matrix */

for (int x = 0; x < N; x++)
for (int y = 0; y < N; y++)
sol[x][y] = -1;
/* xMove[] and yMove[] define next move of Knight.
xMove[] is for next value of x coordinate
yMove[] is for next value of y coordinate */
int xMove[8] = { 2, 1, -1, -2, -2, -1, 1, 2 };
int yMove[8] = { 1, 2, 2, 1, -1, -2, -2, -1 };
// Since the Knight is initially at the first block

sol[0][0] = 0;
/* Start from 0,0 and explore all tours using solveKTUtil() */

if(solveKTUtil(0, 0, 1, sol, xMove, yMove) == false)
{
printf("Solution does not exist");
return false;
}
else
printSolution(sol);
return true;
}
/* A recursive utility function to solve Knight Tour problem */

int solveKTUtil(int x, int y, int movei, int sol[N][N], int xMove[N],
int yMove[N])
{
int k, next_x, next_y;
if (movei == N*N)
return true;
/* Try all next moves from the current coordinate x, y */

for (k = 0; k < 8; k++)
{
next_x = x + xMove[k];
next_y = y + yMove[k];
if (isSafe(next_x, next_y, sol))
{
sol[next_x][next_y] = movei;
if (solveKTUtil(next_x, next_y, movei+1, sol, xMove, yMove) == true)
return true;
else
sol[next_x][next_y] = -1;// backtracking
}
}
return false;
}

int main()
{
solveKT();
getchar();
return 0;
}

Output:

0 59 38 33 30 17 8 63
37 34 31 60 9 62 29 16
58 1 36 39 32 27 18 7
35 48 41 26 61 10 15 28
42 57 2 49 40 23 6 19
47 50 45 54 25 20 11 14
56 43 52 3 22 13 24 5
51 46 55 44 53 4 21 12

Note that Backtracking is not the best solution for the Knight’s tour problem. See this for other better
solutions. The purpose of this post is to explain Backtracking with an example.
References:
http://see.stanford.edu/materials/icspacs106b/H19-RecBacktrackExamples.pdf
http://www.cis.upenn.edu/~matuszek/cit594-2009/Lectures/35-backtracking.ppt
http://mathworld.wolfram.com/KnightsTour.html
http://en.wikipedia.org/wiki/Knight%27s_tour
discussed above.
Backtracking | Set 2 (Rat in a Maze)
We have discussed Backtracking and Knight’s tour problem in Set 1. Let us discuss Rat in a Maze as another
example problem that can be solved using Backtracking.
A Maze is given as N*N binary matrix of blocks where source block is the upper left most block i.e., maze[0]
[0] and destination block is lower rightmost block i.e., maze[N-1][N-1]. A rat starts from source and has to
reach destination. The rat can move only in two directions: forward and down.
In the maze matrix, 0 means the block is dead end and 1 means the block can be used in the path from
source to destination. Note that this is a simple version of the typical Maze problem. For example, a more
complex version can be that the rat can move in 4 directions and a more complex version can be with limited
number of moves.
Following is an example maze.

Gray blocks are dead ends (value = 0).

Following is binary matrix representation of the above maze.
{1, 0, 0, 0}
{1, 1, 0, 1}
{0, 1, 0, 0}
{1, 1, 1, 1}

Following is maze with highlighted solution path.
Following is the solution matrix (output of program) for the above input matrx.

{1, 0, 0, 0}
{1, 1, 0, 0}
{0, 1, 0, 0}
{0, 1, 1, 1}
All enteries in solution path are marked as 1.

Naive Algorithm
The Naive Algorithm is to generate all paths from source to destination and one by one check if the
generated path satisfies the constraints.

while there are untried paths
{
generate the next path
if this path has all blocks as 1
{
print this path;
}
}

Backtrackng Algorithm

If destination is reached
print the solution matrix
Else
a) Mark current cell in solution matrix as 1.
b) Move forward in horizontal direction and recursively check if this
move leads to a solution.
c) If the move chosen in the above step doesn't lead to a solution
then move down and check if this move leads to a solution.
d) If none of the above solutions work then unmark this cell as 0
(BACKTRACK) and return false.

Implementation of Backtracking solution
#include<stdio.h>
// Maze size
#define N 4
bool solveMazeUtil(int maze[N][N], int x, int y, int sol[N][N]);
/* A utility function to print solution matrix sol[N][N] */

void printSolution(int sol[N][N])
{
for (int i = 0; i < N; i++)
{
for (int j = 0; j < N; j++)
printf(" %d ", sol[i][j]);
printf("\n");
}
}
}
/* A utility function to check if x,y is valid index for N*N maze */

bool isSafe(int maze[N][N], int x, int y)
{
// if (x,y outside maze) return false
if(x >= 0 && x < N && y >= 0 && y < N && maze[x][y] == 1)
return true;
return false;
}
/* This function solves the Maze problem using Backtracking. It mainly uses
solveMazeUtil() to solve the problem. It returns false if no path is possible,
otherwise return true and prints the path in the form of 1s. Please note that
there may be more than one solutions, this function prints one of the feasible
solutions.*/
bool solveMaze(int maze[N][N])
{
int sol[N][N] = { {0, 0, 0, 0},
{0, 0, 0, 0},
{0, 0, 0, 0},
{0, 0, 0, 0}
};
if(solveMazeUtil(maze, 0, 0, sol) == false)

{
printf("Solution doesn't exist");
return false;
}
printSolution(sol);
return true;
}
/* A recursive utility function to solve Maze problem */

bool solveMazeUtil(int maze[N][N], int x, int y, int sol[N][N])
{
// if (x,y is goal) return true
if(x == N-1 && y == N-1)
{
sol[x][y] = 1;
return true;
}
// Check if maze[x][y] is valid

if(isSafe(maze, x, y) == true)
{
// mark x,y as part of solution path
sol[x][y] = 1;
/* Move forward in x direction */

if (solveMazeUtil(maze, x+1, y, sol) == true)
return true;
/* If moving in x direction doesn't give solution then

Move down in y direction */
if (solveMazeUtil(maze, x, y+1, sol) == true)
return true;
/* If none of the above movements work then BACKTRACK:

unmark x,y as part of solution path */
sol[x][y] = 0;
return false;
return false;
}
return false;
}

int main()
{
int maze[N][N] = { {1, 0, 0, 0},
{1, 1, 0, 1},
{0, 1, 0, 0},
{1, 1, 1, 1}
};
solveMaze(maze);
getchar();
return 0;
}

discussed above.
Backtracking | Set 3 (N Queen Problem)
We have discussed Knight’s tour and Rat in a Maze problems in Set 1 and Set 2 respectively. Let us discuss N
Queen as another example problem that can be solved using Backtracking.
The N Queen is the problem of placing N chess queens on an N×N chessboard so that no two queens attack
each other. For example, following is a solution for 4 Queen problem.
The expected output is a binary matrix which has 1s for the blocks where queens are placed. For example
following is the output matrix for above 4 queen solution.

{ 0, 1, 0, 0}
{ 0, 0, 0, 1}
{ 1, 0, 0, 0}
{ 0, 0, 1, 0}

Naive Algorithm
Generate all possible configurations of queens on board and print a configuration that satisfies the given
constraints.

while there are untried conflagrations
{
generate the next configuration
if queens don't attack in this configuration then
{
print this configuration;
}
}

Backtracking Algorithm
The idea is to place queens one by one in different columns, starting from the leftmost column. When we
place a queen in a column, we check for clashes with already placed queens. In the current column, if we find
a row for which there is no clash, we mark this row and column as part of the solution. If we do not find such
a row due to clashes then we backtrack and return false.

1) Start in the leftmost column
2) If all queens are placed
return true
3) Try all rows in the current column. Do following for every tried row.
a) If the queen can be placed safely in this row then mark this [row,
column] as part of the solution and recursively check if placing
queen here leads to a solution.
b) If placing queen in [row, column] leads to a solution then return
true.
c) If placing queen doesn't lead to a solution then umark this [row,
column] (Backtrack) and go to step (a) to try other rows.
3) If all rows have been tried and nothing worked, return false to trigger
backtracking.


#define N 4
#include<stdio.h>
/* A utility function to print solution */

void printSolution(int board[N][N])
{
for (int i = 0; i < N; i++)
{
for (int j = 0; j < N; j++)
printf(" %d ", board[i][j]);
printf("\n");
}
}
/* A utility function to check if a queen can be placed on board[row][col]

Note that this function is called when "col" queens are already placeed
in columns from 0 to col -1. So we need to check only left side for
attacking queens */
bool isSafe(int board[N][N], int row, int col)
{
int i, j;
/* Check this row on left side */

for (i = 0; i < col; i++)
{
if (board[row][i])
return false;
}
/* Check upper diagonal on left side */

for (i = row, j = col; i >= 0 && j >= 0; i--, j--)
{
if (board[i][j])
return false;
}
/* Check lower diagonal on left side */

for (i = row, j = col; j >= 0 && i < N; i++, j--)
{
if (board[i][j])
return false;
}
return true;
}
/* A recursive utility function to solve N Queen problem */

bool solveNQUtil(int board[N][N], int col)
{
/* base case: If all queens are placed then return true */
if (col >= N)
return true;
/* Consider this column and try placing this queen in all rows
one by one */
for (int i = 0; i < N; i++)
{
/* Check if queen can be placed on board[i][col] */
if ( isSafe(board, i, col) )
{
/* Place this queen in board[i][col] */
board[i][col] = 1;
/* recur to place rest of the queens */

if ( solveNQUtil(board, col + 1) == true )
return true;
/* If placing queen in board[i][col] doesn't lead to a solution

then remove queen from board[i][col] */
board[i][col] = 0; // BACKTRACK
}
}
/* If queen can not be place in any row in this colum col

return false;
}
/* This function solves the N Queen problem using Backtracking. It mainly uses
solveNQUtil() to solve the problem. It returns false if queens cannot be placed,
otherwise return true and prints placement of queens in the form of 1s. Please
note that there may be more than one solutions, this function prints one of the
feasible solutions.*/
bool solveNQ()
{
int board[N][N] = { {0, 0, 0, 0},
{0, 0, 0, 0},
{0, 0, 0, 0},
{0, 0, 0, 0}
};
if ( solveNQUtil(board, 0) == false )
{
return false;
}
printSolution(board);
return true;
}

int main()
{
solveNQ();
getchar();
getchar();
return 0;
}

Sources:
http://en.literateprograms.org/Eight_queens_puzzle_%28C%29
http://en.wikipedia.org/wiki/Eight_queens_puzzle
discussed above.
Searching for Patterns | Set 4 (A Naive Pattern Searching Question)
Question: We have discussed Naive String matching algorithm here. Consider a situation where all
characters of pattern are different. Can we modify the original Naive String Matching algorithm so that it
works better for these types of patterns. If we can, then what are the changes to original algorithm?
Solution: In the original Naive String matching algorithm , we always slide the pattern by 1. When all
characters of pattern are different, we can slide the pattern by more than 1. Let us see how can we do this.
When a mismatch occurs after j matches, we know that the first character of pattern will not match the j
matched characters because all characters of pattern are different. So we can always slide the pattern by j
without missing any valid shifts. Following is the modified code that is optimized for the special patterns.

#include<stdio.h>
#include<string.h>
/* A modified Naive Pettern Searching algorithn that is optimized

for the cases when all characters of pattern are different */
{
int i = 0;
while(i <= N - M)
{
int j;
/* For current index i, check for pattern match */

for (j = 0; j < M; j++)
{
break;
}
if (j == M) // if pat[0...M-1] = txt[i, i+1, ...i+M-1]
{
i = i + M;
}
else if (j == 0)
{
i = i + 1;
}
else
{
i = i + j; // slide the pattern by j
}
}
}

int main()
{
char *txt = "ABCEABCDABCEABCD";
char *pat = "ABCD";
search(pat, txt);
getchar();
return 0;
}

Output:
discussed above.
Question 1
#include<iostream>
int x = 10;
void fun()
{
int x = 2;
{
int x = 1;
cout << ::x << endl;
}
}
int main()
{
fun();
return 0;
}

Output: 10
If Scope Resolution Operator is placed before a variable name then the global variable is referenced. So if we
remove the following line from the above program then it will fail in compilation.
int x = 10;

Question 2

#include<iostream>
class Point {
private:
int x;
int y;
public:
Point(int i, int j); // Constructor
};
Point::Point(int i = 0, int j = 0) {
x = i;
y = j;
cout << "Constructor called";
}
int main()
{
Point t1, *t2;
return 0;
}

Output: Constructor called.

If we take a closer look at the statement “Point t1, *t2;:” then we can see that only one object is constructed
here. t2 is just a pointer variable, not an object.
Question 3

#include<iostream>
class Point {
private:
int x;
int y;
public:
Point(int i = 0, int j = 0); // Normal Constructor
Point(const Point &t); // Copy Constructor
};
Point::Point(int i, int j) {
x = i;
y = j;
cout << "Normal Constructor called\n";
}
Point::Point(const Point &t) {

y = t.y;
cout << "Copy Constructor called\n";
}
int main()
{
Point *t1, *t2;
t1 = new Point(10, 15);
t2 = new Point(*t1);
Point t3 = *t1;
Point t4;
t4 = t3;
return 0;
}

Output:
Normal Constructor called
Copy Constructor called
Copy Constructor called
Normal Constructor called
See following comments for explanation:
Point *t1, *t2; // No constructor call

t1 = new Point(10, 15); // Normal constructor call
t2 = new Point(*t1); // Copy constructor call
Point t3 = *t1; // Copy Constructor call
Point t4; // Normal Constructor call
t4 = t3; // Assignment operator call

Decision Trees – Fake (Counterfeit) Coin Puzzle (12 Coin Puzzle)
Let us solve the classic “fake coin” puzzle using decision trees. There are the two different variants of the
puzzle given below. I am providing description of both the puzzles below, try to solve on your own, assume
N = 8.
Easy: Given a two pan fair balance and N identically looking coins, out of which only one coin is lighter
(or heavier). To figure out the odd coin, how many minimum number of weighing are required in the
worst case?
Difficult: Given a two pan fair balance and N identically looking coins out of which only one coin may
be defective. How can we trace which coin, if any, is odd one and also determine whether it is lighter or
heavier in minimum number of trials in the worst case?
Let us start with relatively simple examples. After reading every problem try to solve on your own.
Problem 1: (Easy)
Given 5 coins out of which one coin is lighter. In the worst case, how many minimum number of
weighing are required to figure out the odd coin?
Name the coins as 1, 2, 3, 4 and 5. We know that one coin is lighter. Considering best out come of balance,
we can group the coins in two different ways, [(1, 2), (3, 4) and (5)], or [(12), (34) and (5)]. We can easily
rule out groups like [(123) and (45)], as we will get obvious answer. Any other combination will fall into one
of these two groups, like [(2)(45) and (13)], etc.
Consider the first group, pairs (1, 2) and (3, 4). We can check (1, 2), if they are equal we go ahead with (3, 4).
We need two weighing in worst case. The same analogy can be applied when the coin in heavier.
With the second group, weigh (12) and (34). If they balance (5) is defective one, otherwise pick the lighter
pair, and we need one more weighing to find odd one.
Both the combinations need two weighing in case of 5 coins with prior information of one coin is lighter.
Analysis: In general, if we know that the coin is heavy or light, we can trace the coin in log(N) trials
3
(rounded to next integer). If we represent the outcome of balance as ternary tree, every leaf represent an
outcome. Since any coin among N coins can be defective, we need to get a 3-ary tree having minimum of N
leaves. A 3-ary tree at k-th level will have 3k leaves and hence we need 3k >= N.
In other-words, in k trials we can examine upto 3k coins, if we know whether the defective coin is heavier or
lighter. Given that a coin is heavier, verify that 3 trials are sufficient to find the odd coin among 12 coins,
because 32 < 12 < 33.
Problem 2: (Difficult)
We are given 4 coins, out of which only one coin may be defective. We don’t know, whether all coins are
genuine or any defective one is present. How many number of weighing are required in worst case to
figure out the odd coin, if present? We also need to tell whether it is heavier or lighter.
From the above analysis we may think that k = 2 trials are sufficient, since a two level 3-ary tree yields 9
leaves which is greater than N = 4 (read the problem once again). Note that it is impossible to solve above 4
coins problem in two weighing. The decision tree confirms the fact (try to draw).
We can group the coins in two different ways, [(12, 34)] or [(1, 2) and (3, 4)]. Let us consider the
combination (12, 34), the corresponding decision tree is given below. Blue leaves are valid outcomes, and
red leaves are impossible cases. We arrived at impossible cases due to the assumptions made earlier on the
path.
The outcome can be (12) < (34) i.e. we go on to left subtree or (12) > (34) i.e. we go on to right subtree.
The left subtree is possible in two ways,
A) Either 1 or 2 can be lighter OR

B) Either 3 or 4 can be heavier.
Further on the left subtree, as second trial, we weigh (1, 2) or (3, 4). Let us consider (3, 4) as the analogy for
(1, 2) is similar. The outcome of second trail can be three ways
A) (3) < (4) yielding 4 as defective heavier coin, OR

B) (3) > (4) yielding 3 as defective heavier coin OR
C) (3) = (4), yielding ambiguity. Here we need one more weighing to check a genuine coin against 1 or
2. In the figure I took (3, 2) where 3 is confirmed as genuine. We can get (3) > (2) in which 2 is lighter,
or (3) = (2) in which 1 is lighter. Note that it impossible to get (3) < (2), it contradicts our assumption
leaned to left side.
Similarly we can analyze the right subtree. We need two more weighings on right subtree as well.
Overall we need 3 weighings to trace the odd coin. Note that we are unable to utilize two outcomes of 3-ary
trees. Also, the tree is not full tree, middle branch terminated after first weighing. Infact, we can get 27
leaves of 3 level full 3-ary tree, but only we got 11 leaves including impossible cases.
Analysis: Given N coins, all may be genuine or only one coin is defective. We need a decision tree with
atleast (2N + 1) leaves correspond to the outputs. Because there can be N leaves to be lighter, or N leaves to
be heavier or one genuine case, on total (2N + 1) leaves.
As explained earlier ternary tree at level k, can have utmost 3k leaves and we need a tree with leaves of 3k >
(2N + 1).
In other words, we need atleast k > log3(2N + 1) weighing to find the defective one.
Observe the above figure that not all the branches are generating leaves, i.e. we are missing valid outputs
under some branches that leading to more number of trials. When possible, we should group the coins in
such a way that every branch is going to yield valid output (in simple terms generate full 3-ary tree).
Problem 4 describes this approach of 12 coins.
Problem 3: (Special case of two pan balance)
We are given 5 coins, a group of 4 coins out of which one coin is defective (we
don’t know whether it is
heavier or lighter), and one coin is genuine. How many weighing are required in worst case to figure out
the odd coin whether it is heavier or lighter?
Label the coins as 1, 2, 3, 4 and G (genuine). We now have some information on coin purity. We need to
make use that in the groupings.
We can best group them as [(G1, 23) and (4)]. Any other group can’t generate full 3-ary tree, try yourself.
The following diagram explains the procedure.
The middle case (G1) = (23) is self explanatory, i.e. 1, 2, 3 are genuine and 4th coin can be figured out lighter
or heavier in one more trial.
The left side of tree corresponds to the case (G1) < (23). This is possible in two ways, either 1 should be
lighter or either of (2, 3) should be heavier. The former instance is obvious when next weighing (2, 3) is
balanced, yielding 1 as lighter. The later instance could be (2) < (3) yielding 3 as heavier or (2) > (3) yielding
2 as heavier. The leaf nodes on left branch are named to reflect these outcomes.
The right side of tree corresponds to the case (G1) > (23). This is possible in two ways, either 1 is heavier or
either of (2, 3) should be lighter. The former instance is obvious when the next weighing (2, 3) is balanced,
yielding 1 as heavier. The later case could be (2) < (3) yielding 2 as lighter coin, or (2) > (3) yielding 3 as
lighter.
In the above problem, under any possibility we need only two weighing. We are able to use all outcomes of
two level full 3-ary tree. We started with (N + 1) = 5 coins where N = 4, we end up with (2N + 1) = 9 leaves.
Infact we should have 11 outcomes since we stared with 5 coins, where are other 2
outcomes? These two outcomes can be declared at the root of tree itself (prior to first
weighing), can you figure these two out comes?
If we observe the figure, after the first weighing the problem reduced to “we know three coins, either one can
be lighter (heavier) or one among other two can be heavier (lighter)”. This can be solved in one weighing
(read Problem 1).
Analysis: Given (N + 1) coins, one is genuine and the rest N can be genuine or only one coin is defective.
The required decision tree should result in minimum of (2N + 1) leaves. Since the total possible outcomes
are (2(N + 1) + 1), number of weighing (trials) are given by the height of ternary tree, k >= log3[2(N + 1) + 1].
Note the equality sign.
Rearranging k and N, we can weigh maximum of N <= (3k – 3)/2 coins in k trials.
Problem 4: (The classic 12 coin puzzle)
You are given two pan fair balance. You have 12 identically looking coins out of which one coin may be
lighter or heavier. How can you find odd coin, if any, in minimum trials, also determine whether defective
coin is lighter or heavier, in the worst case?
How do you want to group them? Bi-set or tri-set? Clearly we can discard the option of dividing into two
equal groups. It can’t lead to best tree. From the above two examples, we can ensure that the decision tree
can be used in optimal way if we can reveal atleaset one genuine coin. Remember to group coins such that
the first weighing reveals atleast one genuine coin.
Let us name the coins as 1, 2, … 8, A, B, C and D. We can combine the coins into 3 groups, namely (1234),
(5678) and (ABCD). Weigh (1234) and (5678). You are encouraged to draw decision tree while reading the
procedure. The outcome can be three ways,
1. (1234) = (5678), both groups are equal. Defective coin may be in (ABCD) group.
2. (1234) < (5678), i.e. first group is less in weight than second group.
3. (1234) > (5678), i.e. first group is more in weight than second group.
The output (1) can be solved in two more weighing as special case of two pan balance given in Problem 3.
We know that groups (1234) and (5678) are genuine and defective coin may be in (ABCD). Pick one genuine
coin from any of weighed groups, and proceed with (ABCD) as explained in Problem 3.
Outcomes (2) and (3) are special. In both the cases, we know that (ABCD) is genuine. And also, we know a
set of coins being lighter and a set of coins being heavier. We need to shuffle the weighed two groups in such
a way that we end up with smaller height decision tree.
Consider the second outcome where (1234) < (5678). It is possible when any coin among (1, 2, 3, 4) is lighter
or any coin among (5, 6, 7, 8 ) is heavier. We revealed lighter or heavier possibility after first weighing. If we
proceed as in Problem 1, we will not generate best decision tree. Let us shuffle coins as (1235) and (4BCD) as
new groups (there are different shuffles possible, they also lead to minimum weighing, can you try?). If we
weigh these two groups again the outcome can be three ways, i) (1235) < (4BCD) yielding one among 1, 2, 3
is lighter which is similar to Problem 1 explained above, we need one more weighing, ii) (1235) = (4BCD)
yielding one among 6, 7, 8 is heavier which is similar to Problem 1 explained above, we need one more
weighing iii) (1235) > (4BCD) yielding either 5 as heavier coin or 4 as lighter coin, at the expense of one
more weighing.
Similar way we can also solve the right subtree (third outcome where (1234) > (5678)) in two more weighing.
We are able to solve the 12 coin puzzle in 3 weighing in the worst case.
Few Interesting Puzzles:
1. Solve Problem 4 with N = 8 and N = 13, How many minimum trials are required in each case?
2. Given a function int weigh(A[], B[]) where A and B are arrays (need not be equal size). The function
returns -1, 0 or 1. It returns 0 if sum of all elements in A and B are equal, -1 if A < B and 1 if A > B.
Given an array of 12 elements, all elements are equal except one. The odd element can be as that of
others, smaller or greater than others. Write a program to find the odd element (if any) using weigh()
minimum number of times.
3. You might have seen 3-pan balance in science labs during school days. Given a 3-pan balance (4
outcomes) and N coins, how many minimum trials are needed to figure out odd coin?
References:
Similar problem was provided in one of the exercises of the book “Introduction to Algorithms by Levitin”.
Specifically read section 5.5 and section 11.2 including exercises.
Question 1
#include<iostream>
class Test {
int value;
public:
Test(int v);
};
Test::Test(int v) {
value = v;
}
int main() {
Test t[100];
return 0;
}

Output: Compiler error
The class Test has one user defined constructor “Test(int v)” that expects one argument. It doesn’t have a
constructor without any argument as the compiler doesn’t create the default constructor if user defines a
constructor (See this). Following modified program works without any error.

#include<iostream>
class Test {
int value;
public:
Test(int v = 0);
};
Test::Test(int v) {
value = v;
}
int main() {
Test t[100];
return 0;
}

Question 2

#include<iostream>
int &fun() {
static int a = 10;
return a;
}
int main() {
int &y = fun();
y = y +30;
cout<<fun();
return 0;
}

Output: 40
The program works fine because ‘a’ is static. Since ‘a’ is static, memory location of it remains valid even after
fun() returns. So a reference to static variable can be returned.
Question 3
#include<iostream>
class Test
{
public:
Test();
};
Test::Test() {
cout<<"Constructor Called \n";
}
int main()
{
cout<<"Start \n";
Test t1();
cout<<"End \n";
return 0;
}

Output:
Start
End
Note that the line “Test t1();” is not a constructor call. Compiler considers this line as declaration of function
t1 that doesn’t recieve any parameter and returns object of type Test.
Question 1
#include<iostream>
class Test {
int value;
public:
Test (int v = 0) {value = v;}
int getValue() { return value; }
};
int main() {
const Test t;
cout << t.getValue();
return 0;
}

Output: Compiler Error.
A const object cannot call a non-const function. The above code can be fixed by either making getValue()
const or making t non-const. Following is modified program with getValue() as const, it works fine and
prints 0.
#include<iostream>
class Test {
int value;
public:
Test (int v = 0) { value = v; }
int getValue() const { return value; }
};
int main() {
const Test t;
return 0;
}

Question 2

#include<iostream>
class Test {
int &t;
public:
Test (int &x) { t = x; }
int getT() { return t; }
};
int main()
{
int x = 20;
Test t1(x);
cout << t1.getT() << " ";
x = 30;
cout << t1.getT() << endl;
return 0;
}


Since t is a reference in Test, it must be initialized using Initializer List. Following is the modified program.
It works and prints “20 30″.
#include<iostream>
class Test {
int &t;
public:
Test (int &x):t(x) { }
int getT() { return t; }
};
int main() {
int x = 20;
Test t1(x);
cout << t1.getT() << " ";
x = 30;
cout << t1.getT() << endl;
return 0;
}

Check if a binary tree is subtree of another binary tree | Set 1
Given two binary trees, check if the first tree is subtree of the second one. A subtree of a tree T is a tree S
consisting of a node in T and all of its descendants in T. The subtree corresponding to the root node is the
entire tree; the subtree corresponding to any other node is called a proper subtree.
For example, in the following case, tree S is a subtree of tree T.
Tree S
10
/ \
4 6
\
30
Tree T
26
/ \
10 3
/ \ \
4 6 3
\
30

Solution: Traverse the tree T in preorder fashion. For every visited node in the traversal, see if the subtree
rooted with this node is identical to S.
Following is C implementation for this.
#include <stdio.h>
#include <stdlib.h>
struct node
{
int data;
struct node* left;
struct node* right;
};
/* A utility function to check whether trees with roots as root1 and

root2 are identical or not */
bool areIdentical(struct node * root1, struct node *root2)
{
/* base cases */
if (root1 == NULL && root2 == NULL)
return true;
if (root1 == NULL || root2 == NULL)

return false;
return false;
/* Check if the data of both roots is same and data of left and right
subtrees are also same */
return (root1->data == root2->data &&
areIdentical(root1->left, root2->left) &&
areIdentical(root1->right, root2->right) );
}
/* This function returns true if S is a subtree of T, otherwise false */

bool isSubtree(struct node *T, struct node *S)
{
/* base cases */
if (S == NULL)
return true;
if (T == NULL)
return false;
/* Check the tree with root as current node */

if (areIdentical(T, S))
return true;
/* If the tree with root as current node doesn't match then

try left and right subtrees one by one */
return isSubtree(T->left, S) ||
isSubtree(T->right, S);
}
/* Helper function that allocates a new node with the given data
and NULL left and right pointers. */
{
struct node* node =
node->data = data;
node->left = NULL;
node->right = NULL;
return(node);
}

int main()
{
/* Construct the following tree
26
/ \
10 3
/ \ \
4 6 3
\
30
*/
struct node *T = newNode(26);
T->right = newNode(3);
T->right->right = newNode(3);
T->left = newNode(10);
T->left->left = newNode(4);
T->left->left->right = newNode(30);
T->left->right = newNode(6);
/* Construct the following tree

10
10
/ \
4 6
\
30
*/
struct node *S = newNode(10);
S->right = newNode(6);
S->left = newNode(4);
S->left->right = newNode(30);
if (isSubtree(T, S))
printf("Tree S is subtree of tree T");
else
printf("Tree S is not a subtree of tree T");
getchar();
return 0;
}

Output:
Tree S is subtree of tree T

Time Complexity: Time worst case complexity of above solution is O(mn) where m and n are number of
nodes in given two trees.
We can solve the above problem in O(n) time. Please refer Check if a binary tree is subtree of another binary
tree | Set 2 for O(n) solution.
discussed above.
Find the repeating and the missing | Added 3 new methods
Given an unsorted array of size n. Array elements are in range from 1 to n. One number from set {1, 2, …n} is
missing and one number occurs twice in array. Find these two numbers.
Examples:

arr[] = {3, 1, 3}
Output: 2, 3 // 2 is missing and 3 occurs twice
arr[] = {4, 3, 6, 2, 1, 1}
Output: 1, 5 // 5 is missing and 1 occurs twice


1) Sort the input array.
2) Traverse the array and check for missing and repeating.
Thanks to LoneShadow for suggesting this method.
Method 2 (Use count array)

1) Create a temp array temp[] of size n with all initial values as 0.
2) Traverse the input array arr[], and do following for each arr[i]
……a) if(temp[arr[i]] == 0) temp[arr[i]] = 1;
……b) if(temp[arr[i]] == 1) output “arr[i]” //repeating
3) Traverse temp[] and output the array element having value as 0 (This is the missing element)

Method 3 (Use elements as Index and mark the visited places)

Traverse the array. While traversing, use absolute value of every element as index and make the value at this
index as negative to mark it visited. If something is already marked negative then this is the repeating
element. To find missing, traverse the array again and look for a positive value.

#include<stdio.h>
#include<stdlib.h>
void printTwoElements(int arr[], int size)

{
int i;
printf("\n The repeating element is");

{
if(arr[abs(arr[i])-1] > 0)
arr[abs(arr[i])-1] = -arr[abs(arr[i])-1];
else
}
printf("\nand the missing element is ");

for(i=0; i<size; i++)
{
if(arr[i]>0)
printf("%d",i+1);
}
}

int main()
{
int arr[] = {7, 3, 4, 5, 5, 6, 2};
printTwoElements(arr, n);
return 0;
}

Thanks to Manish Mishra for suggesting this method.
Method 4 (Make two equations)

Let x be the missing and y be the repeating element.
1) Get sum of all numbers.

Sum of array computed S = n(n+1)/2 – x + y
2) Get product of all numbers.
Product of array computed P = 1*2*3*…*n * y / x
3) The above two steps give us two equations, we can solve the equations and get the values of x and y.
Thanks to disappearedng for suggesting this solution.
This method can cause arithmetic overflow as we calculate product and sum of all array elements. See
this
for changes suggested by john to reduce the chances of overflow.
Method 5 (Use XOR)

Let x and y be the desired output elements.
Calculate XOR of all the array elements.

xor1 = arr[0]ârr[1]ârr[2].....arr[n-1]

XOR the result with all numbers from 1 to n

xor1 = xor1^1^2^.....^n

In the result xor1, all elements would nullify each other except x and y. All the bits that are set in xor1 will be
set in either x or y. So if we take any set bit (We have chosen the rightmost set bit in code) of xor1 and divide
the elements of the array in two sets – one set of elements with same bit set and other set with same bit not
set. By doing so, we will get x in one set and y in another set. Now if we do XOR of all the elements in first
set, we will get x, and by doing same in other set we will get y.

#include <stdio.h>
#include <stdlib.h>
/* The output of this function is stored at *x and *y */

void getTwoElements(int arr[], int n, int *x, int *y)
{
int xor1; /* Will hold xor of all elements and numbers from 1 to n */
int set_bit_no; /* Will have only single set bit of xor1 */
int i;
*x = 0;
*y = 0;
xor1 = arr[0];
/* Get the xor of all array elements elements */

for(i = 1; i < n; i++)
xor1 = xor1ârr[i];
/* XOR the previous result with numbers from 1 to n*/

for(i = 1; i <= n; i++)
xor1 = xor1î;

set_bit_no = xor1 & ~(xor1-1);

bit of xor1 with bit at same position in each element. Also, get XORs
of two sets. The two XORs are the output elements.
The following two for loops serve the purpose */
for(i = 0; i < n; i++)
{
*x = *x ^ arr[i]; /* arr[i] belongs to first set */
else
*y = *y ^ arr[i]; /* arr[i] belongs to second set*/
}
for(i = 1; i <= n; i++)
{
if(i & set_bit_no)
*x = *x ^ i; /* i belongs to first set */
else
*y = *y ^ i; /* i belongs to second set*/
}
/* Now *x and *y hold the desired output elements */

}

int main()
{
int arr[] = {1, 3, 4, 5, 5, 6, 2};
int *x = (int *)malloc(sizeof(int));
int *y = (int *)malloc(sizeof(int));
getTwoElements(arr, n, x, y);
printf(" The two elements are %d and %d", *x, *y);
getchar();
}

This method doesn’t cause overflow, but it doesn’t tell which one occurs twice and which one is missing. We
can add one more step that checks which one is missing and which one is repeating. This can be easily done
in O(n) time.
same problem.
Print a given matrix in spiral form
Given a 2D array, print it in spiral form. See the following examples.
Input:
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 16
Output:
1 2 3 4 8 12 16 15 14 13 9 5 6 7 11 10
Input:
1 2 3 4 5 6
7 8 9 10 11 12
13 14 15 16 17 18
Output:
1 2 3 4 5 6 12 18 17 16 15 14 13 7 8 9 10 11

Solution:
/* This code is adopted from the solution given

@ http://effprog.blogspot.com/2011/01/spiral-printing-of-two-dimensional.html */
#include <stdio.h>
#define R 3
#define C 6
void spiralPrint(int m, int n, int a[R][C])

{
int i, k = 0, l = 0;
/* k - starting row index

m - ending row index
l - starting column index
n - ending column index
i - iterator
*/
while (k < m && l < n)

{
/* Print the first row from the remaining rows */
for (i = l; i < n; ++i)
{
printf("%d ", a[k][i]);
}
k++;
/* Print the last column from the remaining columns */

for (i = k; i < m; ++i)
{
printf("%d ", a[i][n-1]);
}
n--;
/* Print the last row from the remaining rows */

/* Print the last row from the remaining rows */
if ( k < m)
{
for (i = n-1; i >= l; --i)
{
printf("%d ", a[m-1][i]);
}
m--;
}
/* Print the first column from the remaining columns */

if (l < n)
{
for (i = m-1; i >= k; --i)
{
printf("%d ", a[i][l]);
}
l++;
}
}
}

int main()
{
int a[R][C] = { {1, 2, 3, 4, 5, 6},
{7, 8, 9, 10, 11, 12},
{13, 14, 15, 16, 17, 18}
};
spiralPrint(R, C, a);
return 0;
}
/* OUTPUT:
1 2 3 4 5 6 12 18 17 16 15 14 13 7 8 9 10 11
*/

Time Complexity: Time complexity of the above solution is O(mn).
Please write comments if you find the above code incorrect, or find other ways to solve the same problem.
Check if a number is multiple of 5 without using / and % operators
Given a positive number n, write a function isMultipleof5(int n) that returns true if n is multiple of 5,
otherwise false. You are not allowed to use % and / operators .
Method 1 (Repeatedly subtract 5 from n)

Run a loop and subtract 5 from n in the loop while n is greater than 0. After the loop terminates, check
whether n is 0. If n becomes 0 then n is multiple of 5, otherwise not.
#include<stdio.h>
/* assumes that n is a positive integer */

bool isMultipleof5 (int n)
{
while ( n > 0 )
n = n - 5;
if ( n == 0 )
return true;
return false;
}

int main()
{
int n = 19;
if ( isMultipleof5(n) == true )
printf("%d is multiple of 5\n", n);
else
printf("%d is not a multiple of 5\n", n);
return 0;
}

Method 2 (Convert to string and check the last character)

Convert n to a string and check the last character of the string. If the last character is ‘5’ or ‘0’ then n is
multiple of 5, otherwise not.

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
/* Assuming that integre takes 4 bytes, there can

be maximum 10 digits in a integer */
# define MAX 11
bool isMultipleof5(int n)
{
char str[MAX];
itoa(n, str, MAX);
/* Check the last character of string */

if ( str[len-1] == '5' || str[len-1] == '0' )
return true;
return false;
}

int main()
{
int n = 19;
if ( isMultipleof5(n) == true )
printf("%d is multiple of 5\n", n);
else
printf("%d is not a multiple of 5\n", n);
return 0;
}

Thanks to Baban_Rathore for suggesting this method.
Method 3 (Set last digit as 0 and use floating point trick)

A number n can be a mulpile of 5 in two cases. When last digit of n is 5 or 10. If last bit in binary equivalent
of n is set (which can be the case when last digit is 5) then we multiply by 2 using n #include<stdio.h> bool
isMultipleof5(int n) { /* If n is a multiple of 5 then we make sure that last digit of n is 0 */ if ( (n&1) == 1 ) n
<<= 1; float x = n; x = ( (int)(x*0.1) )*10; /* If last digit of n is 0 then n will be equal to (int)x */ if ( (int)x ==
n ) return true; return false; } /* Driver program to test above function */ int main() { int i = 19; if (
isMultipleof5(i) == true ) printf("%d is multiple of 5\n", i); else printf("%d is not a multiple of 5\n", i);
getchar(); return 0; }
Thanks to darkprince for suggesting this method.
Source: See this forum thread.
same problem.
Predict the output of following C++ programs.
Question 1
class Test1 {
int y;
};
class Test2 {
int x;
Test1 t1;
public:
operator Test1() { return t1; }
operator int() { return x; }
};
void fun ( int x) { };

void fun ( Test1 t ) { };
int main() {
Test2 t;
fun(t);
return 0;
}


There are two conversion operators defined in the Test2 class. So Test2 objects can automatically be
converted to both int and Test1. Therefore, the function call fun(t) is ambiguous as there are two functions
void fun(int ) and void fun(Test1 ), compiler has no way to decide which function to call. In general,
conversion operators must be overloaded carefully as they may lead to ambiguity.
Question 2
#include <iostream>
class X {
private:
static const int a = 76;
public:
static int getA() { return a; }
};
int main() {
cout <<X::getA()<<endl;
return 0;
}

Output: The program compiles and prints 76

Generally, it is not allowed to initialize data members in C++ class declaration, but static const integral
members are treated differently and can be initialized with declaration.
Memory Layout of C Programs
A typical memory representation of C program consists of following sections.
1. Text segment
2. Initialized data segment
3. Uninitialized data segment
4. Stack
5. Heap
A typical memory layout of a running process
1. Text Segment:
A text segment , also known as a code segment or simply as text, is one of the sections of a program in an
object file or in memory, which contains executable instructions.
As a memory region, a text segment may be placed below the heap or stack in order to prevent heaps and
stack overflows from overwriting it.
Usually, the text segment is sharable so that only a single copy needs to be in memory for frequently
executed programs, such as text editors, the C compiler, the shells, and so on. Also, the text segment is often
read-only, to prevent a program from accidentally modifying its instructions.
2. Initialized Data Segment:

Initialized data segment, usually called simply the Data Segment. A data segment is a portion of virtual
address space of a program, which contains the global variables and static variables that are initialized by
the programmer.
Note that, data segment is not read-only, since the values of the variables can be altered at run time.
This segment can be further classified into initialized read-only area and initialized read-write area.
For instance the global string defined by char s[] = “hello world” in C and a C statement like int debug=1
outside the main (i.e. global) would be stored in initialized read-write area. And a global C statement like
const char* string = “hello world” makes the string literal “hello world” to be stored in initialized read-only
area and the character pointer variable string in initialized read-write area.
Ex: static int i = 10 will be stored in data segment and global int i = 10 will also be stored in data segment
3. Uninitialized Data Segment:
Uninitialized data segment, often called the “bss” segment, named after an ancient assembler operator that
stood for “block started by symbol.” Data in this segment is initialized by the kernel to arithmetic 0 before
the program starts executing
uninitialized data starts at the end of the data segment and contains all global variables and static variables
that are initialized to zero or do not have explicit initialization in source code.
For instance a variable declared static int i; would be contained in the BSS segment.
For instance a global variable declared int j; would be contained in the BSS segment.
4. Stack:
The stack area traditionally adjoined the heap area and grew the opposite direction; when the stack pointer
met the heap pointer, free memory was exhausted. (With modern large address spaces and virtual memory
techniques they may be placed almost anywhere, but they still typically grow opposite directions.)
The stack area contains the program stack, a LIFO structure, typically located in the higher parts of memory.
On the standard PC x86 computer architecture it grows toward address zero; on some other architectures it
grows the opposite direction. A “stack pointer” register tracks the top of the stack; it is adjusted each time a
value is “pushed” onto the stack. The set of values pushed for one function call is termed a “stack frame”; A
stack frame consists at minimum of a return address.
Stack, where automatic variables are stored, along with information that is saved each time a function is
called. Each time a function is called, the address of where to return to and certain information about the
caller’s environment, such as some of the machine registers, are saved on the stack. The newly called
function then allocates room on the stack for its automatic and temporary variables. This is how recursive
functions in C can work. Each time a recursive function calls itself, a new stack frame is used, so one set of
variables doesn’t interfere with the variables from another instance of the function.
5. Heap:
Heap is the segment where dynamic memory allocation usually takes place.
The heap area begins at the end of the BSS segment and grows to larger addresses from there.The Heap area
is managed by malloc, realloc, and free, which may use the brk and sbrk system calls to adjust its size (note
that the use of brk/sbrk and a single “heap area” is not required to fulfill the contract of malloc/realloc/free;
they may also be implemented using mmap to reserve potentially non-contiguous regions of virtual memory
into the process’ virtual address space). The Heap area is shared by all shared libraries and dynamically
loaded modules in a process.
Examples.
The size(1) command reports the sizes (in bytes) of the text, data, and bss segments. ( for more details please
refer man page of size(1) )
1. Check the following simple C program
#include <stdio.h>
int main(void)
{
return 0;
}

[narendra@CentOS]$ gcc memory-layout.c -o memory-layout

[narendra@CentOS]$ size memory-layout
text data bss dec hex filename
960 248 8 1216 4c0 memory-layout

2. Let us add one global variable in program, now check the size of bss (highlighted in red color).
#include <stdio.h>
int global; /* Uninitialized variable stored in bss*/
int main(void)
{
return 0;
}


960 248 12 1220 4c4 memory-layout

3. Let us add one static variable which is also stored in bss.
#include <stdio.h>
int main(void)
{
static int i; /* Uninitialized static variable stored in bss */
return 0;
}


960 248 16 1224 4c8 memory-layout

4. Let us initialize the static variable which will then be stored in Data Segment (DS)

#include <stdio.h>
int main(void)
{
static int i = 100; /* Initialized static variable stored in DS*/
return 0;
}


960 252 12 1224 4c8 memory-layout

5. Let us initialize the global variable which will then be stored in Data Segment (DS)
#include <stdio.h>
int global = 10; /* initialized global variable stored in DS*/
int main(void)
{
static int i = 100; /* Initialized static variable stored in DS*/
return 0;
}


960 256 8 1224 4c8 memory-layout

This article is compiled by Narendra Kangralkar. Please write comments if you find anything incorrect,
or you want to share more information about the topic discussed above.
Source:
http://en.wikipedia.org/wiki/Data_segment
http://en.wikipedia.org/wiki/Code_segment
http://en.wikipedia.org/wiki/.bss
http://www.amazon.com/Advanced-Programming-UNIX-Environment-2nd/dp/0201433079
Design and Implement Special Stack Data Structure | Added Space
Optimized Version
Question: Design a Data Structure SpecialStack that supports all the stack operations like push(), pop(),
isEmpty(), isFull() and an additional operation getMin() which should return minimum element from the
SpecialStack. All these operations of SpecialStack must be O(1). To implement SpecialStack, you should only
use standard Stack data structure and no other data structure like arrays, list, .. etc.
Example:
Consider the following SpecialStack

16 --> TOP
15
29
19
18
When getMin() is called it should return 15, which is the minimum

element in the current stack.
If we do pop two times on stack, the stack becomes

29 --> TOP
19
18
When getMin() is called, it should return 18 which is the minimum

in the current stack.

Solution: Use two stacks: one to store actual stack elements and other as an auxiliary stack to store
minimum values. The idea is to do push() and pop() operations in such a way that the top of auxiliary stack
is always the minimum. Let us see how push() and pop() operations work.
Push(int x) // inserts an element x to Special Stack

1) push x to the first stack (the stack with actual elements)
2) compare x with the top element of the second stack (the auxiliary stack). Let the top element be y.
…..a) If x is smaller than y then push x to the auxiliary stack.
…..b) If x is greater than y then push y to the auxiliary stack.
int Pop() // removes an element from Special Stack and return the removed element
1) pop the top element from the auxiliary stack.
2) pop the top element from the actual stack and return it.
The step 1 is necessary to make sure that the auxiliary stack is also updated for future operations.
int getMin() // returns the minimum element from Special Stack

1) Return the top element of auxiliary stack.
We can see that all above operations are O(1) .

Let us see an example. Let us assume that both stacks are initially empty and 18, 19, 29, 15 and 16 are
inserted to the SpecialStack.
When we insert 18, both stacks change to following.

Actual Stack
Actual Stack
18
Following is C++ implementation for SpecialStack class. In the below implementation, Spe
cialStack inherits from Stack and has one Stack object min which work as auxiliary stack
.

#include<iostream>
#include<stdlib.h>
/* A simple stack class with basic stack funtionalities */

class Stack
{
private:
static const int max = 100;
int arr[max];
int top;
public:
Stack() { top = -1; }
bool isEmpty();
bool isFull();
int pop();
void push(int x);
};
/* Stack's member method to check if the stack is iempty */

bool Stack::isEmpty()
{
if(top == -1)
return true;
return false;
}
/* Stack's member method to check if the stack is full */

bool Stack::isFull()
{
if(top == max - 1)
return true;
return false;
}
/* Stack's member method to remove an element from it */

int Stack::pop()
{
if(isEmpty())
{
cout<<"Stack Underflow";
abort();
}
int x = arr[top];
top--;
return x;
}
/* Stack's member method to insert an element to it */

void Stack::push(int x)
{
if(isFull())
{
cout<<"Stack Overflow";
abort();
}
top++;
arr[top] = x;
}
/* A class that supports all the stack operations and one additional
operation getMin() that returns the minimum element from stack at
any time. This class inherits from the stack class and uses an
auxiliarry stack that holds minimum elements */
class SpecialStack: public Stack
{
Stack min;
public:
int pop();
void push(int x);
int getMin();
};
/* SpecialStack's member method to insert an element to it. This method

makes sure that the min stack is also updated with appropriate minimum
values */
void SpecialStack::push(int x)
{
if(isEmpty()==true)
{
Stack::push(x);
min.push(x);
}
else
{
Stack::push(x);
int y = min.pop();
min.push(y);
if( x < y )
min.push(x);
else
min.push(y);
}
}
/* SpecialStack's member method to remove an element from it. This method

removes top element from min stack also. */
int SpecialStack::pop()
{
int x = Stack::pop();
min.pop();
return x;
}
/* SpecialStack's member method to get minimum element from it. */

int SpecialStack::getMin()
{
int x = min.pop();
min.push(x);
return x;
}
/* Driver program to test SpecialStack methods */

int main()
{
SpecialStack s;
s.push(10);
s.push(20);
s.push(30);
s.push(30);
cout<<s.getMin()<<endl;
s.push(5);
cout<<s.getMin();
return 0;
}

Output:
10
Space Optimized Version
The above approach can be optimized. We can limit the number of elements in auxiliary st
ack. We can push only when the incoming element of main stack is smaller than or equal t
o top of auxiliary stack. Similarly during pop, if the pop off element equal to top of
auxiliary stack, remove the top element of auxiliary stack. Following is modified implem
entation of push() and pop().

/* SpecialStack's member method to insert an element to it. This method
makes sure that the min stack is also updated with appropriate minimum
values */
void SpecialStack::push(int x)
{
if(isEmpty()==true)
{
Stack::push(x);
min.push(x);
}
else
{
Stack::push(x);
int y = min.pop();
min.push(y);

/* push only when the incoming element of main stack is smaller
than or equal to top of auxiliary stack */
if( x <= y )
min.push(x);
}
}
/* SpecialStack's member method to remove an element from it. This method

removes top element from min stack also. */
int SpecialStack::pop()
{
int x = Stack::pop();
int y = min.pop();
/* Push the popped element y back only if it is not equal to x */

if ( y != x )
min.push(x);
return x;
}

Thanks to @Venki, @swarup and @Jing Huang for their inputs.
Please write comments if you find the above code incorrect, or find other ways to solve t
he same problem.

Question 1
#include<iostream>
class Test1
{
int x;
public:
void show() { }
};
class Test2
{
int x;
public:
virtual void show() { }
};
int main(void)
{
cout<<sizeof(Test1)<<endl;
cout<<sizeof(Test2)<<endl;
return 0;
}

Output:
4
8
There is only one difference between Test1 and Test2. show() is non-virtual in Test1, but virtual in Test2.
When we make a function virtual, compiler adds an extra pointer vptr to objects of the class. Compiler does
this to achieve run time polymorphism (See chapter 15 of Thinking in C++ book for more details). The extra
pointer vptr adds to the size of objects, that is why we get 8 as size of Test2.
Question 2

#include<iostream>
class P
{
public:
virtual void show() = 0;
};
class Q : public P {
int x;
};
int main(void)
{
Q q;
return 0;
}


We get the error because we can’t create objects of abstract classes. P is an abstract class as it has a pure
virtual method. Class Q also becomes abstract because it is derived from P and it doesn’t implement show().
Question 1
#include<stdio.h>
#define fun (x) (x)*10
int main()
{
int t = fun(5);
int i;
for(i = 0; i < t; i++)
printf("GeesforGeeks\n");
return 0;
}


There is an extra space in macro declaration which causes fun to be raplaced by (x). If we remove the extra
space then program works fine and prints “GeeksforGeeks” 50 times. Following is the working program.
#include<stdio.h>
#define fun(x) (x)*10
int main()
{
int t = fun(5);
int i;
for(i = 0; i < t; i++)
printf("GeesforGeeks\n");
return 0;
}

Be careful when dealing with macros. Extra spaces may lead to problems.
Question 2

#include<stdio.h>
int main()
{
int i = 20,j;
i = (printf("Hello"), printf(" All Geeks "));
printf("%d", i);
return 0;
}

Output: Hello All Geeks 11

The printf() function returns the number of characters it has successfully printed. The comma operator
evaluates it operands from left to right and returns the value returned by the rightmost expression (See this
for more details). First printf(“Hello”) executes and prints “Hello”, the printf(” All Geeks “) executes and
prints ” All Geeks “. This printf statement returns 11 which is assigned to i.
Backtracking | Set 4 (Subset Sum)
Subset sum problem is to find subset of elements that are selected from a given set whose sum adds up to a
given number K. We are considering the set contains non-negative values. It is assumed that the input set is
unique (no duplicates are presented).
Exhaustive Search Algorithm for Subset Sum
One way to find subsets that sum to K is to consider all possible subsets. A
power set contains all those
N
subsets generated from a given set. The size of such a power set is 2 .
Backtracking Algorithm for Subset Sum
Using exhaustive search we consider all subsets irrespective of whether they satisfy given constraints or not.
Backtracking can be used to make a systematic consideration of the elements to be selected.
Assume given set of 4 elements, say w[1] … w[4]. Tree diagrams can be used to design backtracking
algorithms. The following tree diagram depicts approach of generating variable sized tuple.
In the above tree, a node represents function call and a branch represents candidate element. The root node
contains 4 children. In other words, root considers every element of the set as different branch. The next
level sub-trees correspond to the subsets that includes the parent node. The branches at each level represent
tuple element to be considered. For example, if we are at level 1, tuple_vector[1] can take any value of four
branches generated. If we are at level 2 of left most node, tuple_vector[2] can take any value of three
branches generated, and so on…
For example the left most child of root generates all those subsets that include w[1]. Similarly the second
child of root generates all those subsets that includes w[2] and excludes w[1].
As we go down along depth of tree we add elements so far, and if the added sum is satisfying explicit
constraints, we will continue to generate child nodes further. Whenever the constraints are not met, we stop
further generation of sub-trees of that node, and backtrack to previous node to explore the nodes not yet
explored. In many scenarios, it saves considerable amount of processing time.
The tree should trigger a clue to implement the backtracking algorithm (try yourself). It prints all those
subsets whose sum add up to given number. We need to explore the nodes along the breadth and depth of
the tree. Generating nodes along breadth is controlled by loop and nodes along the depth are generated
using recursion (post order traversal). Pseudo code given below,

if(subset is satisfying the constraint)
print the subset
exclude the current element and consider next element
else
generate the nodes of present level along breadth of tree and
recur for next levels

Following is C implementation of subset sum using variable size tuple vector. Note that the following
program explores all possibilities similar to exhaustive search. It is to demonstrate how backtracking can be
used. See next code to verify, how we can optimize the backtracking solution.
#include <stdio.h>
#include <stdlib.h>
#define ARRAYSIZE(a) (sizeof(a))/(sizeof(a[0]))
static int total_nodes;

// prints subset found
void printSubset(int A[], int size)
{
for(int i = 0; i < size; i++)
{
printf("%*d", 5, A[i]);
}
printf("\n");
}
// inputs
// s - set vector
// t - tuplet vector
// s_size - set size
// t_size - tuplet size so far
// sum - sum so far
// ite - nodes count
// target_sum - sum to be found
void subset_sum(int s[], int t[],
int s_size, int t_size,
int sum, int ite,
int const target_sum)
{
total_nodes++;
if( target_sum == sum )
{
// We found subset
printSubset(t, t_size);
// Exclude previously added item and consider next candidate
subset_sum(s, t, s_size, t_size-1, sum - s[ite], ite + 1, target_sum);
return;
}
else
{
// generate nodes along the breadth
for( int i = ite; i < s_size; i++ )
{
t[t_size] = s[i];
t[t_size] = s[i];
// consider next level node (along depth)
subset_sum(s, t, s_size, t_size + 1, sum + s[i], i + 1, target_sum);
}
}
}
// Wrapper to print subsets that sum to target_sum

// input is weights vector and target_sum
void generateSubsets(int s[], int size, int target_sum)
{
int *tuplet_vector = (int *)malloc(size * sizeof(int));
subset_sum(s, tuplet_vector, size, 0, 0, 0, target_sum);
free(tuplet_vector);
}
int main()
{
int weights[] = {10, 7, 5, 18, 12, 20, 15};
int size = ARRAYSIZE(weights);
generateSubsets(weights, size, 35);

printf("Nodes generated %d\n", total_nodes);
return 0;
}

The power of backtracking appears when we combine explicit and implicit constraints, and we stop
generating nodes when these checks fail. We can improve the above algorithm by strengthening the
constraint checks and presorting the data. By sorting the initial array, we need not to consider rest of the
array, once the sum so far is greater than target number. We can backtrack and check other possibilities.
Similarly, assume the array is presorted and we found one subset. We can generate next node excluding the
present node only when inclusion of next node satisfies the constraints. Given below is optimized
implementation (it prunes the subtree if it is not satisfying contraints).
#include <stdio.h>
#include <stdlib.h>
#define ARRAYSIZE(a) (sizeof(a))/(sizeof(a[0]))
static int total_nodes;
// prints subset found

void printSubset(int A[], int size)
{
{
printf("%*d", 5, A[i]);
}
printf("\n");
}
// qsort compare function

int comparator(const void *pLhs, const void *pRhs)
{
int *lhs = (int *)pLhs;
int *lhs = (int *)pLhs;
int *rhs = (int *)pRhs;
return *lhs > *rhs;

}
// inputs
// s - set vector
// t - tuplet vector
// s_size - set size
// t_size - tuplet size so far
// sum - sum so far
// ite - nodes count
// target_sum - sum to be found
void subset_sum(int s[], int t[],
int s_size, int t_size,
int sum, int ite,
int const target_sum)
{
total_nodes++;
if( target_sum == sum )

{
// We found sum
printSubset(t, t_size);
// constraint check
if( ite + 1 < s_size && sum - s[ite] + s[ite+1] <= target_sum )
{
// Exclude previous added item and consider next candidate
subset_sum(s, t, s_size, t_size-1, sum - s[ite], ite + 1, target_sum);
}
return;
}
else
{
// constraint check
if( ite < s_size && sum + s[ite] <= target_sum )
{
// generate nodes along the breadth
for( int i = ite; i < s_size; i++ )
{
t[t_size] = s[i];
if( sum + s[i] <= target_sum )

{
// consider next level node (along depth)
subset_sum(s, t, s_size, t_size + 1, sum + s[i], i + 1, target_sum);
}
}
}
}
}
// Wrapper that prints subsets that sum to target_sum

void generateSubsets(int s[], int size, int target_sum)
{
int *tuplet_vector = (int *)malloc(size * sizeof(int));
int total = 0;
// sort the set

qsort(s, size, sizeof(int), &comparator);
for( int i = 0; i < size; i++ )

for( int i = 0; i < size; i++ )
{
total += s[i];
}
if( s[0] <= target_sum && total >= target_sum )

{
subset_sum(s, tuplet_vector, size, 0, 0, 0, target_sum);
free(tuplet_vector);
}
int main()
{
int weights[] = {15, 22, 14, 26, 32, 9, 16, 8};
int target = 53;
int size = ARRAYSIZE(weights);
generateSubsets(weights, size, target);
printf("Nodes generated %d\n", total_nodes);
return 0;
}

As another approach, we can generate the tree in fixed size tuple analogs to binary pattern. We will kill
the sub-trees when the constraints are not satisfied.
– – – Venki. Please write comments if you find anything incorrect, or you want to share more information
Trie | (Insert and Search)
Trie is an efficient information retrieval data structure. Using trie, search complexities can be brought to
optimal limit (key length). If we store keys in binary search tree, a well balanced BST will need
time proportional to M * log N , where M is maximum string length and N is number of keys in tree. Using
trie, we can search the key in O(M) time. However the penalty is on trie storage requirements.
Every node of trie consists of multiple branches. Each branch represents a possible character of keys. We
need to mark the last node of every key as leaf node. A trie node field value will be used to distinguish the
node as leaf node (there are other uses of the value field). A simple structure to represent nodes of English
alphabet can be as following,
struct trie_node
int value; /* Used to mark leaf nodes */
trie_node_t *children[ALPHABET_SIZE];
};
Inserting a key into trie is simple approach. Every character of input key is inserted as an individual trie
node. Note that the children is an array of pointers to next level trie nodes. The key character acts as an
index into the array children. If the input key is new or an extension of existing key, we need to construct
non-existing nodes of the key, and mark leaf node. If the input key is prefix of existing key in trie, we simply
mark the last node of key as leaf. The key length determines trie depth.
Searching for a key is similar to insert operation, however we only compare the characters and move down.
The search can terminate due to end of string or lack of key in trie. In the former case, if the value field of last
node is non-zero then the key exists in trie. In the second case, the search terminates without examining all
the characters of key, since the key is not present in trie.
The following picture explains construction of trie using keys given in the example below,

root
/ \ \
t a b
| | |
h n y
| | \ |
e s y e
/ | |
i r w
| | |
r e e
|
r

In the picture, every character is of type trie_node_t. For example, the root is of type trie_node_t, and it’s
children a, b and t are filled, all other nodes of root will be NULL. Similarly, “a” at the next level is having
only one child (“n”), all other children are NULL. The leaf nodes are in blue.
Insert and search costs O(key_length), however the memory requirements of trie is
O(ALPHABET_SIZE * key_length * N) where N is number of keys in trie. There are efficient
representation of trie nodes (e.g. compressed trie, ternary search tree, etc.) to minimize memory
requirements of trie.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define ARRAY_SIZE(a) sizeof(a)/sizeof(a[0])
// Alphabet size (# of symbols)

#define ALPHABET_SIZE (26)
// Converts key current character into index
// use only 'a' through 'z' and lower case
#define CHAR_TO_INDEX(c) ((int)c - (int)'a')
// trie node
typedef struct trie_node trie_node_t;
struct trie_node
{
int value;
};
// trie ADT
typedef struct trie trie_t;
struct trie
{
trie_node_t *root;
int count;
};
// Returns new trie node (initialized to NULLs)

trie_node_t *getNode(void)
{
trie_node_t *pNode = NULL;
pNode = (trie_node_t *)malloc(sizeof(trie_node_t));
if( pNode )
{
int i;
pNode->value = 0;
for(i = 0; i < ALPHABET_SIZE; i++)

{
pNode->children[i] = NULL;
}
}
return pNode;
}
// Initializes trie (root is dummy node)

void initialize(trie_t *pTrie)
{
pTrie->root = getNode();
pTrie->count = 0;
}
// If not present, inserts key into trie

// If the key is prefix of trie node, just marks leaf node
void insert(trie_t *pTrie, char key[])
{
int level;
int length = strlen(key);
int index;
trie_node_t *pCrawl;
pTrie->count++;
pCrawl = pTrie->root;
for( level = 0; level < length; level++ )

{
index = CHAR_TO_INDEX(key[level]);
if( !pCrawl->children[index] )
{
pCrawl->children[index] = getNode();
}
pCrawl = pCrawl->children[index];
}
// mark last node as leaf

pCrawl->value = pTrie->count;
}
// Returns non zero, if key presents in trie

int search(trie_t *pTrie, char key[])
{
int level;
int index;

{
index = CHAR_TO_INDEX(key[level]);
{
return 0;
}
}
return (0 != pCrawl && pCrawl->value);

}
// Driver
int main()
{
// Input keys (use only 'a' through 'z' and lower case)
char keys[][8] = {"the", "a", "there", "answer", "any", "by", "bye", "their"};
trie_t trie;
char output[][32] = {"Not present in trie", "Present in trie"};
initialize(&trie);
// Construct trie
for(int i = 0; i < ARRAY_SIZE(keys); i++)
{
insert(&trie, keys[i]);
}
// Search for different keys

printf("%s --- %s\n", "the", output[search(&trie, "the")] );
printf("%s --- %s\n", "these", output[search(&trie, "these")] );
printf("%s --- %s\n", "their", output[search(&trie, "their")] );
printf("%s --- %s\n", "thaw", output[search(&trie, "thaw")] );
return 0;
}

Question 1
#include<stdio.h>
int main()
{
enum channel {star, sony, zee};
enum symbol {hash, star};
int i = 0;
for(i = star; i <= zee; i++)
{
printf("%d ", i);
}
return 0;
}

Output:
compiler error: redeclaration of enumerator 'star'

In the above program, enumartion constant ‘star’ appears two times in main() which causes the error. An
enumaration constant must be unique within the scope in which it is defined. The following program works
fine and prints 0 1 2 as the enumaration constants automatically get the values starting from 0.
#include<stdio.h>
int main()
{
enum channel {star, sony, zee};
int i = 0;
for(i = star; i <= zee; i++)
{
printf("%d ", i);
}
return 0;
}

Output:

0 1 2

Question 2
#include<stdio.h>
int main()
{
int i, j;
int p = 0, q = 2;
for(i = 0, j = 0; i < p, j < q; i++, j++)

{
printf("GeeksforGeeks\n");
}
return 0;
}

Output:
GeeksforGeeks
GeeksforGeeks

Following is the main expression to consider in the above program.
i < p, j < q

When two expressions are separated by comma operator, the first expression (i this for more details.
A Boolean Matrix Question
Given a boolean matrix mat[M][N] of size M X N, modify it such that if a matrix cell mat[i][j] is 1 (or true)
then make all the cells of ith row and jth column as 1.
Example 1
The matrix
1 0
0 0
should be changed to following
1 1
1 0
Example 2
The matrix
0 0 0
0 0 1
0 0 1
1 1 1
Example 3
The matrix
1 0 0 1
0 0 1 0
0 0 0 0
1 1 1 1
1 1 1 1
1 0 1 1

Method 1 (Use two temporary arrays)

1) Create two temporary arrays row[M] and col[N]. Initialize all values of row[] and col[] as 0.
2) Traverse the input matrix mat[M][N]. If you see an entry mat[i][j] as true, then mark row[i] and col[j] as
true.
3) Traverse the input matrix mat[M][N] again. For each entry mat[i][j], check the values of row[i] and col[j].
If any of the two values (row[i] or col[j]) is true, then mark mat[i][j] as true.
Thanks to Dixit Sethi for suggesting this method.
#include <stdio.h>
#define R 3
#define C 4
void modifyMatrix(bool mat[R][C])

{
bool row[R];
bool col[C];
int i, j;
/* Initialize all values of row[] as 0 */

for (i = 0; i < R; i++)
{
row[i] = 0;
}
/* Initialize all values of col[] as 0 */

for (i = 0; i < C; i++)
{
col[i] = 0;
}
/* Store the rows and columns to be marked as 1 in row[] and col[]

arrays respectively */
for (i = 0; i < R; i++)
{
for (j = 0; j < C; j++)
{
if (mat[i][j] == 1)
{
row[i] = 1;
col[j] = 1;
}
}
}
/* Modify the input matrix mat[] using the above constructed row[] and
col[] arrays */
for (i = 0; i < R; i++)
{
for (j = 0; j < C; j++)
{
if ( row[i] == 1 || col[j] == 1 )
{
mat[i][j] = 1;
}
}
}
}
/* A utility function to print a 2D matrix */

void printMatrix(bool mat[R][C])
{
int i, j;
for (i = 0; i < R; i++)
{
for (j = 0; j < C; j++)
{
printf("%d ", mat[i][j]);
}
printf("\n");
}
}

int main()
{
bool mat[R][C] = { {1, 0, 0, 1},
{0, 0, 1, 0},
{0, 0, 0, 0},
};
printf("Input Matrix \n");

printMatrix(mat);
modifyMatrix(mat);
printf("Matrix after modification \n");

printMatrix(mat);
return 0;
}

Output:
Input Matrix
1 0 0 1
0 0 1 0
0 0 0 0
Matrix after modification
1 1 1 1
1 1 1 1
1 0 1 1

Time Complexity: O(M*N)

Auxiliary Space: O(M + N)
Method 2 (A Space Optimized Version of Method 1)

This method is a space optimized version of above method 1. This method uses the first row and first column
of the input matrix in place of the auxiliary arrays row[] and col[] of method 1. So what we do is: first take
care of first row and column and store the info about these two in two flag variables rowFlag and colFlag.
Once we have this info, we can use first row and first column as auxiliary arrays and apply method 1 for
submatrix (matrix excluding first row and first column) of size (M-1)*(N-1).
1) Scan the first row and set a variable rowFlag to indicate whether we need to set all 1s in first row or not.
2) Scan the first column and set a variable colFlag to indicate whether we need to set all 1s in first column or
not.
3) Use first row and first column as the auxiliary arrays row[] and col[] respectively, consider the matrix as
submatrix starting from second row and second column and apply method 1.
4) Finally, using rowFlag and colFlag, update first row and first column if needed.
Time Complexity: O(M*N)

Thanks to Sidh for suggesting this method.
same problem.
Question 1
template <class S, class T> class Pair

{
private:
S x;
T y;
/* ... */
};
template <class S> class Element

{
private:
S x;
/* ... */
};
int main ()
{
Pair <Element<int>, Element<char>> p;
return 0;
}
Output:
Compiler Error: '>>' should be '> >' within a nested template argument list

When we use nested templates in our program, we must put a space between two closing angular brackets,
otherwise it conflicts with operator >>. For example, following program compiles fine.

template <class S, class T> class Pair

{
private:
S x;
T y;
/* ... */
};
template <class S> class Element

{
private:
S x;
/* ... */
};
int main ()
{
Pair <Element<int>, Element<char> > p; // note the space between '>' and '>'
return 0;
}

Question 2
#include<iostream>
class Test
{
private:
static int count;
public:
static Test& fun();
};
int Test::count = 0;
Test& Test::fun()
{
Test::count++;
cout<<Test::count<<" ";
return *this;
}
int main()
{
Test t;
t.fun().fun().fun().fun();
return 0;
}

Output:

Compiler Error: 'this' is unavailable for static member functions

this pointer is not available to static member methods in C++, as static methods can be called using class
name also. Similarly in Java, static member methods cannot access this and super (super is for base or
parent class).
If we make fun() non-static in the above program, then the program works fine.
#include<iostream>
class Test
{
private:
static int count;
public:
Test& fun(); // fun() is non-static now
};
Test& Test::fun()
{
Test::count++;
cout<<Test::count<<" ";
return *this;
}
int main()
{
Test t;
t.fun().fun().fun().fun();
return 0;
}

Output:
Output:
1 2 3 4

Please write comments if you find any of the answers/explanations incorrect, or want to share more
Question 1
Consider the following recursive C function. Let len be the length of the string s and num be the number of
characters printed on the screen, give the relation between num and len where len is always greater than 0.
void abc(char *s)

{
if(s[0] == '\0')
return;
abc(s + 1);
abc(s + 1);
printf("%c", s[0]);
}

Following is the relation between num and len.

num = 2^len-1

s[0] is 1 time printed

s[1] is 2 times printed
s[2] is 4 times printed
s[i] is printed 2î times
s[strlen(s)-1] is printed 2^(strlen(s)-1) times
total = 1+2+....+2^(strlen(s)-1)
= (2^strlen(s)) - 1

For example, the following program prints 7 characters.

#include<stdio.h>
void abc(char *s)

{
if(s[0] == '\0')
return;
abc(s + 1);
abc(s + 1);
printf("%c", s[0]);
}
int main()
{
abc("xyz");
return 0;
}

Thanks to bharat nag for suggesting this solution.
Question 2
#include<stdio.h>
int fun(int count)
{
printf("%d\n", count);
if(count < 3)
{
fun(fun(fun(++count)));
}
return count;
}
int main()
{
fun(1);
return 0;
}

Output:
1
2
3
3
3
3
3

The main() function calls fun(1). fun(1) prints “1” and calls fun(fun(fun(2))). fun(2) prints “2” and calls
fun(fun(fun(3))). So the function call sequence becomes fun(fun(fun(fun(fun(3))))). fun(3) prints “3” and
returns 3 (note that count is not incremented and no more functions are called as the if condition is not true
for count 3). So the function call sequence reduces to fun(fun(fun(fun(3)))). fun(3) again prints “3” and
returns 3. So the function call again reduces to fun(fun(fun(3))) which again prints “3” and reduces to
fun(fun(3)). This continues and we get “3” printed 5 times on the screen.
Median in a stream of integers (running integers)
Given that integers are read from a data stream. Find median of elements read so for in efficient way. For
simplicity assume there are no duplicates. For example, let us consider the stream 5, 15, 1, 3 …

After reading 1st element of stream - 5 -> median - 5
After reading 2nd element of stream - 5, 15 -> median - 10
After reading 3rd element of stream - 5, 15, 1 -> median - 5
After reading 4th element of stream - 5, 15, 1, 3 -> median - 4, so on...

Making it clear, when the input size is odd, we take the middle element of sorted data. If the input size is
even, we pick average of middle two elements in sorted stream.
Note that output is effective median of integers read from the stream so far. Such an algorithm is called
online algorithm. Any algorithm that can guarantee output of i-elements after processing i-th element, is
said to be online algorithm. Let us discuss three solutions for the above problem.
Method 1: Insertion Sort
If we can sort the data as it appears, we can easily locate median element. Insertion Sort is one such online
algorithm that sorts the data appeared so far. At any instance of sorting, say after sorting i-th element, the
first i elements of array are sorted. The insertion sort doesn’t depend on future data to sort data input till
that point. In other words, insertion sort considers data sorted so far while inserting next element. This is
the key part of insertion sort that makes it an online algorithm.
However, insertion sort takes O(n2) time to sort n elements. Perhaps we can use binary search on insertion
sort to find location of next element in O(log n) time. Yet, we can’t do data movement in O(log n) time. No
matter how efficient the implementation is, it takes polynomial time in case of insertion sort.
Interested reader can try implementation of Method 1.
Method 2: Augmented self balanced binary search tree (AVL, RB, etc…)
At every node of BST, maintain number of elements in the subtree rooted at that node. We can use a node as
root of simple binary tree, whose left child is self balancing BST with elements less than root and right child
is self balancing BST with elements greater than root. The root element always holds effective median.
If left and right subtrees contain same number of elements, root node holds average of left and right subtree
root data. Otherwise, root contains same data as the root of subtree which is having more elements. After
processing an incoming element, the left and right subtrees (BST) are differed utmost by 1.
Self balancing BST is costly in managing balancing factor of BST. However, they provide sorted data which
we don’t need. We need median only. The next method make use of Heaps to trace median.
Method 3: Heaps
Similar to balancing BST in Method 2 above, we can use a max heap on left side to represent elements that
are less than effective median, and a min heap on right side to represent elements that are greater than
effective median.
After processing an incoming element, the number of elements in heaps differ utmost by 1 element. When
both heaps contain same number of elements, we pick average of heaps root data as effective median. When
the heaps are not balanced, we select effective median from the root of heap containing more elements.
Given below is implementation of above method. For algorithm to build these heaps, please read the
highlighted code.

#include <iostream>
// Heap capacity
#define MAX_HEAP_SIZE (128)
//// Utility functions
// exchange a and b
inline
void Exch(int &a, int &b)
{
int aux = a;
a = b;
b = aux;
}
// Greater and Smaller are used as comparators

bool Greater(int a, int b)
{
return a > b;
}
bool Smaller(int a, int b)

{
return a < b;
}
int Average(int a, int b)

{
return (a + b) / 2;
}
// Signum function
// = 0 if a == b - heaps are balanced
// = -1 if a < b - left contains less elements than right
// = 1 if a > b - left contains more elements than right
int Signum(int a, int b)
{
if( a == b )
return 0;
return a < b ? -1 : 1;
}
// Heap implementation
// The functionality is embedded into
// Heap abstract class to avoid code duplication
class Heap
{
public:
// Initializes heap array and comparator required
// in heapification
Heap(int *b, bool (*c)(int, int)) : A(b), comp(c)
{
heapSize = -1;
}
// Frees up dynamic memory

virtual ~Heap()
{
{
if( A )
{
delete[] A;
}
}
// We need only these four interfaces of Heap ADT

virtual bool Insert(int e) = 0;
virtual int GetTop() = 0;
virtual int ExtractTop() = 0;
virtual int GetCount() = 0;
protected:
// We are also using location 0 of array

int left(int i)
{
return 2 * i + 1;
}
int right(int i)
{
return 2 * (i + 1);
}
int parent(int i)
{
if( i <= 0 )
{
return -1;
}
return (i - 1)/2;
}
// Heap array
int *A;
// Comparator
bool (*comp)(int, int);
// Heap size
int heapSize;
// Returns top element of heap data structure

int top(void)
{
int max = -1;
if( heapSize >= 0 )

{
max = A[0];
}
return max;
}
// Returns number of elements in heap

int count()
{
return heapSize + 1;
}
// Heapification
// Note that, for the current median tracing problem
// we need to heapify only towards root, always
void heapify(int i)
{
int p = parent(i);
// comp - differentiate MaxHeap and MinHeap

// percolates up
if( p >= 0 && comp(A[i], A[p]) )
{
Exch(A[i], A[p]);
heapify(p);
}
}
// Deletes root of heap

int deleteTop()
{
int del = -1;
if( heapSize > -1)

{
del = A[0];
Exch(A[0], A[heapSize]);
heapSize--;
heapify(parent(heapSize+1));
}
return del;
}
// Helper to insert key into Heap

bool insertHelper(int key)
{
bool ret = false;
if( heapSize < MAX_HEAP_SIZE )

{
ret = true;
heapSize++;
A[heapSize] = key;
heapify(heapSize);
}
return ret;
}
};
// Specilization of Heap to define MaxHeap

class MaxHeap : public Heap
{
private:
public:
MaxHeap() : Heap(new int[MAX_HEAP_SIZE], &Greater) { }
~MaxHeap() { }
// Wrapper to return root of Max Heap

int GetTop()
{
return top();
}
// Wrapper to delete and return root of Max Heap
int ExtractTop()
{
return deleteTop();
}
// Wrapper to return # elements of Max Heap

int GetCount()
{
return count();
}
// Wrapper to insert into Max Heap

bool Insert(int key)
{
return insertHelper(key);
}
};
// Specilization of Heap to define MinHeap

class MinHeap : public Heap
{
private:
public:
MinHeap() : Heap(new int[MAX_HEAP_SIZE], &Smaller) { }
~MinHeap() { }
// Wrapper to return root of Min Heap

int GetTop()
{
return top();
}
// Wrapper to delete and return root of Min Heap

int ExtractTop()
{
return deleteTop();
}
// Wrapper to return # elements of Min Heap

int GetCount()
{
return count();
}
// Wrapper to insert into Min Heap

bool Insert(int key)
{
return insertHelper(key);
}
};
// Function implementing algorithm to find median so far.

int getMedian(int e, int &m, Heap &l, Heap &r)
{
// Are heaps balanced? If yes, sig will be 0
int sig = Signum(l.GetCount(), r.GetCount());
switch(sig)
{
case 1: // There are more elements in left (max) heap
if( e < m ) // current element fits in left (max) heap
{
// Remore top element from left heap and
// insert into right heap
r.Insert(l.ExtractTop());
// current element fits in left (max) heap

l.Insert(e);
}
else
{
// current element fits in right (min) heap
r.Insert(e);
}
// Both heaps are balanced

m = Average(l.GetTop(), r.GetTop());
break;
case 0: // The left and right heaps contain same number of elements

{
l.Insert(e);
m = l.GetTop();
}
else
{
r.Insert(e);
m = r.GetTop();
}
break;
case -1: // There are more elements in right (min) heap

{
l.Insert(e);
}
else
{
// Remove top element from right heap and
// insert into left heap
l.Insert(r.ExtractTop());

r.Insert(e);
}
// Both heaps are balanced

m = Average(l.GetTop(), r.GetTop());
break;
}
// No need to return, m already updated

return m;
}
void printMedian(int A[], int size)

{
{
int m = 0; // effective median
Heap *left = new MaxHeap();
Heap *right = new MinHeap();

{
m = getMedian(A[i], m, *left, *right);
cout << m << endl;

}
// C++ more flexible, ensure no leaks

delete left;
delete right;
}
// Driver code
int main()
{
int A[] = {5, 15, 1, 3, 2, 8, 7, 9, 10, 6, 11, 4};
int size = ARRAY_SIZE(A);
// In lieu of A, we can also use data read from a stream

printMedian(A, size);
return 0;
}

Time Complexity: If we omit the way how stream was read, complexity of median finding is O(N log N),
as we need to read the stream, and due to heap insertions/deletions.
At first glance the above code may look complex. If you read the code carefully, it is simple algorithm.
Dynamic Programming | Set 6 (Min Cost Path)
Given a cost matrix cost[][] and a position (m, n) in cost[][], write a function that returns cost of minimum
cost path to reach (m, n) from (0, 0). Each cell of the matrix represents a cost to traverse through that cell.
Total cost of a path to reach (m, n) is sum of all the costs on that path (including both source and
destination). You can only traverse down, right and diagonally lower cells from a given cell, i.e., from a given
cell (i, j), cells (i+1, j), (i, j+1) and (i+1, j+1) can be traversed. You may assume that all costs are positive
integers.
For example, in the following figure, what is the minimum cost path to (2, 2)?
The path with minimum cost is highlighted in the following figure. The path is (0, 0) –> (0, 1) –> (1, 2) –>
(2, 2). The cost of the path is 8 (1 + 2 + 2 + 3).
The path to reach (m, n) must be through one of the 3 cells: (m-1, n-1) or (m-1, n) or (m, n-1). So minimum
cost to reach (m, n) can be written as “minimum of the 3 cells plus cost[m][n]”.
minCost(m, n) = min (minCost(m-1, n-1), minCost(m-1, n), minCost(m, n-1)) + cost[m][n]
Following is simple recursive implementation of the MCP (Minimum Cost Path) problem. The
implementation simply follows the recursive structure mentioned above.

/* A Naive recursive implementation of MCP(Minimum Cost Path) problem */

#include<stdio.h>
#include<limits.h>
#define R 3
#define C 3
int min(int x, int y, int z);
/* Returns cost of minimum cost path from (0,0) to (m, n) in mat[R][C]*/

int minCost(int cost[R][C], int m, int n)
{
if (n < 0 || m < 0)
return INT_MAX;
else if (m == 0 && n == 0)
return cost[m][n];
else
return cost[m][n] + min( minCost(cost, m-1, n-1),
minCost(cost, m-1, n),
minCost(cost, m, n-1) );
}
/* A utility function that returns minimum of 3 integers */

int min(int x, int y, int z)
{
if (x < y)
return (x < z)? x : z;
else
return (y < z)? y : z;
}

int main()
{
int cost[R][C] = { {1, 2, 3},
{4, 8, 2},
{1, 5, 3} };
printf(" %d ", minCost(cost, 2, 2));
return 0;
}

It should be noted that the above function computes the same subproblems again and again. See the
following recursion tree, there are many nodes which apear more than once. Time complexity of this naive
recursive solution is exponential and it is terribly slow.
mC refers to minCost()
mC(2, 2)
/ | \
/ | \
mC(1, 1) mC(1, 2) mC(2, 1)
/ | \ / | \ / | \
/ | \ / | \ / | \
mC(0,0) mC(0,1) mC(1,0) mC(0,1) mC(0,2) mC(1,1) mC(1,0) mC(1,1) mC(2,0)

So the MCP problem has both properties (see this and this) of a dynamic programming problem. Like other
typical Dynamic Programming(DP) problems, recomputations of same subproblems can be avoided by
constructing a temporary array tc[][] in bottom up manner.
/* Dynamic Programming implementation of MCP problem */

#include<stdio.h>
#include<limits.h>
#define R 3
#define C 3
int min(int x, int y, int z);
int minCost(int cost[R][C], int m, int n)

{
int i, j;
// Instead of following line, we can use int tc[m+1][n+1] or

// dynamically allocate memoery to save space. The following line is
// used to keep te program simple and make it working on all compilers.
int tc[R][C];
tc[0][0] = cost[0][0];
/* Initialize first column of total cost(tc) array */

for (i = 1; i <= m; i++)
tc[i][0] = tc[i-1][0] + cost[i][0];
/* Initialize first row of tc array */

for (j = 1; j <= n; j++)
tc[0][j] = tc[0][j-1] + cost[0][j];
/* Construct rest of the tc array */

for (i = 1; i <= m; i++)
for (j = 1; j <= n; j++)
tc[i][j] = min(tc[i-1][j-1], tc[i-1][j], tc[i][j-1]) + cost[i][j];
return tc[m][n];
}
/* A utility function that returns minimum of 3 integers */

{
if (x < y)
return (x < z)? x : z;
else
return (y < z)? y : z;
}

int main()
{
int cost[R][C] = { {1, 2, 3},
{4, 8, 2},
{1, 5, 3} };
printf(" %d ", minCost(cost, 2, 2));
return 0;
}

Time Complexity of the DP implementation is O(mn) which is much better than Naive Recursive
implementation.
discussed above.
Output of Java Program | Set 1
Predict the output of following Java Programs.
Program 1
// filename Main.java
class Test {
protected int x, y;
}
class Main {
Test t = new Test();
System.out.println(t.x + " " + t.y);
}
}

Output
0 0
In Java, a protected member is accessible in all classes of same package and in inherited classes of other
packages. Since Test and Main are in same package, no access related problem in the above program. Also,
the default constructors initialize integral variables as 0 in Java (See this GFact for more details). That is
why we get output as 0 0.
Program 2
// filename Test.java
class Test {
for(int i = 0; 1; i++) {
System.out.println("Hello");
break;
}
}
}


There is an error in condition check expression of for loop. Java differs from C++(or C) here. C++ considers
all non-zero values as true and 0 as false. Unlike C++, an integer value expression cannot be placed where a
boolean is expected in Java. Following is the corrected program.

class Test {
for(int i = 0; true; i++) {
System.out.println("Hello");
break;
}
}
}
// Output: Hello

Program 3
class Main {
System.out.println(fun());
}
int fun() {
return 20;
}
}


Like C++, in Java, non-static methods cannot be called in a static method. If we make fun() static, then the
program compiles fine without any compiler error. Following is the corrected program.
class Main {
}
static int fun() {
return 20;
}
}
// Output: 20

Program 4

class Test {
}
static int fun() {
static int x= 0;
return ++x;
}
}


Unlike C++, static local variables are not allowed in Java. See this GFact for details. We can have class static
members to count number of function calls and other purposes that C++ local static variables serve.
Following is the corrected program.
class Test {
private static int x;
}
static int fun() {
return ++x;
}
}
// Output: 1

Predict the output of following Java programs.
Question 1
package main;
class Base {
public void Print() {
System.out.println("Base");
}
}

System.out.println("Derived");
}
}
class Main{
public static void DoPrint( Base o ) {
o.Print();
}
Base x = new Base();
Base y = new Derived();
Derived z = new Derived();
DoPrint(x);
DoPrint(y);
DoPrint(z);
}
}

Output:
Base
Derived
Derived

Predicting the first line of output is easy. We create an object of type Base and call DoPrint(). DoPrint calls
the print function and we get the first line.
DoPrint(y) causes second line of output. Like C++, assigning a derived class reference to a base class
reference is allowed in Java. Therefore, the expression Base y = new Derived() is a valid statement in Java.
In DoPrint(), o starts referring to the same object as referred by y. Also, unlike C++, functions are virtual by
default in Java. So, when we call o.print(), the print() method of Derived class is called due to run time
polymorphism present by default in Java.
DoPrint(z) causes third line of output, we pass a reference of Derived type and the print() method of Derived
class is called again. The point to note here is: unlike C++, object slicing doesn’t happen in Java. Because
non-primitive types are always assigned by reference.
Question 2
package main;
class Point {
protected int x, y;

public Point(int _x, int _y) {
x = _x;
y = _y;
}
}
public class Main {

Point p = new Point();
System.out.println("x = " + p.x + ", y = " + p.y);
}
}

Output:
Compiler Error
In the above program, there are no access permission issues because the Test and Main are in same package
and protected members of a class can be accessed in other classes of same package. The problem with the
code is: there is not default constructor in Point. Like C++, if we write our own parametrized constructor
then Java compiler doesn’t create the default constructor. So there are following two changes to Point class
that can fix the above program.
1) Remove the parametrized constructor.
2) Add a constructor without any parameter.
Java doesn’t support default arguments, so that is not an option.
Add two numbers represented by linked lists | Set 1
Given two numbers represented by two lists, write a function that returns sum list. The sum list is list
representation of addition of two input numbers.
Example 1
Input:
First List: 5->6->3 // represents number 365
Second List: 8->4->2 // represents number 248
Output
Resultant list: 3->1->6 // represents number 613

Example 2
Input:
First List: 7->5->9->4->6 // represents number 64957
Second List: 8->4 // represents number 48
Output
Resultant list: 5->0->0->5->6 // represents number 65005

Solution
Traverse both lists. One by one pick nodes of both lists and add the values. If sum is more than 10 then make
carry as 1 and reduce sum. If one list has more elements than the other then consider remaining values of
this list as 0. Following is C implementation of this approach.
#include<stdio.h>
#include<stdlib.h>
/* Linked list node */

struct node
{
int data;
struct node* next;
};
/* Function to create a new node with given data */

struct node *newNode(int data)
{
struct node *new_node = (struct node *) malloc(sizeof(struct node));
new_node->data = data;
return new_node;
}

{
/* allocate node */
struct node* new_node = newNode(new_data);


}
/* Adds contents of two linked lists and return the head node of resultant list */
struct node* addTwoLists (struct node* first, struct node* second)
{
struct node* res = NULL; // res is head node of the resultant list
struct node *temp, *prev = NULL;
int carry = 0, sum;
while (first != NULL || second != NULL) //while both lists exist

{
// Calculate value of next digit in resultant list.
// The next digit is sum of following things
// (i) Carry
// (ii) Next digit of first list (if there is a next digit)
// (ii) Next digit of second list (if there is a next digit)
sum = carry + (first? first->data: 0) + (second? second->data: 0);
// update carry for next calulation

carry = (sum >= 10)? 1 : 0;
// update sum if it is greater than 10

sum = sum % 10;
// Create a new node with sum as data

temp = newNode(sum);
// if this is the first node then set it as head of the resultant list
if(res == NULL)
res = temp;
else // If this is not the first node then connect it to the rest.
prev->next = temp;
// Set prev for next insertion

prev = temp;
// Move first and second pointers to next nodes

if (first) first = first->next;
if (second) second = second->next;
}
if (carry > 0)
temp->next = newNode(carry);
// return head of the resultant list

return res;
}

{
while(node != NULL)
{
node = node->next;
}
printf("\n");
}
/* Drier program to test above function */

/* Drier program to test above function */
int main(void)
{
struct node* first = NULL;
struct node* second = NULL;
// create first list 7->5->9->4->6

push(&first, 6);
push(&first, 4);
push(&first, 9);
push(&first, 5);
push(&first, 7);
printf("First List is ");
printList(first);
// create second list 8->4

push(&second, 4);
push(&second, 8);
printf("Second List is ");
printList(second);
// Add the two lists and see result

res = addTwoLists(first, second);
printf("Resultant list is ");
printList(res);
return 0;
}

Output:
First List is 7 5 9 4 6
Second List is 8 4
Resultant list is 5 0 0 5 6

Time Complexity: O(m + n) where m and n are number of nodes in first and second lists respectively.
same problem.
Smallest of three integers without comparison operators
Write a C program to find the smallest of three integers, without using any of the comparison operators.
Let 3 input numbers be x, y and z.
Method 1 (Repeated Subtraction)

Take a counter variable c and initialize it with 0. In a loop, repeatedly subtract x, y and z by 1 and increment
c. The number which becomes 0 first is the smallest. After the loop terminates, c will hold the minimum of 3.
#include<stdio.h>
int smallest(int x, int y, int z)

{
int c = 0;
while ( x && y && z )
{
x--; y--; z--; c++;
}
return c;
}
int main()
{
int x = 12, y = 15, z = 5;
printf("Minimum of 3 numbers is %d", smallest(x, y, z));
return 0;
}

This methid doesn’t work for negative numbers. Method 2 works for negative nnumbers also.
Method 2 (Use Bit Operations)

Use method 2 of this post to find minimum of two numbers (We can’t use Method 1 as Method 1 uses
comparison operator). Once we have functionality to find minimum of 2 numbers, we can use this to find
minimum of 3 numbers.

// See mthod 2 of http://www.geeksforgeeks.org/archives/2643

#include<stdio.h>
#define CHAR_BIT 8

{
return y + ((x - y) & ((x - y) >>
}
/* Function to find minimum of 3 numbers x, y and z*/

{
return min(x, min(y, z));
}
int main()
{
int x = 12, y = 15, z = 5;
return 0;
}

Method 3 (Use Division operator)

We can also use division operator to find minimum of two numbers. If value of (a/b) is zero, then b is greater
than a, else a is greater. Thanks to gopinath and Vignesh for suggesting this method.
#include <stdio.h>
// Using division operator to find minimum of three numbers

{
if (!(y/x)) // Same as "if (y < x)"
return (!(y/z))? y : z;
return (!(x/z))? x : z;
}
int main()
{
int x = 78, y = 88, z = 68;
return 0;
}
same problem.
Accessing Grandparent’s member in Java
Directly accessing Grandparent’s member in Java:
Predict the output of following Java program.
class Grandparent {
System.out.println("Grandparent's Print()");
}
}

class Parent extends Grandparent {
System.out.println("Parent's Print()");
}
}

class Child extends Parent {
super.super.Print(); // Trying to access Grandparent's Print()
System.out.println("Child's Print()");
}
}

public class Main {
Child c = new Child();
c.Print();
}
}


There is error in line “super.super.print();”. In Java, a class cannot directly access the grandparent’s
members. It is allowed in C++ though. In C++, we can use scope resolution operator (::) to access any
ancestor’s member in inheritance hierarchy. In Java, we can access grandparent’s members only
through the parent class. For example, the following program compiles and runs fine.

class Grandparent {
System.out.println("Grandparent's Print()");
}
}

class Parent extends Grandparent {
super.Print();
System.out.println("Parent's Print()");
}
}

class Child extends Parent {
super.Print();
System.out.println("Child's Print()");
}
}

public class Main {
Child c = new Child();
c.Print();
}
}

Output:
Grandparent's Print()
Parent's Print()
Child's Print()

discussed above.
Predict the output of following C Program.
#include <stdio.h>
#define R 4
#define C 4
void modifyMatrix(int mat[][C])

{
mat++;
mat[1][1] = 100;
mat++;
mat[1][1] = 200;
}
void printMatrix(int mat[][C])

{
int i, j;
for (i = 0; i < R; i++)
{
for (j = 0; j < C; j++)
printf("%3d ", mat[i][j]);
printf("\n");
}
}
int main()
{
int mat[R][C] = { {1, 2, 3, 4},
{5, 6, 7, 8},
{9, 10, 11, 12},
{13, 14, 15, 16}
};
printf("Original Matrix \n");
printMatrix(mat);
modifyMatrix(mat);
printf("Matrix after modification \n");

printMatrix(mat);
return 0;
}

Output: The program compiles fine and produces following output:

Original Matrix
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 16
Matrix after modification
1 2 3 4
5 6 7 8
9 100 11 12
13 200 15 16

At first look, the line “mat++;” in modifyMatrix() seems invalid. But this is a valid C line as array parameters
are always pointers (see this and this for details). In modifyMatrix(), mat is just a pointer that points to
block of size C*sizeof(int). So following function prototype is same as “void modifyMatrix(int mat[][C])”
void modifyMatrix(int (*mat)[C]);

When we do mat++, mat starts pointing to next row, and mat[1][1] starts referring to value 10. mat[1][1]
(value 10) is changed to 100 by the statement “mat[1][1] = 100;”. mat is again incremented and mat[1][1]
(now value 14) is changed to 200 by next couple of statements in modifyMatrix().
The line “mat[1][1] = 100;” is valid as pointer arithmetic and array indexing are equivalent in C.
On a side note, we can’t do mat++ in main() as mat is 2 D array in main(), not a pointer.
Please write comments if you find above answer/explanation incorrect, or you want to share more
information about the topic discussed above
Comparison of Inheritance in C++ and Java
The purpose of inheritance is same in C++ and Java. Inheritance is used in both languages for reusing code
and/or creating is-a relationship. There are following differences in the way both languages provide support
for inheritance.
1) In Java, all classes inherit from the Object class directly or indirectly. Therefore, there is always a single
inheritance tree of classes in Java, and Object class is root of the tree. In Java, if we create a class that doesn’t
inherit from any class then it automatically inherits from Object class . In C++, there is forest of classes;
when we create a class that doesn’t inherit from anything, we create a new tree in forest.
Following Java example shows that Test class automatically inherits from Object class.
class Test {
// members of test
}
class Main {
System.out.println("t is instanceof Object: " + (t instanceof Object));
}
}

Output:

t is instanceof Object: true

2) In Java, members of the grandparent class are not directly accessible. See this G-Fact for more details.
3) The meaning of protected member access specifier is somewhat different in Java. In Java, protected
members of a class “A” are accessible in other class “B” of same package, even if B doesn’t inherit from A
(they both have to be in the same package). For example, in the following program, protected members of A
are accessible in B.
// filename B.java
class A {
protected int x = 10, y = 20;
}

class B {
A a = new A();
System.out.println(a.x + " " + a.y);
}
}

4) Java uses extends keyword for inheritence. Unlike C++, Java doesn’t provide an inheritance specifier like
public, protected or private. Therefore, we cannot change the protection level of members of base class in
Java, if some data member is public or protected in base class then it remains public or protected in derived
class. Like C++, private members of base class are not accessible in derived class.
Unlike C++, in Java, we don’t have to remember those rules of inheritance which are combination of base
class access specifier and inheritance specifier.
5) In Java, methods are virtual by default. In C++, we explicitly use virtual keyword. See this G-Fact for more
details.
6) Java uses a separte keyword interface for interfaces, and abstract keyword for abstract classes and
abstract functions.
Following is a Java abstract class example.
// An abstract class example

abstract class myAbstractClass {

// An abstract method
abstract void myAbstractFun();

// A normal method
void fun() {
System.out.println("Inside My fun");
}
}
public class myClass extends myAbstractClass {

public void myAbstractFun() {
}
}

Following is a Java interface example
// An interface example
public interface myInterface {
// myAbstractFun() is public and abstract, even if we don't use these keywords
void myAbstractFun(); // is same as public abstract void myAbstractFun()
}
// Note the implements keyword also.

public class myClass implements myInterface {
public void myAbstractFun() {
}
}

7) Unlike C++, Java doesn’t support multiple inheritance. A class cannot inherit from more than one class. A
class can implement multiple interfaces though.
8 ) In C++, default constructor of parent class is automatically called, but if we want to call parametrized
constructor of a parent class, we must use Initializer list. Like C++, default constructor of the parent class is
automatically called in Java, but if we want to call parametrized constructor then we must use super to call
the parent constructor. See following Java example.
package main;

class Base {
private int b;
Base(int x) {
b = x;
System.out.println("Base constructor called");
}
}

private int d;
Derived(int x, int y) {
// Calling parent class parameterized constructor
// Call to parent constructor must be the first line in a Derived class
super(x);
d = y;
System.out.println("Derived constructor called");
}
}

class Main{
Derived obj = new Derived(1, 2);
}
}

Output:
Base constructor called

Derived constructor called

discussed above.
Question 1 Predict the output of the following program. What does the following fun() do in general?
#include <stdio.h>
int fun ( int n, int *fp )

{
int t, f;
if ( n <= 1 )
{
*fp = 1;
return 1;
}
t = fun ( n-1, fp );
f = t + *fp;
*fp = t;
return f;
}
int main()
{
int x = 15;
printf("%d\n",fun(5, &x));
return 0;
}

Output:
The program calculates nth Fibonacci Number. The statement t = fun ( n-1, fp ) gives the (n-1)th Fibonacci
number and *fp is used to store the (n-2)th Fibonacci Number. Initial value of *fp (which is 15 in the above
prgram) doesn’t matter. Following recursion tree shows all steps from 1 to 10, for exceution of fun(5, &x).
(1) fun(5, fp)

/ \
(2) fun(4, fp) (10) t = 5, f = 8, *fp = 5
/ \
(3) fun(3, fp) (9) t = 3, f = 5, *fp = 3
/ \
(4) fun(2, fp) (8) t = 2, f = 3, *fp = 2
/ \
(5) fun(1, fp) (7) t = 1, f = 2, *fp = 1
/
(6) *fp = 1

Question 2: Predict the output of the following program.
#include <stdio.h>
void fun(int n)
{
if(n > 0)
{
fun(n-1);
printf("%d ", n);
fun(n-1);
}
}
int main()
{
fun(4);
return 0;
}

Output

1 2 1 3 1 2 1 4 1 2 1 3 1 2 1

fun(4)
/
fun(3), print(4), fun(3) [fun(3) prints 1 2 1 3 1 2 1]
/
fun(2), print(3), fun(2) [fun(2) prints 1 2 1]
/
fun(1), print(2), fun(1) [fun(1) prints 1]
/
fun(0), print(1), fun(0) [fun(0) does nothing]

Copy Constructor in Java
Like C++, Java also supports copy constructor. But, unlike C++, Java doesn’t create a default copy
constructor if you don’t write your own.
Following is an example Java program that shows a simple use of copy constructor.
// filename: Main.java
class Complex {
private double re, im;

// A normal parametrized constructor
public Complex(double re, double im) {
this.re = re;
this.im = im;
}

// copy constructor
Complex(Complex c) {
System.out.println("Copy constructor called");
re = c.re;
im = c.im;
}

// Overriding the toString of Object class
@Override
public String toString() {
return "(" + re + " + " + im + "i)";
}
}
public class Main {

Complex c1 = new Complex(10, 15);

// Following involves a copy constructor call
Complex c2 = new Complex(c1);
// Note that following doesn't involve a copy constructor call as

// non-primitive variables are just references.
Complex c3 = c2;
System.out.println(c2); // toString() of c2 is called here

}
}

Output:
Copy constructor called

(10.0 + 15.0i)

Now try the following Java program:
// filename: Main.java
class Complex {
public Complex(double re, double im) {

this.re = re;
this.im = im;
}
}
public class Main {

Complex c1 = new Complex(10, 15);
Complex c2 = new Complex(c1); // compiler error here
}
}

discussed above.
How to write C functions that modify head pointer of a Linked List?
Consider simple representation (without any dummy node) of Linked List. Functions that operate on such
Linked lists can be divided in two categories:
1) Functions that do not modify the head pointer: Examples of such functions include, printing a
linked list, updating data members of nodes like adding given a value to all nodes, or some other operation
which access/update data of nodes
It is generally easy to decide prototype of functions of this category. We can always pass head pointer as an
argument and traverse/update the list. For example, the following function that adds x to data members of
all nodes.
void addXtoList(struct node *node, int x)

{
while(node != NULL)
{
node->data = node->data + x;
node = node->next;
}
}

2) Functions that modify the head pointer: Examples include, inserting a node at the beginning (head
pointer is always modified in this function), inserting a node at the end (head pointer is modified only when
the first node is being inserted), deleting a given node (head pointer is modified when the deleted node is
first node). There may be different ways to update the head pointer in these functions. Let us discuss these
ways using following simple problem:
“Given a linked list, write a function deleteFirst() that deletes the first node of a given linked list. For
example, if the list is 1->2->3->4, then it should be modified to 2->3->4″
Algorithm to solve the problem is a simple 3 step process: (a) Store the head pointer (b) change the head
pointer to point to next node (c) delete the previous head node.
Following are different ways to update head pointer in deleteFirst() so that the list is updated everywhere.
2.1) Make head pointer global: We can make the head pointer global so that it can be accessed and updated
in our function. Following is C code that uses global head pointer.

// global head pointer

// function to delete first node: uses approach 2.1

// See http://ideone.com/ClfQB for complete program and output
void deleteFirst()
{
if(head != NULL)
{
// store the old value of head pointer

// Change head pointer to point to next node
head = head->next;
// delete memory allocated for the previous head node

free(temp);
}
}

See this for complete running program that uses above function.
This is not a recommended way as it has many problems like following:

a) head is globally accessible, so it can be modified anywhere in your project and may lead to unpredictable
results.
b) If there are multiple linked lists, then multiple global head pointers with different names are needed.
See this to know all reasons why should we avoid global variables in our projects.
2.2) Return head pointer: We can write deleteFirst() in such a way that it returns the modified head pointer.
Whoever is using this function, have to use the returned value to update the head node.

// See http://ideone.com/P5oLe for complete program and output
struct node *deleteFirst(struct node *head)
{
if(head != NULL)
{
// store the old value of head pointer

head = head->next;

free(temp);
}
return head;
}

See this for complete program and output.

This approach is much better than the previous 1. There is only one issue with this, if user misses to assign
the returned value to head, then things become messy. C/C++ compilers allows to call a function without
assigning the returned value.
head = deleteFirst(head); // proper use of deleteFirst()

deleteFirst(head); // improper use of deleteFirst(), allowed by compiler

2.3) Use Double Pointer: This approach follows the simple C rule: if you want to modify local variable of
one function inside another function, pass pointer to that variable. So we can pass pointer to the head
pointer to modify the head pointer in our deleteFirst() function.

// See http://ideone.com/9GwTb for complete program and output
void deleteFirst(struct node **head_ref)
{
if(*head_ref != NULL)
{
// store the old value of pointer to head pointer
struct node *temp = *head_ref;

*head_ref = (*head_ref)->next;

free(temp);
}
}

See this for complete program and output.

This approach seems to be the best among all three as there are less chances of having problems.
discussed above.
Delete a given node in Linked List under given constraints
Given a Singly Linked List, write a function to delete a given node. Your function must follow following
constraints:
1) It must accept pointer to the start node as first parameter and node to be deleted as second parameter i.e.,
pointer to head node is not global.
2) It should not return pointer to the head node.
3) It should not accept pointer to pointer to head node.
You may assume that the Linked List never becomes empty.
Let the function name be deleteNode(). In a straightforward implementation, the function needs to modify
head pointer when the node to be deleted is first node. As discussed in previous post, when a function
modifies the head pointer, the function must use one of the given approaches, we can’t use any of those
approaches here.
Solution
We explicitly handle the case when node to be deleted is first node, we copy the data of next node to head
and delete the next node. The cases when deleted node is not the head node can be handled normally by
finding the previous node and changing next of previous node. Following is C implementation.
#include <stdio.h>
#include <stdlib.h>
/* structure of a linked list node */

struct node
{
int data;
struct node *next;
};
void deleteNode(struct node *head, struct node *n)

{
// When node to be deleted is head node
if(head == n)
{
if(head->next == NULL)
{
printf("There is only one node. The list can't be made empty ");
return;
}
/* Copy the data of next node to head */

head->data = head->next->data;
// store address of next node

n = head->next;
// Remove the link of next node

head->next = head->next->next;
// free memory
free(n);
return;
}
// When not first node, follow the normal deletion process

// When not first node, follow the normal deletion process
// find the previous node

struct node *prev = head;
while(prev->next != NULL && prev->next != n)
prev = prev->next;
// Check if node really exists in Linked List

if(prev->next == NULL)
{
printf("\n Given node is not present in Linked List");
return;
}
// Remove node from Linked List

prev->next = prev->next->next;
// Free memory
free(n);
return;
}
/* Utility function to insert a node at the begining */

{
struct node *new_node =
}
/* Utility function to print a linked list */

{
while(head!=NULL)
{
head=head->next;
}
printf("\n");
}

int main()
{

12->15->10->11->5->6->2->3 */
push(&head,3);
push(&head,2);
push(&head,6);
push(&head,5);
push(&head,11);
push(&head,10);
push(&head,15);
push(&head,12);
printf("Given Linked List: ");

printList(head);
/* Let us delete the node with value 10 */

printf("\nDeleting node %d: ", head->next->next->data);
printf("\nDeleting node %d: ", head->next->next->data);
deleteNode(head, head->next->next);

printList(head);
/* Let us delete the the first node */

printf("\nDeleting first node ");
deleteNode(head, head);

printList(head);
getchar();
return 0;
}
Output:
Given Linked List: 12 15 10 11 5 6 2 3
Deleting node 10:

Modified Linked List: 12 15 11 5 6 2 3
Deleting first node

Modified Linked List: 15 11 5 6 2 3

same problem.
Understanding “volatile” qualifier in C
The volatile keyword is intended to prevent the compiler from applying any optimizations on objects that
can change in ways that cannot be determined by the compiler.
Objects declared as volatile are omitted from optimization because their values can be changed by code
outside the scope of current code at any time. The system always reads the current value of a volatile object
from the memory location rather than keeping its value in temporary register at the point it is requested,
even if a previous instruction asked for a value from the same object. So the simple question is, how can
value of a variable change in such a way that compiler cannot predict. Consider the following cases for
answer to this question.
1) Global variables modified by an interrupt service routine outside the scope: For example, a global
variable can represent a data port (usually global pointer referred as memory mapped IO) which will be
updated dynamically. The code reading data port must be declared as volatile in order to fetch latest data
available at the port. Failing to declare variable as volatile, the compiler will optimize the code in such a way
that it will read the port only once and keeps using the same value in a temporary register to speed up the
program (speed optimization). In general, an ISR used to update these data port when there is an interrupt
due to availability of new data
2) Global variables within a multi-threaded application: There are multiple ways for threads
communication, viz, message passing, shared memory, mail boxes, etc. A global variable is weak form of
shared memory. When two threads sharing information via global variable, they need to be qualified with
volatile. Since threads run asynchronously, any update of global variable due to one thread should be fetched
freshly by another consumer thread. Compiler can read the global variable and can place them in temporary
variable of current thread context. To nullify the effect of compiler optimizations, such global variables to be
qualified as volatile
If we do not use volatile qualifier, the following problems may arise

1) Code may not work as expected when optimization is turned on.
2) Code may not work as expected when interrupts are enabled and used.
Let us see an example to understand how compilers interpret volatile keyword. Consider below code, we are
changing value of const object using pointer and we are compiling code without optimization option. Hence
compiler won’t do any optimization and will change value of const object.
/* Compile code without optimization option */

#include <stdio.h>
int main(void)
{
const int local = 10;
int *ptr = (int*) &local;
printf("Initial value of local : %d \n", local);
*ptr = 100;
printf("Modified value of local: %d \n", local);
return 0;
}

When we compile code with “–save-temps” option of gcc it generates 3 output files
1) preprocessed code (having .i extention)
2) assembly code (having .s extention) and
3) object code (having .o option).
We compile code without optimization, that’s why the size of assembly code will be larger (which is
highlighted in red color below).
Output:
[narendra@ubuntu]$ gcc volatile.c -o volatile –save-temps

[narendra@ubuntu]$ ./volatile
Initial value of local : 10
Modified value of local: 100
[narendra@ubuntu]$ ls -l volatile.s
-rw-r–r– 1 narendra narendra 731 2016-11-19 16:19 volatile.s
[narendra@ubuntu]$

Let us compile same code with optimization option (i.e. -O option). In thr below code, “local” is declared as
const (and non-volatile), GCC compiler does optimization and ignores the instructions which try to change
value of const object. Hence value of const object remains same.
/* Compile code with optimization option */

#include <stdio.h>
int main(void)
{
const int local = 10;
*ptr = 100;
return 0;
}

For above code, compiler does optimization, that’s why the size of assembly code will reduce.
Output:
[narendra@ubuntu]$ gcc -O3 volatile.c -o volatile –save-temps


Let us declare const object as volatile and compile code with optimization option. Although we compile code
with optimization option, value of const object will change, because variable is declared as volatile that
means don’t do any optimization.
/* Compile code with optimization option */

#include <stdio.h>
int main(void)
{
const volatile int local = 10;
*ptr = 100;
return 0;
}

Output:
[narendra@ubuntu]$ gcc -O3 volatile.c -o volatile –save-temp

[narendra@ubuntu]$

The above example may not be a good practical example, the purpose was to explain how compilers interpret
volatile keyword. As a practical example, think of touch sensor on mobile phones. The driver abstracting
touch sensor will read the location of touch and send it to higher level applications. The driver itself should
not modify (const-ness) the read location, and make sure it reads the touch input every time fresh (volatile-
ness). Such driver must read the touch sensor input in const volatile manner.
Refer following links for more details on volatile keyword:

Volatile: A programmer’s best friend
Do not use volatile as a synchronization primitive
This article is compiled by “Narendra Kangralkar“ and reviewed by GeeksforGeeks team. Please write
comments if you find anything incorrect, or you want to share more information about the topic discussed
above.
Trie | (Delete)
In the previous post on trie we have described how to insert and search a node in trie. Here is an algorithm
how to delete a node from trie.
During delete operation we delete the key in bottom up manner using recursion. The following are possible
conditions when deleting key from trie,
1. Key may not be there in trie. Delete operation should not modify trie.
2. Key present as unique key (no part of key contains another key (prefix), nor the key itself is prefix of
another key in trie). Delete all the nodes.
3. Key is prefix key of another long key in trie. Unmark the leaf node.
4. Key present in trie, having atleast one other key as prefix key. Delete nodes from end of key until first
leaf node of longest prefix key.
The highlighted code presents algorithm to implement above conditions. (One may be in dilemma how a
pointer passed to delete helper is reflecting changes from deleteHelper to deleteKey. Note that we are
holding trie as an ADT in trie_t node, which is passed by reference or pointer).
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// Alphabet size (# of symbols)
#define ALPHABET_SIZE (26)

#define INDEX(c) ((int)c - (int)'a')
#define FREE(p) \
free(p); \
p = NULL;
// forward declration
typedef struct trie_node trie_node_t;
// trie node
struct trie_node
{
int value; // non zero if leaf
};
// trie ADT
typedef struct trie trie_t;
struct trie
{
trie_node_t *root;
int count;
};
trie_node_t *getNode(void)
{
trie_node_t *pNode = NULL;
pNode = (trie_node_t *)malloc(sizeof(trie_node_t));
if( pNode )
if( pNode )
{
int i;
pNode->value = 0;

{
pNode->children[i] = NULL;
}
}
return pNode;
}
void initialize(trie_t *pTrie)

{
pTrie->root = getNode();
pTrie->count = 0;
}

{
int level;
int index;
pTrie->count++;

{
index = INDEX(key[level]);
if( pCrawl->children[index] )
{
// Skip current node
}
else
{
// Add new node
pCrawl->children[index] = getNode();
}
}
// mark last node as leaf (non zero)

pCrawl->value = pTrie->count;
}
int search(trie_t *pTrie, char key[])

{
int level;
int index;

{
index = INDEX(key[level]);
{
return 0;
}
}
return (0 != pCrawl && pCrawl->value);

}
int leafNode(trie_node_t *pNode)

{
return (pNode->value != 0);
}
int isItFreeNode(trie_node_t *pNode)

{
int i;
{
if( pNode->children[i] )
return 0;
}
return 1;
}
bool deleteHelper(trie_node_t *pNode, char key[], int level, int len)

{
if( pNode )
{
// Base case
if( level == len )
{
if( pNode->value )
{
// Unmark leaf node
pNode->value = 0;
// If empty, node to be deleted

if( isItFreeNode(pNode) )
{
return true;
}
return false;
}
}
else // Recursive case
{
int index = INDEX(key[level]);
if( deleteHelper(pNode->children[index], key, level+1, len) )

{
// last node marked, delete it
FREE(pNode->children[index]);
// recursively climb up, and delete eligible nodes

return ( !leafNode(pNode) && isItFreeNode(pNode) );
}
}
}
return false;
}
void deleteKey(trie_t *pTrie, char key[])

{
int len = strlen(key);
if( len > 0 )

{
deleteHelper(pTrie->root, key, 0, len);
}
}
int main()
{
char keys[][8] = {"she", "sells", "sea", "shore", "the", "by", "sheer"};
trie_t trie;
initialize(&trie);
for(int i = 0; i < ARRAY_SIZE(keys); i++)

{
insert(&trie, keys[i]);
}
deleteKey(&trie, keys[0]);
printf("%s %s\n", "she", search(&trie, "she") ? "Present in trie" : "Not present in t

rie");
return 0;
}
Find a Fixed Point in a given array
Given an array of n distinct integers sorted in ascending order, write a function that returns a Fixed Point in
the array, if there is any Fixed Point present in array, else returns -1. Fixed Point in an array is an index i
such that arr[i] is equal to i. Note that integers in array can be negative.
Examples:
Input: arr[] = {-10, -5, 0, 3, 7}

Output: 3 // arr[3] == 3
Input: arr[] = {0, 2, 5, 8, 17}

Output: 0 // arr[0] == 0
Input: arr[] = {-10, -5, 3, 4, 7, 9}

Output: -1 // No Fixed Point

Asked by rajk

Linearly search for an index i such that arr[i] == i. Return the first such index found. Thanks to pm for
suggesting this solution.
int linearSearch(int arr[], int n)

{
int i;
for(i = 0; i < n; i++)
{
if(arr[i] == i)
return i;
}
/* If no fixed point present then return -1 */

return -1;
}

int main()
{
int arr[] = {-10, -1, 0, 3, 10, 11, 30, 50, 100};
printf("Fixed Point is %d", linearSearch(arr, n));
getchar();
return 0;
}


First check whether middle element is Fixed Point or not. If it is, then return it; otherwise check whether
index of middle element is greater than value at the index. If index is greater, then Fixed Point(s) lies on the
right side of the middle point (obviously only if there is a Fixed Point). Else the Fixed Point(s) lies on left
side.
int binarySearch(int arr[], int low, int high)

{
if(high >= low)
{
if(mid == arr[mid])
return mid;
if(mid > arr[mid])
return binarySearch(arr, (mid + 1), high);
else
return binarySearch(arr, low, (mid -1));
}
/* Return -1 if there is no Fixed Point */

return -1;
}

int main()
{
int arr[10] = {-10, -1, 0, 3, 10, 11, 30, 50, 100};
printf("Fixed Point is %d", binarySearch(arr, 0, n-1));
getchar();
return 0;
}

Algorithmic Paradigm: Divide & Conquer

discussed above.
Length of the longest substring without repeating characters
Given a string, find the length of the longest substring without repeating characters. For example, the longest
substrings without repeating characters for “ABDEFGABEF” are “BDEFGA” and “DEFGAB”, with length 6.
For “BBBB” the longest substring is “B”, with length 1. For “GEEKSFORGEEKS”, there are two longest
substrings shown in the below diagrams, with length 7.
The desired time complexity is O(n) where n is the length of the string.
Method 1 (Simple)
We can consider all substrings one by one and check for each substring whether it contains all unique
characters or not. There will be n*(n+1)/2 substrings. Whether a substirng contains all unique characters or
not can be checked in linear time by scanning it from left to right and keeping a map of visited characters.
Time complexity of this solution would be O(n^3).
Method 2 (Linear Time)

Let us talk about the linear time solution now. This solution uses extra space to store the last indexes of
already visited characters. The idea is to scan the string from left to right, keep track of the maximum length
Non-Repeating Character Substring (NRCS) seen so far. Let the maximum length be max_len. When we
traverse the string, we also keep track of length of the current NRCS using cur_len variable. For every new
character, we look for it in already processed part of the string (A temp array called visited[] is used for this
purpose). If it is not present, then we increase the cur_len by 1. If present, then there are two cases:
a) The previous instance of character is not part of current NRCS (The NRCS which is under process). In
this case, we need to simply increase cur_len by 1.
b) If the previous instance is part of the current NRCS, then our current NRCS changes. It becomes the
substring staring from the next character of previous instance to currently scanned character. We also need
to compare cur_len and max_len, before changing current NRCS (or changing cur_len).
Implementation
#include<stdlib.h>
#include<stdio.h>
int min(int a, int b);
int longestUniqueSubsttr(char *str)

{
int cur_len = 1; // To store the lenght of current substring
int max_len = 1; // To store the result
int prev_index; // To store the previous index
int prev_index; // To store the previous index
int i;
int *visited = (int *)malloc(sizeof(int)*NO_OF_CHARS);
/* Initialize the visited array as -1, -1 is used to indicate that

character has not been visited yet. */
visited[i] = -1;
/* Mark first character as visited by storing the index of first

character in visited array. */
visited[str[0]] = 0;
/* Start from the second character. First character is already processed

(cur_len and max_len are initialized as 1, and visited[str[0]] is set */
for (i = 1; i < n; i++)
{
prev_index = visited[str[i]];
/* If the currentt character is not present in the already processed

substring or it is not part of the current NRCS, then do cur_len++ */
if (prev_index == -1 || i - cur_len > prev_index)
cur_len++;
/* If the current character is present in currently considered NRCS,

then update NRCS to start from the next character of previous instance. */
else
{
/* Also, when we are changing the NRCS, we should also check whether
length of the previous NRCS was greater than max_len or not.*/
if (cur_len > max_len)
max_len = cur_len;
cur_len = i - prev_index;
}
visited[str[i]] = i; // update the index of current character

}
// Compare the length of last NRCS with max_len and update max_len if needed
if (cur_len > max_len)
max_len = cur_len;
free(visited); // free memory allocated for visited
return max_len;
}
/* A utility function to get the minimum of two integers */

int min(int a, int b)
{
return (a>b)?b:a;
}

int main()
{
char str[] = "ABDEFGABEF";
printf("The input string is %s \n", str);
int len = longestUniqueSubsttr(str);
printf("The length of the longest non-repeating character substring is %d", len);
getchar();
return 0;
return 0;
}

Output
The input string is ABDEFGABEF

The length of the longest non-repeating character substring is 6

Time Complexity: O(n + d) where n is length of the input string and d is number of characters in input
string alphabet. For example, if string consists of lowercase English characters then value of d is 26.
Auxiliary Space: O(d)
As an exercise, try the modified version of the above problem where you need to print the maximum length
NRCS also (the above program only prints length of it).
discussed above.
Predict the output of following C programs:
Question 1
#include<stdio.h>
int main()
{
int arr[] = {10, 20, 30, 40, 50, 60};
int *ptr1 = arr;
int *ptr2 = arr + 5;
printf ("ptr2 - ptr1 = %d\n", ptr2 - ptr1);
printf ("(char*)ptr2 - (char*) ptr1 = %d", (char*)ptr2 - (char*)ptr1);
getchar();
return 0;
}

Output:
ptr2 - ptr1 = 5
(char*)ptr2 - (char*) ptr1 = 20

In C, array name gives address of the first element in the array. So when we do ptr1 = arr, ptr1 starts
pointing to address of first element of arr. Since array elements are accessed using pointer arithmetic, arr +
5 is a valid expression and gives the address of 6th element. Predicting value ptr2 – ptr1 is easy, it gives 5 as
there are 5 inetegers between these two addresses. When we do (char *)ptr2, ptr2 is typecasted to char
pointer. In expression “(int*)ptr2 – (int*)ptr1″, pointer arithmetic happens considering character poitners.
Since size of a character is one byte, we get 5*sizeof(int) (which is 20) as difference of two pointers.
As an excercise, predict the output of following program.
#include<stdio.h>
int main()
{
char *ptr1 = arr;
char *ptr2 = ptr1 + 3;
printf ("ptr2 - ptr1 = %d\n", ptr2 - ptr1);
printf ("(int*)ptr2 - (int*) ptr1 = %d", (int*)ptr2 - (int*)ptr1);
getchar();
return 0;
}

Question 2

#include<stdio.h>
int main()
{
char arr[] = "geeks\0 for geeks";
char *str = "geeks\0 for geeks";
printf ("arr = %s, sizeof(arr) = %d \n", arr, sizeof(arr));
printf ("str = %s, sizeof(str) = %d", str, sizeof(str));
getchar();
return 0;
}

Output:
arr = geeks, sizeof(arr) = 17

str = geeks, sizeof(str) = 4

Let us first talk about first output “arr = geeks”. When %s is used to print a string, printf starts from the first
character at given address and keeps printing characters until it sees a string termination character, so we
get “arr = geeks” as there is a \0 after geeks in arr[].
Now let us talk about output “sizeof(arr) = 17″. When a character array is initialized with a double quoted
string and array size is not specified, compiler automatically allocates one extra space for string terminator
‘\0′ (See this Gfact), that is why size of arr is 17.
Explanation for printing “str = geeks” is same as printing “arr = geeks”. Talking about value of sizeof(str), str
is just a pointer (not array), so we get size of a pointer as output.
Please write comments if you find above answer/explanation incorrect, or you want to share more
Pure Functions
A function is called pure function if it always returns the same result for same argument values and it has no
side effects like modifying an argument (or global variable) or outputting something. The only result of
calling a pure function is the return value. Examples of pure functions are strlen(), pow(), sqrt() etc.
Examples of impure functions are printf(), rand(), time(), etc.
If a function is known as pure to compiler then Loop optimization and subexpression elimination can be
applied to it. In GCC, we can mark functions as pure using the “pure” attribute.
__attribute__ ((pure)) return-type fun-name(arguments1, …)

{
/* function body */
}

Following is an example pure function that returns square of a passed integer.
__attribute__ _((pure)) int my_square(int val)

{
return val*val;
}

Consider the below example
for (len = 0; len < strlen(str); ++len)

printf("%c", toupper(str[len]));

If “strlen()” function is not marked as pure function then compiler will invoke the “strlen()” function with
each iteration of the loop, and if function is marked as pure function then compiler knows that value of
“strlen()” function will be same for each call, that’s why compiler optimizes the for loop and generates code
like following.
for (i = 0; i < len; ++i)

printf("%c", toupper((str[i]));

Let us write our own pure function to calculate string length.

__attribute__ ((pure)) size_t my_strlen(const char *str)

{
const char *ptr = str;
while (*ptr)
++ptr;
return (ptr – str);

}

Marking function as pure says that the hypothetical function “my_strlen()” is safe to call fewer times than
the program says.
This article is compiled by “Narendra Kangralkar” and reviewed by GeeksforGeeks team. Please write
above.
Maximum Length Bitonic Subarray
Given an array A[0 … n-1] containing n positive integers, a subarray A[i … j] is bitonic if there is a k with i =
A[k + 1] >= .. A[j – 1] > = A[j]. Write a function that takes an array as argument and returns the length of the
maximum length bitonic subarray.
Expected time complexity of the solution is O(n)
Simple Examples
1) A[] = {12, 4, 78, 90, 45, 23}, the maximum length bitonic subarray is {4, 78, 90, 45, 23} which is of length
5.
2) A[] = {20, 4, 1, 2, 3, 4, 2, 10}, the maximum length bitonic subarray is {1, 2, 3, 4, 2} which is of length 5.
Extreme Examples
1) A[] = {10}, the single element is bitnoic, so output is 1.
2) A[] = {10, 20, 30, 40}, the complete array itself is bitonic, so output is 4.
3) A[] = {40, 30, 20, 10}, the complete array itself is bitonic, so output is 4.
Solution
Let us consider the array {12, 4, 78, 90, 45, 23} to understand the soultion.
1) Construct an auxiliary array inc[] from left to right such that inc[i] contains length of the nondecreaing
subarray ending at arr[i].
For for A[] = {12, 4, 78, 90, 45, 23}, inc[] is {1, 1, 2, 3, 1, 1}
2) Construct another array dec[] from right to left such that dec[i] contains length of nonincreasing subarray
starting at arr[i].
For A[] = {12, 4, 78, 90, 45, 23}, dec[] is {2, 1, 1, 3, 2, 1}.
3) Once we have the inc[] and dec[] arrays, all we need to do is find the maximum value of (inc[i] + dec[i] –
1).
For {12, 4, 78, 90, 45, 23}, the max value of (inc[i] + dec[i] – 1) is 5 for i = 3.

#include<stdio.h>
#include<stdlib.h>
int bitonic(int arr[], int n)

{
int i;
int *inc = new int[n];
int *dec = new int[n];
int max;
inc[0] = 1; // The length of increasing sequence ending at first index is 1
dec[n-1] = 1; // The length of increasing sequence starting at first index is 1
// Step 1) Construct increasing sequence array

for(i = 1; i < n; i++)
{
if (arr[i] > arr[i-1])
inc[i] = inc[i-1] + 1;
else
inc[i] = 1;
}
// Step 2) Construct decreasing sequence array

for (i = n-2; i >= 0; i--)
{
dec[i] = dec[i+1] + 1;
else
dec[i] = 1;
}
// Step 3) Find the length of maximum length bitonic sequence

max = inc[0] + dec[0] - 1;
for (i = 1; i < n; i++)
{
if (inc[i] + dec[i] - 1 > max)
{
max = inc[i] + dec[i] - 1;
}
}
// free dynamically allocated memory

delete [] inc;
delete [] dec;
return max;
}

int main()
{
int arr[] = {12, 4, 78, 90, 45, 23};
printf("\n Length of max length Bitnoic Subarray is %d", bitonic(arr, n));
getchar();
return 0;
}


As an exercise, extend the above implementation to print the longest bitonic subarray also. The above
implementation only returns the length of such subarray.
discussed above.
Output of C program | Set 25
Predict the output of following C program.
int main(void)
{
struct str
{
int i: 1;
int j: 2;
int k: 3;
int l: 4;
};
struct str s;
s.i = 1;
s.j = 2;
s.k = 5;
s.l = 10;
printf(" i: %d \n j: %d \n k: %d \n l: %d \n", s.i, s.j, s.k, s.l);
getchar();
return 0;
}

The above code is non-portable and output is compiler dependent. We get following output using GCC
compiler for intel 32 bit machine.
[narendra@ubuntu]$ ./structure
i: -1
j: -2
k: -3
l: -6

Let us take a closer look at declaration of structure.
struct str
{
int i: 1;
int j: 2;
int k: 3;
int l: 4;
};

In the structure declaration, for structure member ‘i’, we used width of bit field as 1, width of ‘j’ as 2, and so
on. At first, it looks we can store values in range [0-1] for ‘i’, range [0-3] for ‘j’, and so on. But in the above
declaration, type of bit fields is integer (signed). That’s why out of available bits, 1 bit is used to store sign
information. So for ‘i’, the values we can store are 0 or -1 (for a machine that uses two’s complement to store
signed integers). For variable ‘k’, number of bits is 3. Out of these 3 bits, 2 bits are used to store data and 1 bit
is used to store sign.
Let use declare structure members as “unsigned int” and check output.
int main(void)
{
struct str
{
unsigned int i: 1;
unsigned int j: 2;
unsigned int k: 3;
unsigned int l: 4;
};
struct str s;
s.i = 1;
s.j = 2;
s.k = 5;
s.l = 10;
printf(" i: %d \n j: %d \n k: %d \n l: %d \n", s.i, s.j, s.k, s.l);
getchar();
return 0;
}

output:
[narendra@ubuntu]$ ./structure
i: 1
j: 2
k: 5
l: 10

This article is compiled by “Narendra Kangralkar“ and reviewed by GeeksforGeeks team. Please write
above.
Scope rules in C
Scope of an identifier is the part of the program where the identifier may directly be accessible. In C, all
identifiers are lexically (or statically) scoped. C scope rules can be covered under following two categories.
Global Scope: Can be accessed anywhere in a program.
// filename: file1.c
int a;
int main(void)
{
a = 2;
}

// filename: file2.c
// When this file is linked with file1.c, functions of this file can access a
extern int a;
int myfun()
{
a = 2;
}

To restrict access to current file only, global variables can be marked as static.
Block Scope: A Block is a set of statements enclosed within left and right braces ({ and } respectively).
Blocks may be nested in C (a block may contain other blocks inside it). A variable declared in a block is
accessible in the block and all inner blocks of that block, but not accessible outside the block.
What if the inner block itself has one variable with the same name?
If an inner block declares a variable with the same name as the variable declared by the outer block, then the
visibility of the outer block variable ends at the pint of declaration by inner block.

int main()
{
{
int x = 10, y = 20;
{
// The outer block contains declaration of x and y, so
// following statement is valid and prints 10 and 20
printf("x = %d, y = %d\n", x, y);
{
// y is declared again, so outer block y is not accessible
// in this block
int y = 40;

x++; // Changes the outer block variable x to 11
y++; // Changes this block's variable y to 41

printf("x = %d, y = %d\n", x, y);
}
// This statement accesses only outer block's variables

printf("x = %d, y = %d\n", x, y);
}
}
return 0;
}

Output:
x = 10, y = 20
x = 11, y = 41
x = 11, y = 20

What about functions and parameters passed to functions?

A function itself is a block. Parameters and other local variables of a function follow the same block scope
rules.
Can variables of block be accessed in another subsequent block?*

No, a variabled declared in a block can only be accessed inside the block and all inner blocks of this block.
For example, following program produces compiler error.

int main()
{
{
int x = 10;
}
{
printf("%d", x); // Error: x is not accessible here
}
return 0;
}

Output:
error: 'x' undeclared (first use in this function)

As an exercise, predict the output of following program.
int main()
{
int x = 1, y = 2, z = 3;
printf(" x = %d, y = %d, z = %d \n", x, y, z);
{
int x = 10;
float y = 20;
printf(" x = %d, y = %f, z = %d \n", x, y, z);
{
int z = 100;
printf(" x = %d, y = %f, z = %d \n", x, y, z);
}
}
return 0;
}

discussed above.
Analysis of Algorithms | Set 1 (Asymptotic Analysis)
Why performance analysis?
There are many important things that should be taken care of, like user friendliness, modularity, security,
maintainability, etc. Why to worry about performance?
The answer to this is simple, we can have all the above things only if we have performance. So performance
is like currency through which we can buy all the above things. Another reason for studying performance is –
speed is fun!
Given two algorithms for a task, how do we find out which one is better?
One naive way of doing this is – implement both the algorithms and run the two programs on your computer
for different inputs and see which one takes less time. There are many problems with this approach for
analysis of algorithms.
1) It might be possible that for some inputs, first algorithm performs better than the second. And for some
inputs second performs better.
2) It might also be possible that for some inputs, first algorithm perform better on one machine and the
second works better on other machine for some other inputs.
Asymptotic Analysis is the big idea that handles above issues in analyzing algorithms. In Asymptotic
Analysis, we evaluate the performance of an algorithm in terms of input size (we don’t measure the actual
running time). We calculate, how does the time (or space) taken by an algorithm increases with the input
size.
For example, let us consider the search problem (searching a given item) in a sorted array. One way to search
is Linear Search (order of growth is linear) and other way is Binary Search (order of growth is logarithmic).
To understand how Asymptotic Analysis solves the above mentioned problems in analyzing algorithms, let
us say we run the Linear Search on a fast computer and Binary Search on a slow computer. For small values
of input array size n, the fast computer may take less time. But, after certain value of input array size, the
Binary Search will definitely start taking less time compared to the Linear Search even though the Binary
Search is being run on a slow machine. The reason is the order of growth of Binary Search with respect to
input size logarithmic while the order of growth of Linear Search is linear. So the machine dependent
constants can always be ignored after certain values of input size.
Does Asymptotic Analysis always work?

Asymptotic Analysis is not perfect, but that’s the best way available for analyzing algorithms. For example,
say there are two sorting algorithms that take 1000nLogn and 2nLogn time respectively on a machine. Both
of these algorithms are asymptotically same (order of growth is nLogn). So, With Asymptotic Analysis, we
can’t judge which one is better as we ignore constants in Asymptotic Analysis.
Also, in Asymptotic analysis, we always talk about input sizes larger than a constant value. It might be
possible that those large inputs are never given to your software and an algorithm which is asymptotically
slower, always performs better for your particular situation. So, you may end up choosing an algorithm that
is Asymptotically slower but faster for your software.
We will covering more on analysis of algorithms in some more posts on this topic.
References:
MIT’s Video lecture 1 on Introduction to Algorithms.
discussed above.
Print all sequences of given length
Given two integers k and n, write a function that prints all the sequences of length k composed of numbers
1,2..n. You need to print these sequences in sorted order.
Examples:
Input: k = 2, n = 3
Output:
1 1
1 2
1 3
2 1
2 2
2 3
3 1
3 2
3 3

Input: k = 3, n = 4
Output:
1 1 1
1 1 2
1 1 3
1 1 4
1 2 1
.....
.....
4 3 4
4 4 1
4 4 2
4 4 3
4 4 4

Method 1 (Simple and Iterative):

The simple idea to print all sequences in sorted order is to start from {1 1 … 1} and keep incrementing the
sequence while the sequence doesn’t become {n n … n}. Following is the detailed process.
1) Create an output array arr[] of size k. Initialize the array as {1, 1…1}.
2) Print the array arr[].
3) Update the array arr[] so that it becomes immediate successor (to be printed) of itself. For example,
immediate successor of {1, 1, 1} is {1, 1, 2}, immediate successor of {1, 4, 4} is {2, 1, 1} and immediate
successor of {4, 4, 3} is {4 4 4}.
4) Repeat steps 2 and 3 while there is a successor array. In other words, while the output array arr[] doesn’t
become {n, n .. n}
Now let us talk about how to modify the array so that it contains immediate successor. By definition, the
immediate successor should have the same first p terms and larger (p+l)th term. In the original array,
(p+1)th term (or arr[p]) is smaller than n and all terms after arr[p] i.e., arr[p+1], arr[p+2], … arr[k-1] are n.
To find the immediate successor, we find the point p in the previously printed array. To find point p, we start
from rightmost side and keep moving till we find a number arr[p] such that arr[p] is smaller than n (or not
n). Once we find such a point, we increment it arr[p] by 1 and make all the elements after arr[p] as 1 i.e., we
do arr[p+1] = 1, arr[p+2] = 1 .. arr[k-1] = 1. Following are the detailed steps to get immediate successor of
arr[]
1) Start from the rightmost term arr[k-1] and move toward left. Find the first element arr[p] that is not same
as n.
2) Increment arr[p] by 1
3) Starting from arr[p+1] to arr[k-1], set the value of all terms as 1.
#include<stdio.h>
/* A utility function that prints a given arr[] of length size*/

{
printf("\n");
return;
}
/* This function returns 0 if there are no more sequences to be printed, otherwise

modifies arr[] so that arr[] contains next sequence to be printed */
int getSuccessor(int arr[], int k, int n)
{
/* start from the rightmost side and find the first number less than n */
int p = k - 1;
while (arr[p] == n)
p--;
/* If all numbers are n in the array then there is no successor, return 0 */

if (p < 0)
return 0;
/* Update arr[] so that it contains successor */

arr[p] = arr[p] + 1;
for(int i = p + 1; i < k; i++)
arr[i] = 1;
return 1;
}
/* The main function that prints all sequences from 1, 1, ..1 to n, n, ..n */
void printSequences(int n, int k)
{
int *arr = new int[k];
/* Initialize the current sequence as the first sequence to be printed */

for(int i = 0; i < k; i++)
arr[i] = 1;
/* The loop breaks when there are no more successors to be printed */

while(1)
{
/* Print the current sequence */
printArray(arr, k);
/* Update arr[] so that it contains next sequence to be printed. And if

there are no more sequences then break the loop */
if(getSuccessor(arr, k, n) == 0)
if(getSuccessor(arr, k, n) == 0)
break;
}
delete(arr); // free dynamically allocated array

return;
}
/* Driver Program to test above functions */

int main()
{
int n = 3;
int k = 2;
printSequences(n, k);
return 0;
}

Output:
1 1
1 2
1 3
2 1
2 2
2 3
3 1
3 2
3 3

Time Complexity: There are total n^k sequences. Printing a sequence and finding its successor take O(k)
time. So time complexity of above implementation is O(k*n^k).
Method 2 (Tricky and Recursive)

The recursive function printSequencesRecur generates and prints all sequences of length k. The idea is to
use one more parameter index. The function printSequencesRecur keeps all the terms in arr[] sane till index,
update the value at index and recursively calls itself for more terms after index.

#include<stdio.h>
/* A utility function that prints a given arr[] of length size*/

{
printf("\n");
return;
}
/* The core function that recursively generates and prints all sequences of
length k */
void printSequencesRecur(int arr[], int n, int k, int index)
{
int i;
if (k == 0)
{
printArray(arr, index);
}
if (k > 0)
{
for(i = 1; i<=n; ++i)
{
arr[index] = i;
printSequencesRecur(arr, n, k-1, index+1);
}
}
}
/* A function that uses printSequencesRecur() to prints all sequences

from 1, 1, ..1 to n, n, ..n */
void printSequences(int n, int k)
{
printSequencesRecur(arr, n, k, 0);
delete(arr); // free dynamically allocated array

return;
}

int main()
{
int n = 3;
int k = 2;
printSequences(n, k);
return 0;
}

Output:

1 1
1 2
1 3
2 1
2 2
2 3
3 1
3 2
3 3

Time Complexity: There are n^k sequences and printing a sequence takes O(k) time. So time complexity is
O(k*n^k).
Thanks to mopurizwarriors for suggesting above method. As suggested by alphayoung, we can avoid use of
arrays for small sequences that can fit in an integer. Following is the C implementation for same.
/* The core function that generates and prints all sequences of length k */
void printSeqRecur(int num, int pos, int k, int n)
{
if (pos == k) {
printf("%d \n", num);
return;
}
for (int i = 1; i <= n; i++) {
printSeqRecur(num * 10 + i, pos + 1, k, n);
}
}
/* A function that uses printSequencesRecur() to prints all sequences

from 1, 1, ..1 to n, n, ..n */
void printSequences(int k, int n)
{
printSeqRecur(0, 0, k, n);
}

References:
Algorithms and Programming: Problems and Solutions by Alexander Shen
discussed above.
Connect nodes at same level
Write a function to connect all the adjacent nodes at the same level in a binary tree. Structure of the given
Binary Tree node is like following.
struct node{
int data;
struct node* left;
struct node* right;
struct node* nextRight;
}

Initially, all the nextRight pointers point to garbage values. Your function should set these pointers to point
next right for each node.
Example
Input Tree
A
/ \
B C
/ \ \
D E F
Output Tree
A--->NULL
/ \
B-->C-->NULL
/ \ \
D-->E-->F-->NULL

Method 1 (Extend Level Order Traversal or BFS)

Consider the method 2 of Level Order Traversal. The method 2 can easily be extended to connect nodes of
same level. We can augment queue entries to contain level of nodes also which is 0 for root, 1 for root’s
children and so on. So a queue node will now contain a pointer to a tree node and an integer level. When we
enqueue a node, we make sure that correct level value for node is being set in queue. To set nextRight, for
every node N, we dequeue the next node from queue, if the level number of next node is same, we set the
nextRight of N as address of the dequeued node, otherwise we set nextRight of N as NULL.
Method 2 (Extend Pre Order Traversal)

This approach works only for Complete Binary Trees. In this method we set nextRight in Pre Order fashion
to make sure that the nextRight of parent is set before its children. When we are at node p, we set the
nextRight of its left and right children. Since the tree is complete tree, nextRight of p’s left child (p->left-
>nextRight) will always be p’s right child, and nextRight of p’s right child (p->right->nextRight) will always
be left child of p’s nextRight (if p is not the rightmost node at its level). If p is the rightmost node, then
nextRight of p’s right child will be NULL.
#include <stdio.h>
#include <stdlib.h>
struct node
{
int data;
struct node *left;
struct node *right;
struct node *nextRight;
};
void connectRecur(struct node* p);
// Sets the nextRight of root and calls connectRecur() for other nodes
void connect (struct node *p)
{
// Set the nextRight for root
p->nextRight = NULL;
// Set the next right for rest of the nodes (other than root)
connectRecur(p);
}
/* Set next right of all descendents of p.

Assumption: p is a compete binary tree */
void connectRecur(struct node* p)
{
// Base case
if (!p)
return;
// Set the nextRight pointer for p's left child

if (p->left)
p->left->nextRight = p->right;
// Set the nextRight pointer for p's right child

// p->nextRight will be NULL if p is the right most child at its level
if (p->right)
p->right->nextRight = (p->nextRight)? p->nextRight->left: NULL;
// Set nextRight for other nodes in pre order fashion

connectRecur(p->left);
connectRecur(p->right);
}
{
node->data = data;
node->left = NULL;
node->right = NULL;
node->nextRight = NULL;
return(node);
}

int main()
{

10
/ \
8 2
/
3
*/
// Populates nextRight pointer in all nodes

connect(root);
// Let us check the values of nextRight pointers

printf("Following are populated nextRight pointers in the tree "
"(-1 is printed if there is no nextRight) \n");
printf("nextRight of %d is %d \n", root->data,
root->nextRight? root->nextRight->data: -1);
printf("nextRight of %d is %d \n", root->left->data,
root->left->nextRight? root->left->nextRight->data: -1);
printf("nextRight of %d is %d \n", root->right->data,
root->right->nextRight? root->right->nextRight->data: -1);
printf("nextRight of %d is %d \n", root->left->left->data,
root->left->left->nextRight? root->left->left->nextRight->data: -1);
getchar();
return 0;
}

Thanks to Dhanya for suggesting this approach.
Why doesn’t method 2 work for trees which are not Complete Binary Trees?
Let us consider following tree as an example. In Method 2, we set the nextRight pointer in pre order fashion.
When we are at node 4, we set the nextRight of its children which are 8 and 9 (the nextRight of 4 is already
set as node 5). nextRight of 8 will simply be set as 9, but nextRight of 9 will be set as NULL which is
incorrect. We can’t set the correct nextRight, because when we set nextRight of 9, we only have nextRight of
node 4 and ancestors of node 4, we don’t have nextRight of nodes in right subtree of root.
1
/ \
2 3
/ \ / \
4 5 6 7
/ \ / \
8 9 10 11

See next post for more solutions.
discussed above.
Connect nodes at same level using constant extra space
Write a function to connect all the adjacent nodes at the same level in a binary tree. Structure of the given
Binary Tree node is like following.
struct node {
int data;
struct node* left;
struct node* right;
struct node* nextRight;
}

Initially, all the nextRight pointers point to garbage values. Your function should set these pointers to point
next right for each node. You can use only constant extra space.
Example
Input Tree
A
/ \
B C
/ \ \
D E F
Output Tree
A--->NULL
/ \
B-->C-->NULL
/ \ \
D-->E-->F-->NULL

We discussed two different approaches to do it in the previous post. The auxiliary space required in both of
those approaches is not constant. Also, the method 2 discussed there only works for complete Binary Tree.
In this post, we will first modify the method 2 to make it work for all kind of trees. After that, we will remove
recursion from this method so that the extra space becomes constant.
A Recursive Solution
In the method 2 of previous post, we traversed the nodes in pre order fashion. Instead of traversing in Pre
Order fashion (root, left, right), if we traverse the nextRight node before the left and right children (root,
nextRight, left), then we can make sure that all nodes at level i have the nextRight set, before the level i+1
nodes. Let us consider the following example (same example as previous post). The method 2 fails for right
child of node 4. In this method, we make sure that all nodes at the 4’s level (level 2) have nextRight set,
before we try to set the nextRight of 9. So when we set the nextRight of 9, we search for a nonleaf node on
right side of node 4 (getNextRight() does this for us).

1 -------------- Level 0
/ \
2 3 -------------- Level 1
/ \ / \
4 5 6 7 -------------- Level 2
/ \ / \
8 9 10 11 -------------- Level 3

void connectRecur(struct node* p);

struct node *getNextRight(struct node *p);
// Sets the nextRight of root and calls connectRecur() for other nodes
void connect (struct node *p)
{
// Set the nextRight for root
// Set the next right for rest of the nodes (other than root)
connectRecur(p);
}
/* Set next right of all descendents of p. This function makes sure that
nextRight of nodes ar level i is set before level i+1 nodes. */
void connectRecur(struct node* p)
{
// Base case
if (!p)
return;
/* Before setting nextRight of left and right children, set nextRight

of children of other nodes at same level (because we can access
children of other nodes using p's nextRight only) */
if (p->nextRight != NULL)
connectRecur(p->nextRight);
/* Set the nextRight pointer for p's left child */

if (p->left)
{
if (p->right)
{
p->left->nextRight = p->right;
p->right->nextRight = getNextRight(p);
}
else
p->left->nextRight = getNextRight(p);
/* Recursively call for next level nodes. Note that we call only
for left child. The call for left child will call for right child */
connectRecur(p->left);
}
/* If left child is NULL then first node of next level will either be
p->right or getNextRight(p) */
else if (p->right)
{
p->right->nextRight = getNextRight(p);
}
else
connectRecur(getNextRight(p));
}
/* This function returns the leftmost child of nodes at the same level as p.
This function is used to getNExt right of p's right child
If right child of p is NULL then this can also be used for the left child */
struct node *getNextRight(struct node *p)
{
struct node *temp = p->nextRight;
/* Traverse nodes at p's level and find and return

the first node's first child */
while(temp != NULL)
{
if(temp->left != NULL)
return temp->left;
if(temp->right != NULL)
return temp->right;
temp = temp->nextRight;
}
// If all the nodes at p's level are leaf nodes then return NULL
return NULL;
}
An Iterative Solution
The recursive approach discussed above can be easily converted to iterative. In the iterative version, we use
nested loop. The outer loop, goes through all the levels and the inner loop goes through all the nodes at every
level. This solution uses constant space.
#include <stdio.h>
#include <stdlib.h>
struct node
{
int data;
struct node *left;
struct node *right;
struct node *nextRight;
};
/* This function returns the leftmost child of nodes at the same level as p.
This function is used to getNExt right of p's right child
If right child of is NULL then this can also be sued for the left child */
struct node *getNextRight(struct node *p)
{
struct node *temp = p->nextRight;
/* Traverse nodes at p's level and find and return

the first node's first child */
{
if (temp->left != NULL)
return temp->left;
if (temp->right != NULL)
return temp->right;
temp = temp->nextRight;
}
// If all the nodes at p's level are leaf nodes then return NULL
return NULL;
}
/* Sets nextRight of all nodes of a tree with root as p */

void connect(struct node* p)
{
struct node *temp;
if (!p)
return;
// Set nextRight for root

// set nextRight of all levels one by one

while (p != NULL)
{
struct node *q = p;
/* Connect all childrem nodes of p and children nodes of all other nodes
at same level as p */
while (q != NULL)
{
// Set the nextRight pointer for p's left child
if (q->left)
{
// If q has right child, then right child is nextRight of
// p and we also need to set nextRight of right child
if (q->right)
q->left->nextRight = q->right;
else
q->left->nextRight = getNextRight(q);
}
if (q->right)
q->right->nextRight = getNextRight(q);
// Set nextRight for other nodes in pre order fashion

q = q->nextRight;
}
// start from the first node of next level

if (p->left)
p = p->left;
else if (p->right)
p = p->right;
else
p = getNextRight(p);
}
}
{
node->data = data;
node->left = NULL;
node->right = NULL;
node->nextRight = NULL;
return(node);
}

int main()
{

10
/ \
8 2
/ \
3 90
*/
root->right->right = newnode(90);

connect(root);
// Let us check the values of nextRight pointers

printf("Following are populated nextRight pointers in the tree "
"(-1 is printed if there is no nextRight) \n");
printf("nextRight of %d is %d \n", root->data,
root->nextRight? root->nextRight->data: -1);
printf("nextRight of %d is %d \n", root->left->data,
root->left->nextRight? root->left->nextRight->data: -1);
printf("nextRight of %d is %d \n", root->right->data,
root->right->nextRight? root->right->nextRight->data: -1);
printf("nextRight of %d is %d \n", root->left->left->data,
root->left->left->nextRight? root->left->left->nextRight->data: -1);
printf("nextRight of %d is %d \n", root->right->right->data,
root->right->right->nextRight? root->right->right->nextRight->data: -1);
getchar();
return 0;
}

Output:
Following are populated nextRight pointers in the tree (-1 is printed if

there is no nextRight)
nextRight of 10 is -1
nextRight of 8 is 2
nextRight of 3 is 90

discussed above.
Find the maximum element in an array which is first increasing and then
decreasing
Given an array of integers which is initially increasing and then decreasing, find the maximum value in the
array.
Input: arr[] = {8, 10, 20, 80, 100, 200, 400, 500, 3, 2, 1}
Output: 500
Input: arr[] = {1, 3, 50, 10, 9, 7, 6}

Output: 50
Corner case (No decreasing part)

Input: arr[] = {10, 20, 30, 40, 50}
Output: 50
Corner case (No increasing part)

Input: arr[] = {120, 100, 80, 20, 0}
Output: 120


We can traverse the array and keep track of maximum and element. And finally return the maximum
element.
#include <stdio.h>
int findMaximum(int arr[], int low, int high)

{
int max = arr[low];
int i;
for (i = low; i <= high; i++)
{
if (arr[i] > max)
max = arr[i];
}
return max;
}

int main()
{
int arr[] = {1, 30, 40, 50, 60, 70, 23, 20};
printf("The maximum element is %d", findMaximum(arr, 0, n-1));
getchar();
return 0;
}


We can modify the standard Binary Search algorithm for the given type of arrays.
i) If the mid element is greater than both of its adjacent elements, then mid is the maximum.
ii) If mid element is greater than its next element and smaller than the previous element then maximum lies
on left side of mid. Example array: {3, 50, 10, 9, 7, 6}
iii) If mid element is smaller than its next element and greater than the previous element then maximum lies
on right side of mid. Example array: {2, 4, 6, 8, 10, 3, 1}
#include <stdio.h>
int findMaximum(int arr[], int low, int high)

{
/* Base Case: Only one element is present in arr[low..high]*/

if (low == high)
return arr[low];
/* If there are two elements and first is greater then

the first element is maximum */
if ((high == low + 1) && arr[low] >= arr[high])
return arr[low];
/* If there are two elements and second is greater then

the second element is maximum */
if ((high == low + 1) && arr[low] < arr[high])
return arr[high];
/* If we reach a point where arr[mid] is greater than both of

its adjacent elements arr[mid-1] and arr[mid+1], then arr[mid]
is the maximum element*/
if ( arr[mid] > arr[mid + 1] && arr[mid] > arr[mid - 1])
return arr[mid];
/* If arr[mid] is greater than the next element and smaller than the previous
element then maximum lies on left side of mid */
if (arr[mid] > arr[mid + 1] && arr[mid] < arr[mid - 1])
return findMaximum(arr, low, mid-1);
else // when arr[mid] is greater than arr[mid-1] and smaller than arr[mid+1]
return findMaximum(arr, mid + 1, high);
}

int main()
{
int arr[] = {1, 3, 50, 10, 9, 7, 6};
printf("The maximum element is %d", findMaximum(arr, 0, n-1));
getchar();
return 0;
}

This method works only for distinct numbers. For example, it will not work for an array like {0, 1, 1, 2, 2, 2,
2, 2, 3, 4, 4, 5, 3, 3, 2, 2, 1, 1}.
discussed above.
Sorted Linked List to Balanced BST
Given a Singly Linked List which has data members sorted in ascending order. Construct a Balanced Binary
Search Tree which has same data members as the given Linked List.
Examples:
Input: Linked List 1->2->3

Output: A Balanced BST
2
/ \
1 3
Input: Linked List 1->2->3->4->5->6->7

4
/ \
2 6
/ \ / \
1 3 4 7
Input: Linked List 1->2->3->4

3
/ \
2 4
/
1
Input: Linked List 1->2->3->4->5->6

4
/ \
2 6
/ \ /
1 3 5

Method 1 (Simple)
Following is a simple algorithm where we first find the middle node of list and make it root of the tree to be
constructed.
1) Get the Middle of the linked list and make it root.

2) Recursively do same for left half and right half.
a) Get the middle of left half and make it left child of the root
created in step 1.
b) Get the middle of right half and make it right child of the
root created in step 1.
Time complexity: O(nLogn) where n is the number of nodes in Linked List.
See this forum thread for more details.

Method 2 (Tricky)
The method 1 constructs the tree from root to leaves. In this method, we construct from leaves to root. The
idea is to insert nodes in BST in the same order as the appear in Linked List, so that the tree can be
constructed in O(n) time complexity. We first count the number of nodes in the given Linked List. Let the
count be n. After counting nodes, we take left n/2 nodes and recursively construct the left subtree. After left
subtree is constructed, we allocate memory for root and link the left subtree with root. Finally, we recursively
construct the right subtree and link it with root.
While constructing the BST, we also keep moving the list head pointer to next so that we have the
appropriate pointer in each recursive call.
Following is C implementation of method 2. The main code which creates Balanced BST is highlighted.
#include<stdio.h>
#include<stdlib.h>

struct LNode
{
int data;
struct LNode* next;
};
/* A Binary Tree node */

struct TNode
{
int data;
struct TNode* left;
struct TNode* right;
};
struct TNode* newNode(int data);

int countLNodes(struct LNode *head);
struct TNode* sortedListToBSTRecur(struct LNode **head_ref, int n);
/* This function counts the number of nodes in Linked List and then calls
sortedListToBSTRecur() to construct BST */
struct TNode* sortedListToBST(struct LNode *head)
{
/*Count the number of nodes in Linked List */
int n = countLNodes(head);
/* Construct BST */
return sortedListToBSTRecur(&head, n);
}
/* The main function that constructs balanced BST and returns root of it.
head_ref --> Pointer to pointer to head node of linked list
n --> No. of nodes in Linked List */
struct TNode* sortedListToBSTRecur(struct LNode **head_ref, int n)
{
/* Base Case */
if (n <= 0)
return NULL;
/* Recursively construct the left subtree */

struct TNode *left = sortedListToBSTRecur(head_ref, n/2);
/* Allocate memory for root, and link the above constructed left
subtree with root */
subtree with root */
struct TNode *root = newNode((*head_ref)->data);
root->left = left;
/* Change head pointer of Linked List for parent recursive calls */

/* Recursively construct the right subtree and link it with root

The number of nodes in right subtree is total nodes - nodes in
left subtree - 1 (for root) which is n-n/2-1*/
root->right = sortedListToBSTRecur(head_ref, n-n/2-1);
return root;
}
/* A utility function that returns count of nodes in a given Linked List */

int countLNodes(struct LNode *head)
{
int count = 0;
struct LNode *temp = head;
while(temp)
{
temp = temp->next;
count++;
}
return count;
}

void push(struct LNode** head_ref, int new_data)
{
/* allocate node */
struct LNode* new_node =
(struct LNode*) malloc(sizeof(struct LNode));


}

void printList(struct LNode *node)
{
while(node!=NULL)
{
node = node->next;
}
}

struct TNode* newNode(int data)
{
struct TNode* node = (struct TNode*)
malloc(sizeof(struct TNode));
node->data = data;
node->data = data;
node->left = NULL;
node->right = NULL;
return node;
}
/* A utility function to print preorder traversal of BST */

void preOrder(struct TNode* node)
{
if (node == NULL)
return;
preOrder(node->left);
preOrder(node->right);
}

int main()
{
struct LNode* head = NULL;

Created linked list will be 1->2->3->4->5->6->7 */
push(&head, 7);
push(&head, 6);
push(&head, 5);
push(&head, 4);
push(&head, 3);
push(&head, 2);
push(&head, 1);
printf("\n Given Linked List ");

printList(head);
/* Convert List to BST */

struct TNode *root = sortedListToBST(head);
printf("\n PreOrder Traversal of constructed BST ");
preOrder(root);
return 0;
}

discussed above.
Sorted Array to Balanced BST
Given a sorted array. Write a function that creates a Balanced Binary Search Tree using array elements.
Examples:
Input: Array {1, 2, 3}

2
/ \
1 3
Input: Array {1, 2, 3, 4}

3
/ \
2 4
/
1

Algorithm
In the previous post, we discussed construction of BST from sorted Linked List. Constructing from sorted
array in O(n) time is simpler as we can get the middle element in O(1) time. Following is a simple algorithm
where we first find the middle node of list and make it root of the tree to be constructed.
1) Get the Middle of the array and make it root.

created in step 1.

Following is C implementation of the above algorithm. The main code which creates Balanced BST is
highlighted.
#include<stdio.h>
#include<stdlib.h>
/* A Binary Tree node */

struct TNode
{
int data;
struct TNode* left;
struct TNode* right;
};
struct TNode* newNode(int data);
/* A function that constructs Balanced Binary Search Tree from a sorted array */
struct TNode* sortedArrayToBST(int arr[], int start, int end)
{
/* Base Case */
/* Base Case */
if (start > end)
return NULL;
/* Get the middle element and make it root */

int mid = (start + end)/2;
struct TNode *root = newNode(arr[mid]);
/* Recursively construct the left subtree and make it

left child of root */
root->left = sortedArrayToBST(arr, start, mid-1);
/* Recursively construct the right subtree and make it

right child of root */
root->right = sortedArrayToBST(arr, mid+1, end);
return root;
}

struct TNode* newNode(int data)
{
struct TNode* node = (struct TNode*)
malloc(sizeof(struct TNode));
node->data = data;
node->left = NULL;
node->right = NULL;
return node;
}

void preOrder(struct TNode* node)
{
if (node == NULL)
return;
preOrder(node->left);
preOrder(node->right);
}

int main()
{
int arr[] = {1, 2, 3, 4, 5, 6, 7};

struct TNode *root = sortedArrayToBST(arr, 0, n-1);
preOrder(root);
return 0;
}


Following is the recurrance relation for sortedArrayToBST().

T(n) = 2T(n/2) + C
T(n) --> Time taken for an array of size n
C --> Constant (Finding middle of array and linking root to left
and right subtrees take constant time)

The above recurrence can be solved using Master Theorem as it falls in case 2.
discussed above.
Average of a stream of numbers
Given a stream of numbers, print average (or mean) of the stream at every point. For example, let us consider
the stream as 10, 20, 30, 40, 50, 60, …
Average of 1 numbers is 10.00

..................

To print mean of a stream, we need to find out how to find average when a new number is being added to the
stream. To do this, all we need is count of numbers seen so far in the stream, previous average and new
number. Let n be the count, prev_avg be the previous average and x be the new number being added. The
average after including x number can be written as (prev_avg*n + x)/(n+1).
#include <stdio.h>
// Returns the new average after including x

float getAvg(float prev_avg, int x, int n)
{
return (prev_avg*n + x)/(n+1);
}
// Prints average of a stream of numbers

void streamAvg(float arr[], int n)
{
float avg = 0;
for(int i = 0; i < n; i++)
{
avg = getAvg(avg, arr[i], i);
printf("Average of %d numbers is %f \n", i+1, avg);
}
return;
}

int main()
{
float arr[] = {10, 20, 30, 40, 50, 60};
streamAvg(arr, n);
return 0;
}

The above function getAvg() can be optimized using following changes. We can avoid the use of prev_avg
and number of elements by using static variables (Assuming that only this function is called for average of
stream). Following is the oprimnized version.

#include <stdio.h>
// Returns the new average after including x

float getAvg (int x)
{
static int sum, n;
sum += x;
return (((float)sum)/++n);
}
// Prints average of a stream of numbers

void streamAvg(float arr[], int n)
{
float avg = 0;
for(int i = 0; i < n; i++)
{
avg = getAvg(arr[i]);
printf("Average of %d numbers is %f \n", i+1, avg);
}
return;
}

int main()
{
float arr[] = {10, 20, 30, 40, 50, 60};
streamAvg(arr, n);
return 0;
}

Thanks to Abhijeet Deshpande for suggesting this optimized version.
discussed above.
Count smaller elements on right side
Write a function to count number of smaller elements on right of each element in an array. Given an
unsorted array arr[] of distinct integers, construct another array countSmaller[] such that countSmaller[i]
contains count of smaller elements on right side of each element arr[i] in array.
Examples:
Input: arr[] = {12, 1, 2, 3, 0, 11, 4}

Output: countSmaller[] = {6, 1, 1, 1, 0, 1, 0}
(Corner Cases)
Input: arr[] = {5, 4, 3, 2, 1}
Output: countSmaller[] = {4, 3, 2, 1, 0}
Input: arr[] = {1, 2, 3, 4, 5}

Output: countSmaller[] = {0, 0, 0, 0, 0}

Method 1 (Simple)
Use two loops. The outer loop picks all elements from left to right. The inner loop iterates through all the
elements on right side of the picked element and updates countSmaller[].

void constructLowerArray (int *arr[], int *countSmaller, int n)

{
int i, j;
// initialize all the counts in countSmaller array as 0

for (i = 0; i < n; i++)
countSmaller[i] = 0;
for (i = 0; i < n; i++)

{
for (j = i+1; j < n; j++)
{
if (arr[j] < arr[i])
countSmaller[i]++;
}
}
}
/* Utility function that prints out an array on a line */

{
int i;
printf("\n");
}

int main()
{
int arr[] = {12, 10, 5, 4, 2, 20, 6, 1, 0, 2};
int *low = (int *)malloc(sizeof(int)*n);
constructLowerArray(arr, low, n);
printArray(low, n);
return 0;
}


Method 2 (Use Self Balancing BST)

A Self Balancing Binary Search Tree (AVL, Red Black,.. etc) can be used to get the solution in O(nLogn) time
complexity. We can augment these trees so that every node N contains size the subtree rooted with N. We
have used AVL tree in the following implementation.
We traverse the array from right to left and insert all elements one by one in an AVL tree. While inserting a
new key in an AVL tree, we first compare the key with root. If key is greater than root, then it is greater than
all the nodes in left subtree of root. So we add the size of left subtree to the count of smaller element for the
key being inserted. We recursively follow the same approach for all nodes down the root.
Following is C implementation.

#include<stdio.h>
#include<stdlib.h>
// An AVL tree node

struct node
{
int key;
struct node *left;
struct node *right;
int height;
int size; // size of the tree rooted with this node
};
// A utility function to get maximum of two integers

// A utility function to get height of the tree rooted with N

int height(struct node *N)
{
if (N == NULL)
return 0;
return N->height;
}
// A utility function to size of the tree of rooted with N

int size(struct node *N)
{
if (N == NULL)
return 0;
return N->size;
}

{
}
/* Helper function that allocates a new node with the given key and
struct node* newNode(int key)
{
node->key = key;
node->left = NULL;
node->right = NULL;
node->height = 1; // new node is initially added at leaf
node->size = 1;
return(node);
}
// A utility function to right rotate subtree rooted with y

struct node *rightRotate(struct node *y)
{
struct node *x = y->left;
struct node *T2 = x->right;
// Perform rotation
x->right = y;
y->left = T2;
// Update heights
y->height = max(height(y->left), height(y->right))+1;
x->height = max(height(x->left), height(x->right))+1;
// Update sizes
y->size = size(y->left) + size(y->right) + 1;
x->size = size(x->left) + size(x->right) + 1;
// Return new root

return x;
}
// A utility function to left rotate subtree rooted with x

struct node *leftRotate(struct node *x)
{
struct node *y = x->right;
struct node *T2 = y->left;
// Perform rotation
y->left = x;
x->right = T2;
// Update heights
// Update sizes
// Return new root

return y;
}
// Get Balance factor of node N

int getBalance(struct node *N)
{
if (N == NULL)
return 0;
return height(N->left) - height(N->right);
}
// Inserts a new key to the tree rotted with node. Also, updates *count
// to contain count of smaller elements for the new key
struct node* insert(struct node* node, int key, int *count)
{
/* 1. Perform the normal BST rotation */
if (node == NULL)
return(newNode(key));
if (key < node->key)

node->left = insert(node->left, key, count);
else
{
node->right = insert(node->right, key, count);
// UPDATE COUNT OF SMALLER ELEMENTS FOR KEY

*count = *count + size(node->left) + 1;
}
/* 2. Update height and size of this ancestor node */

node->height = max(height(node->left), height(node->right)) + 1;
node->size = size(node->left) + size(node->right) + 1;
/* 3. Get the balance factor of this ancestor node to check whether

this node became unbalanced */
int balance = getBalance(node);
// If this node becomes unbalanced, then there are 4 cases
// Left Left Case

if (balance > 1 && key < node->left->key)
return rightRotate(node);
// Right Right Case

if (balance < -1 && key > node->right->key)
return leftRotate(node);
// Left Right Case

if (balance > 1 && key > node->left->key)
{
node->left = leftRotate(node->left);
}
// Right Left Case

if (balance < -1 && key < node->right->key)
{
node->right = rightRotate(node->right);
}

return node;
}
// The following function updates the countSmaller array to contain count of

// smaller elements on right side.
void constructLowerArray (int arr[], int countSmaller[], int n)
{
int i, j;
struct node *root = NULL;
// initialize all the counts in countSmaller array as 0

for (i = 0; i < n; i++)
countSmaller[i] = 0;
// Starting from rightmost element, insert all elements one by one in

// an AVL tree and get the count of smaller elements
for (i = n-1; i >= 0; i--)
{
root = insert(root, arr[i], &countSmaller[i]);
}
}
/* Utility function that prints out an array on a line */

{
int i;
printf("\n");
}

int main()
{
int arr[] = {10, 6, 15, 20, 30, 5, 7};
int *low = (int *)malloc(sizeof(int)*n);
constructLowerArray(arr, low, n);
printf("Following is the constructed smaller count array");

printArray(low, n);
return 0;
}

Output:

Following is the constructed smaller count array
3 1 2 2 2 0 0


discussed above.
Minimum number of jumps to reach end
Given an array of integers where each element represents the max number of steps that can be made forward
from that element. Write a function to return the minimum number of jumps to reach the end of the array
(starting from the first element). If an element is 0, then cannot move through that element.
Example:
Input: arr[] = {1, 3, 5, 8, 9, 2, 6, 7, 6, 8, 9}

Output: 3 (1-> 3 -> 8 ->9)

First element is 1, so can only go to 3. Second element is 3, so can make at most 3 steps eg to 5 or 8 or 9.
Method 1 (Naive Recursive Approach)

A naive approach is to start from the first element and recursively call for all the elements reachable from
first element. The minimum number of jumps to reach end from first can be calculated using minimum
number of jumps needed to reach end from the elements reachable from first.
minJumps(start, end) = Min ( minJumps(k, end) ) for all k reachable from start

#include <stdio.h>
#include <limits.h>
// Returns minimum number of jumps to reach arr[h] from arr[l]

int minJumps(int arr[], int l, int h)
{
// Base case: when source and destination are same
if (h == l)
return 0;
// When nothing is reachable from the given source

if (arr[l] == 0)
return INT_MAX;
// Traverse through all the points reachable from arr[l]. Recursively

// get the minimum number of jumps needed to reach arr[h] from these
// reachable points.
int min = INT_MAX;
for (int i = l+1; i <= h && i <= l + arr[l]; i++)
{
int jumps = minJumps(arr, i, h);
if(jumps != INT_MAX && jumps + 1 < min)
min = jumps + 1;
}
return min;
}

int main()
{
int arr[] = {1, 3, 6, 3, 2, 3, 6, 8, 9, 5};
printf("Minimum number of jumps to reach end is %d ", minJumps(arr, 0, n-1));
return 0;
}

If we trace the execution of this method, we can see that there will be overlapping subproblems. For example,
minJumps(3, 9) will be called two times as arr[3] is reachable from arr[1] and arr[2]. So this problem has
both properties (optimal substructure and overlapping subproblems) of Dynamic Programming.
Method 2 (Dynamic Programming)

In this method, we build a jumps[] array from left to right such that jumps[i] indicates the minimum number
of jumps needed to reach arr[i] from arr[0]. Finally, we return jumps[n-1].

#include <stdio.h>
#include <limits.h>
int min(int x, int y) { return (x < y)? x: y; }
// Returns minimum number of jumps to reach arr[n-1] from arr[0]

int minJumps(int arr[], int n)
{
int *jumps = new int[n]; // jumps[n-1] will hold the result
int i, j;
if (n == 0 || arr[0] == 0)
return INT_MAX;
jumps[0] = 0;
// Find the minimum number of jumps to reach arr[i]

// from arr[0], and assign this value to jumps[i]
for (i = 1; i < n; i++)
{
jumps[i] = INT_MAX;
for (j = 0; j < i; j++)
{
if (i <= j + arr[j] && jumps[j] != INT_MAX)
{
jumps[i] = min(jumps[i], jumps[j] + 1);
break;
}
}
}
return jumps[n-1];
}

int main()
{
int arr[] = {1, 3, 6, 1, 0, 9};
int size = sizeof(arr)/sizeof(int);
printf("Minimum number of jumps to reach end is %d ", minJumps(arr,size));
return 0;
}

Output:

Minimum number of jumps to reach end is 3

Thanks to paras for suggesting this method.

In this method, we build jumps[] array from right to left such that jumps[i] indicates the minimum number
of jumps needed to reach arr[n-1] from arr[i]. Finally, we return arr[0].

int minJumps(int arr[], int n)

{
int *jumps = new int[n]; // jumps[0] will hold the result
int min;
// Minimum number of jumps needed to reach last element

// from last elements itself is always 0
jumps[n-1] = 0;
int i, j;
// Start from the second element, move from right to left

// and construct the jumps[] array where jumps[i] represents
// minimum number of jumps needed to reach arr[m-1] from arr[i]
for (i = n-2; i >=0; i--)
{
// If arr[i] is 0 then arr[n-1] can't be reached from here
if (arr[i] == 0)
jumps[i] = INT_MAX;
// If we can direcly reach to the end point from here then

// jumps[i] is 1
else if (arr[i] >= n - i - 1)
jumps[i] = 1;
// Otherwise, to find out the minimum number of jumps needed

// to reach arr[n-1], check all the points reachable from here
// and jumps[] value for those points
else
{
min = INT_MAX; // initialize min value
// following loop checks with all reachable points and

// takes the minimum
for (j = i+1; j < n && j <= arr[i] + i; j++)
{
if (min > jumps[j])
min = jumps[j];
}
// Handle overflow
if (min != INT_MAX)
jumps[i] = min + 1;
else
jumps[i] = min; // or INT_MAX
}
}
return jumps[0];
}

Time Complexity: O(n^2) in worst case.
Thanks to Ashish for suggesting this solution.
discussed above.
Populate Inorder Successor for all nodes
Given a Binary Tree where each node has following structure, write a function to populate next pointer for
all nodes. The next pointer for every node should be set to point to inorder successor.
struct node
{
int data;
struct node* left;
struct node* right;
struct node* next;
}

Initially, all next pointers have NULL values. Your function should fill these next pointers so that they point
to inorder successor.
Solution (Use Reverse Inorder Traversal)

Traverse the given tree in reverse inorder traversal and keep track of previously visited node. When a node is
being visited, assign previously visited node as next.
#include <stdio.h>
#include <stdlib.h>
struct node
{
int data;
struct node *left;
struct node *right;
struct node *next;
};
/* Set next of p and all descendents of p by traversing them in reverse Inorder */

void populateNext(struct node* p)
{
// The first visited node will be the rightmost node
// next of the rightmost node will be NULL
static struct node *next = NULL;
if (p)
{
// First set the next pointer in right subtree
populateNext(p->right);
// Set the next as previously visited node in reverse Inorder

p->next = next;
// Change the prev for subsequent node

next = p;
// Finally, set the next pointer in left subtree

populateNext(p->left);
}
}
{
node->data = data;
node->left = NULL;
node->right = NULL;
node->next = NULL;
return(node);
}

int main()
{

10
/ \
8 12
/
3
*/

populateNext(root);
// Let us see the populated values

struct node *ptr = root->left->left;
while(ptr)
{
// -1 is printed if there is no successor
printf("Next of %d is %d \n", ptr->data, ptr->next? ptr->next->data: -1);
ptr = ptr->next;
}
return 0;
}

We can avoid the use of static variable by passing reference to next as paramater.

// An implementation that doesn't use static variable
// A wrapper over populateNextRecur

void populateNext(struct node *root)
{
// The first visited node will be the rightmost node
// next of the rightmost node will be NULL
struct node *next = NULL;
populateNextRecur(root, &next);
}
/* Set next of all descendents of p by traversing them in reverse Inorder */

void populateNextRecur(struct node* p, struct node **next_ref)
{
if (p)
{
// First set the next pointer in right subtree
populateNextRecur(p->right, next_ref);
// Set the next as previously visited node in reverse Inorder

p->next = *next_ref;
// Change the prev for subsequent node

*next_ref = p;
// Finally, set the next pointer in right subtree

populateNextRecur(p->left, next_ref);
}
}

discussed above.
Dynamic Programming | Set 7 (Coin Change)
Given a value N, if we want to make change for N cents, and we have infinite supply of each of S = { S1, S2, .. ,
Sm} valued coins, how many ways can we make the change? The order of coins doesn’t matter.
For example, for N = 4 and S = {1,2,3}, there are four solutions: {1,1,1,1},{1,1,2},{2,2},{1,3}. So output should
be 4. For N = 10 and S = {2, 5, 3, 6}, there are five solutions: {2,2,2,2,2}, {2,2,3,3}, {2,2,6}, {2,3,5} and {5,5}.
So the output should be 5.
To count total number solutions, we can divide all set solutions in two sets.
1) Solutions that do not contain mth coin (or Sm).
2) Solutions that contain at least one Sm.
Let count(S[], m, n) be the function to count the number of solutions, then it can be written as sum of
count(S[], m-1, n) and count(S[], m, n-Sm).
Therefore, the problem has optimal substructure property as the problem can be solved using solutions to
subproblems.
Following is a simple recursive implementation of the Coin Change problem. The implementation simply
follows the recursive structure mentioned above.
#include<stdio.h>
// Returns the count of ways we can sum S[0...m-1] coins to get sum n
int count( int S[], int m, int n )
{
// If n is 0 then there is 1 solution (do not include any coin)
if (n == 0)
return 1;

// If n is less than 0 then no solution exists
if (n < 0)
return 0;
// If there are no coins and n is greater than 0, then no solution exist

if (m <=0 && n >= 1)
return 0;
// count is sum of solutions (i) including S[m-1] (ii) excluding S[m-1]

return count( S, m - 1, n ) + count( S, m, n-S[m-1] );
}

int main()
{
int i, j;
int arr[] = {1, 2, 3};
int m = sizeof(arr)/sizeof(arr[0]);
printf("%d ", count(arr, m, 4));
getchar();
return 0;
}

following recursion tree for S = {1, 2, 3} and n = 5.
The function C({1}, 3) is called two times. If we draw the complete tree, then we can see that there are many
subproblems being called more than once.
C() --> count()

C({1,2,3}, 5)
/ \
/ \
C({1,2,3}, 2) C({1,2}, 5)
/ \ / \
/ \ / \
C({1,2,3}, -1) C({1,2}, 2) C({1,2}, 3) C({1}, 5)
/ \ / \ / \
/ \ / \ / \
C({1,2},0) C({1},2) C({1,2},1) C({1},3) C({1}, 4) C({}, 5)
/ \ / \ / \ / \
/ \ / \ / \ / \
. . . . . . C({1}, 3) C({}, 4)
/ \
/ \
. .

Since same suproblems are called again, this problem has Overlapping Subprolems property. So the Coin
Change problem has both properties (see this and this) of a dynamic programming problem. Like other
constructing a temporary array table[][] in bottom up manner.
Dynamic Programming Solution

#include<stdio.h>

{
int i, j, x, y;
// We need n+1 rows as the table is consturcted in bottom up manner using

// the base case 0 value case (n = 0)
int table[n+1][m];

// Fill the enteries for 0 value case (n = 0)
for (i=0; i<m; i++)
table[0][i] = 1;
// Fill rest of the table enteries in bottom up manner

for (i = 1; i < n+1; i++)
{
for (j = 0; j < m; j++)
{
// Count of solutions including S[j]
x = (i-S[j] >= 0)? table[i - S[j]][j]: 0;
// Count of solutions excluding S[j]

y = (j >= 1)? table[i][j-1]: 0;
// total count
table[i][j] = x + y;
}
}
return table[n][m-1];
}

int main()
{
int arr[] = {1, 2, 3};
int n = 4;
printf(" %d ", count(arr, m, n));
return 0;
}

Time Complexity: O(mn)
Following is a simplified version of method 2. The auxiliary space required here is O(n) only.


{
// table[i] will be storing the number of solutions for
// value i. We need n+1 rows as the table is consturcted
// in bottom up manner using the base case (n = 0)
int table[n+1];
// Initialize all table values as 0

memset(table, 0, sizeof(table));
// Base case (If given value is 0)

table[0] = 1;
// Pick all coins one by one and update the table[] values
// after the index greater than or equal to the value of the
// picked coin
for(int i=0; i<m; i++)
for(int j=S[i]; j<=n; j++)
table[j] += table[j-S[i]];
return table[n];
}

Thanks to Rohan Laishram for suggesting this space optimized version.
discussed above.
References:
http://www.algorithmist.com/index.php/Coin_Change
Dynamic Programming | Set 8 (Matrix Chain Multiplication)
Given a sequence of matrices, find the most efficient way to multiply these matrices together. The problem is
not actually to perform the multiplications, but merely to decide in which order to perform the
multiplications.
We have many options to multiply a chain of matrices because matrix multiplication is associative. In other
words, no matter how we parenthesize the product, the result will be the same. For example, if we had four
matrices A, B, C, and D, we would have:
(ABC)D = (AB)(CD) = A(BCD) = ....

However, the order in which we parenthesize the product affects the number of simple arithmetic operations
needed to compute the product, or the efficiency. For example, suppose A is a 10 × 30 matrix, B is a 30 × 5
matrix, and C is a 5 × 60 matrix. Then,
(AB)C = (10×30×5) + (10×5×60) = 1500 + 3000 = 4500 operations

A(BC) = (30×5×60) + (10×30×60) = 9000 + 18000 = 27000 operations.

Clearly the first parenthesization requires less number of operations.
Given an array p[] which represents the chain of matrices such that the ith matrix Ai is of dimension p[i-1]
x p[i]. We need to write a function MatrixChainOrder() that should return the minimum number of
multiplications needed to multiply the chain.
Input: p[] = {40, 20, 30, 10, 30}

Output: 26000
There are 4 matrices of dimensions 40x20, 20x30, 30x10 and 10x30.
Let the input 4 matrices be A, B, C and D. The minimum number of
multiplications are obtained by putting parenthesis in following way
(A(BC))D --> 20*30*10 + 40*20*10 + 40*10*30
Input: p[] = {10, 20, 30, 40, 30}

Output: 30000
There are 4 matrices of dimensions 10x20, 20x30, 30x40 and 40x30.
Let the input 4 matrices be A, B, C and D. The minimum number of
multiplications are obtained by putting parenthesis in following way
((AB)C)D --> 10*20*30 + 10*30*40 + 10*40*30
Input: p[] = {10, 20, 30}

Output: 6000
There are only two matrices of dimensions 10x20 and 20x30. So there
is only one way to multiply the matrices, cost of which is 10*20*30

A simple solution is to place parenthesis at all possible places, calculate the cost for each placement and
return the minimum value. In a chain of matrices of size n, we can place the first set of parenthesis in n-1
ways. For example, if the given chain is of 4 matrices. let the chain be ABCD, then there are 3 way to place
first set of parenthesis: A(BCD), (AB)CD and (ABC)D. So when we place a set of parenthesis, we divide the
problem into subproblems of smaller size. Therefore, the problem has optimal substructure property and
can be easily solved using recursion.
Minimum number of multiplication needed to multiply a chain of size n = Minimum of all n-1 placements
(these placements create subproblems of smaller size)
Following is a recursive implementation that simply follows the above optimal substructure property.
/* A naive recursive implementation that simply follows the above optimal

substructure property */
#include<stdio.h>
#include<limits.h>
// Matrix Ai has dimension p[i-1] x p[i] for i = 1..n

int MatrixChainOrder(int p[], int i, int j)
{
if(i == j)
return 0;
int k;
int min = INT_MAX;
int count;
// place parenthesis at different places between first and last matrix,

// recursively calculate count of multiplcations for each parenthesis
// placement and return the minimum count
for (k = i; k <j; k++)
{
count = MatrixChainOrder(p, i, k) +
MatrixChainOrder(p, k+1, j) +
p[i-1]*p[k]*p[j];
if (count < min)

min = count;
}
// Return minimum count

return min;
}

int main()
{
int arr[] = {1, 2, 3, 4, 3};
printf("Minimum number of multiplications is %d ",

MatrixChainOrder(arr, 1, n-1));
getchar();
return 0;
}

Time complexity of the above naive recursive approach is exponential. It should be noted that the above
function computes the same subproblems again and again. See the following recursion tree for a matrix
chain of size 4. The function MatrixChainOrder(p, 3, 4) is called two times. We can see that there are many
subproblems being called more than once.
Since same suproblems are called again, this problem has Overlapping Subprolems property. So Matrix
Chain Multiplication problem has both properties (see this and this) of a dynamic programming problem.
Like other typical Dynamic Programming(DP) problems, recomputations of same subproblems can be
avoided by constructing a temporary array m[][] in bottom up manner.

Following is C/C++ implementation for Matrix Chain Multiplication problem using Dynamic Programming.

// See the Cormen book for details of the following algorithm

#include<stdio.h>
#include<limits.h>
// Matrix Ai has dimension p[i-1] x p[i] for i = 1..n

int MatrixChainOrder(int p[], int n)
{
/* For simplicity of the program, one extra row and one extra column are
allocated in m[][]. 0th row and 0th column of m[][] are not used */
int m[n][n];
int i, j, k, L, q;
/* m[i,j] = Minimum number of scalar multiplications needed to compute

the matrix A[i]A[i+1]...A[j] = A[i..j] where dimention of A[i] is
p[i-1] x p[i] */
// cost is zero when multiplying one matrix.

for (i = 1; i < n; i++)
m[i][i] = 0;
// L is chain length.
for (L=2; L<n; L++)
{
for (i=1; i<=n-L+1; i++)
{
j = i+L-1;
m[i][j] = INT_MAX;
for (k=i; k<=j-1; k++)
{
// q = cost/scalar multiplications
q = m[i][k] + m[k+1][j] + p[i-1]*p[k]*p[j];
if (q < m[i][j])
m[i][j] = q;
}
}
}
return m[1][n-1];
}
int main()
{
int arr[] = {1, 2, 3, 4};
printf("Minimum number of multiplications is %d ",

MatrixChainOrder(arr, size));
getchar();
return 0;
}


Auxiliary Space: O(n^2)
discussed above.
References:
http://en.wikipedia.org/wiki/Matrix_chain_multiplication
http://www.personal.kent.edu/~rmuhamma/Algorithms/MyAlgorithms/Dynamic/chainMatrixMult.htm
In-place conversion of Sorted DLL to Balanced BST
Given a Doubly Linked List which has data members sorted in ascending order. Construct a Balanced Binary
Search Tree which has same data members as the given Doubly Linked List. The tree must be constructed in-
place (No new node should be allocated for tree conversion)
Examples:
Input: Doubly Linked List 1 2 3

2
/ \
1 3
Input: Doubly Linked List 1 2 3 4 5 6 7

4
/ \
2 6
/ \ / \
1 3 4 7
Input: Doubly Linked List 1 2 3 4

3
/ \
2 4
/
1
Input: Doubly Linked List 1 2 3 4 5 6

4
/ \
2 6
/ \ /
1 3 5

The Doubly Linked List conversion is very much similar to this Singly Linked List problem and the method 1
is exactly same as the method 1 of previous post. Method 2 is also almost same. The only difference in
method 2 is, instead of allocating new nodes for BST, we reuse same DLL nodes. We use prev pointer as left
and next pointer as right.
Method 1 (Simple)
Following is a simple algorithm where we first find the middle node of list and make it root of the tree to be
constructed.

1) Get the Middle of the linked list and make it root.

created in step 1.
Time complexity: O(nLogn) where n is the number of nodes in Linked List.
Method 2 (Tricky)
The method 1 constructs the tree from root to leaves. In this method, we construct from leaves to root. The
idea is to insert nodes in BST in the same order as the appear in Doubly Linked List, so that the tree can be
constructed in O(n) time complexity. We first count the number of nodes in the given Linked List. Let the
count be n. After counting nodes, we take left n/2 nodes and recursively construct the left subtree. After left
subtree is constructed, we assign middle node to root and link the left subtree with root. Finally, we
recursively construct the right subtree and link it with root.
While constructing the BST, we also keep moving the list head pointer to next so that we have the
appropriate pointer in each recursive call.
Following is C implementation of method 2. The main code which creates Balanced BST is highlighted.
#include<stdio.h>
#include<stdlib.h>
/* A Doubly Linked List node that will also be used as a tree node */
struct Node
{
int data;
// For tree, next pointer can be used as right subtree pointer

struct Node* next;
// For tree, prev pointer can be used as left subtree pointer

struct Node* prev;
};
// A utility function to count nodes in a Linked List

int countNodes(struct Node *head);
struct Node* sortedListToBSTRecur(struct Node **head_ref, int n);
/* This function counts the number of nodes in Linked List and then calls
sortedListToBSTRecur() to construct BST */
struct Node* sortedListToBST(struct Node *head)
{
/*Count the number of nodes in Linked List */
int n = countNodes(head);
/* Construct BST */
return sortedListToBSTRecur(&head, n);
}
/* The main function that constructs balanced BST and returns root of it.
head_ref --> Pointer to pointer to head node of Doubly linked list
head_ref --> Pointer to pointer to head node of Doubly linked list
n --> No. of nodes in the Doubly Linked List */
struct Node* sortedListToBSTRecur(struct Node **head_ref, int n)
{
/* Base Case */
if (n <= 0)
return NULL;
/* Recursively construct the left subtree */

struct Node *left = sortedListToBSTRecur(head_ref, n/2);
/* head_ref now refers to middle node, make middle node as root of BST*/
struct Node *root = *head_ref;
// Set pointer to left subtree

root->prev = left;
/* Change head pointer of Linked List for parent recursive calls */

/* Recursively construct the right subtree and link it with root

The number of nodes in right subtree is total nodes - nodes in
left subtree - 1 (for root) */
root->next = sortedListToBSTRecur(head_ref, n-n/2-1);
return root;
}
/* A utility function that returns count of nodes in a given Linked List */
int countNodes(struct Node *head)
{
int count = 0;
struct Node *temp = head;
while(temp)
{
temp = temp->next;
count++;
}
return count;
}

void push(struct Node** head_ref, int new_data)
{
/* allocate node */
struct Node* new_node =
(struct Node*) malloc(sizeof(struct Node));





}

void printList(struct Node *node)
{
while(node!=NULL)
{
node = node->next;
}
}

void preOrder(struct Node* node)
{
if (node == NULL)
return;
preOrder(node->prev);
preOrder(node->next);
}

int main()
{
struct Node* head = NULL;

Created linked list will be 7->6->5->4->3->2->1 */
push(&head, 7);
push(&head, 6);
push(&head, 5);
push(&head, 4);
push(&head, 3);
push(&head, 2);
push(&head, 1);
printf("\n Given Linked List ");

printList(head);

struct Node *root = sortedListToBST(head);
preOrder(root);
return 0;
}

discussed above.
Print all permutations with repetition of characters
Given a string of length n, print all permutation of the given string. Repetition of characters is allowed. Print
these permutations in lexicographically sorted order
Examples:
Input: AB
Ouput: All permutations of AB with repetition are:
AA
AB
BA
BB
Input: ABC
Output: All permutations of ABC with repetition are:
AAA
AAB
AAC
ABA
...
...
CCB
CCC

For an input string of size n, there will be n^n permutations with repetition allowed. The idea is to fix the
first character at first index and recursively call for other subsequent indexes. Once all permutations starting
with the first character are printed, fix the second character at first index. Continue these steps till last
character. Thanks to PsychoCoder for providing following C implementation.
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
/* Following function is used by the library qsort() function to sort an

array of chars */
int compare (const void * a, const void * b);
/* The main function that recursively prints all repeated permutations of

the given string. It uses data[] to store all permutations one by one */
void allLexicographicRecur (char *str, char* data, int last, int index)
{
int i, len = strlen(str);
// One by one fix all characters at the given index and recur for the
// subsequent indexes
for ( i=0; i<len; i++ )
{
// Fix the ith character at index and if this is not the last index
// then recursively call for higher indexes
data[index] = str[i] ;
// If this is the last index then print the string stored in data[]
if (index == last)
printf("%s\n", data);
else // Recur for higher indexes
allLexicographicRecur (str, data, last, index+1);
allLexicographicRecur (str, data, last, index+1);
}
}
/* This function sorts input string, allocate memory for data (needed for
allLexicographicRecur()) and calls allLexicographicRecur() for printing all
permutations */
void allLexicographic(char *str)
{
int len = strlen (str) ;
// Create a temp array that will be used by allLexicographicRecur()

char *data = (char *) malloc (sizeof(char) * (len + 1)) ;
data[len] = '\0';
// Sort the input string so that we get all output strings in

// lexicographically sorted order
qsort(str, len, sizeof(char), compare);
// Now print all permutaions

allLexicographicRecur (str, data, len-1, 0);
// Free data to avoid memory leak

free(data);
}
// Needed for library function qsort()

int compare (const void * a, const void * b)
{
return ( *(char *)a - *(char *)b );
}

int main()
{
char str[] = "ABC";
printf("All permutations with repetition of %s are: \n", str);
allLexicographic(str);
getchar();
return 0;
}

Following is recursion tree for input string “AB”. The purpose of recursion tree is to help in understanding
the above implementation as it shows values of different variables.
data=""
/ \
/ \
index=0 index=0
i=0 i=1
data="A" data="B"
/ \ / \
/ \ / \
index=1 index=1 index=1 index=1
i=0 i=1 i=0 i=1
data="AA" data="AB" data="BA" data="BB"

In the above implementation, it is assumed that all characters of the input string are different. The
implementation can be easily modified to handle the repeated characters. We have to add a preprocessing
step to find unique characters (before calling allLexicographicRecur()).
discussed above.
Print all interleavings of given two strings
Given two strings str1 and str2, write a function that prints all interleavings of the given two strings. You may
assume that all characters in both strings are different
Example:
Input: str1 = "AB", str2 = "CD"

Output:
ABCD
ACBD
ACDB
CABD
CADB
CDAB
Input: str1 = "AB", str2 = "C"

Output:
ABC
ACB
CAB

An interleaved string of given two strings preserves the order of characters in individual strings. For
example, in all the interleavings of above first example, ‘A’ comes before ‘B’ and ‘C’ comes before ‘D’.
Let the length of str1 be m and the length of str2 be n. Let us assume that all characters in str1 and str2 are
different. Let count(m, n) be the count of all interleaved strings in such strings. The value of count(m, n) can
be written as following.
count(m, n) = count(m-1, n) + count(m, n-1)

count(1, 0) = 1 and count(0, 1) = 1

To print all interleavings, we can first fix the first character of str1[0..m-1] in output string, and recursively
call for str1[1..m-1] and str2[0..n-1]. And then we can fix the first character of str2[0..n-1] and recursively call
for str1[0..m-1] and str2[1..n-1]. Thanks to akash01 for providing following C implementation.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// The main function that recursively prints all interleavings. The variable
// iStr is used to store all interleavings (or output strings) one by one.
// i is used to pass next available place in iStr
void printIlsRecur (char *str1, char *str2, char *iStr, int m, int n, int i)
{
// Base case: If all characters of str1 and str2 have been included in
// output string, then print the output string
if ( m==0 && n ==0 )
{
printf("%s\n", iStr) ;
}
// If some characters of str1 are left to be included, then include the

// first character from the remaining characters and recur for rest
if ( m != 0 )
{
iStr[i] = str1[0];
printIlsRecur (str1 + 1, str2, iStr, m-1, n, i+1);
}
// If some characters of str2 are left to be included, then include the

// first character from the remaining characters and recur for rest
if ( n != 0 )
{
iStr[i] = str2[0];
printIlsRecur (str1, str2+1, iStr, m, n-1, i+1);
}
}
// Allocates memory for output string and uses printIlsRecur()

// for printing all interleavings
void printIls (char *str1, char *str2, int m, int n)
{
// allocate memory for the output string
char *iStr= (char*)malloc((m+n+1)*sizeof(char));
// Set the terminator for the output string

iStr[m+n] = '\0';
// print all interleavings using printIlsRecur()

printIlsRecur (str1, str2, iStr, m, n, 0);
// free memory to avoid memory leak

free(iStr);
}

int main()
{
char *str1 = "AB";
char *str2 = "CD";
printIls (str1, str2, strlen(str1), strlen(str2));
return 0;
}

discussed above.
Check whether a given string is an interleaving of two other given strings
Given three strings A, B and C. Write a function that checks whether C is an interleaving of A and B.
C is said to be interleaving A and B, if it contains all characters of A and B and order of all characters in
individual strings is preserved. See previous post for examples.
Solution:
Pick each character of C one by one and match it with the first character in A. If it doesn’t match then match
it with first character of B. If it doesn’t even match first character of B, then return false. If the character
matches with first character of A, then repeat the above process from second character of C, second
character of A and first character of B. If first character of C matches with the first character of B (and
doesn’t match the first character of A), then repeat the above process from the second character of C, first
character of A and second character of B. If all characters of C match either with a character of A or a
character of B and length of C is sum of lengths of A and B, then C is an interleaving A and B.
Thanks to venkat for suggesting following C implementation.

#include<stdio.h>
// Returns true if C is an interleaving of A and B, otherwise

// returns false
bool isInterleaved (char *A, char *B, char *C)
{
// Iterate through all characters of C.
while (*C != 0)
{
// Match first character of C with first character of A,
// If matches them move A to next
if (*A == *C)
A++;
// Else Match first character of C with first character of B,

// If matches them move B to next
else if (*B == *C)
B++;

// If doesn't match with either A or B, then return false
else
return false;

// Move C to next for next iteration
C++;
}
// If A or B still have some characters, then length of C is smaller

// than sum of lengths of A and B, so return false
if (*A || *B)
return false;
return true;
}

int main()
{
char *A = "AB";
char *B = "CD";
char *C = "ACBG";
if (isInterleaved(A, B, C) == true)
printf("%s is interleaved of %s and %s", C, A, B);
else
printf("%s is not interleaved of %s and %s", C, A, B);
return 0;
}

Output:
ACBG is not interleaved of AB and CD

Time Complexity: O(m+n) where m and n are the lengths of strings A and B respectively.
Note that the above approach doesn’t work if A and B have some characters in common. For example, if
string A = “AAB”, string B = “AAC” and string C = “AACAAB”, then the above method will return false. We
have discussed here an extended solution that handles common characters.
discussed above.
Dynamic Programming | Set 9 (Binomial Coefficient)
Following are common definition of Binomial Coefficients.
1) A binomial coefficient C(n, k) can be defined as the coefficient of X^k in the expansion of (1 + X)^n.
2) A binomial coefficient C(n, k) also gives the number of ways, disregarding order, that k objects can be
chosen from among n objects; more formally, the number of k-element subsets (or k-combinations) of an n-
element set.
The Problem
Write a function that takes two parameters n and k and returns the value of Binomial Coefficient C(n, k).
For example, your function should return 6 for n = 4 and k = 2, and it should return 10 for n = 5 and k = 2.
The value of C(n, k) can recursively calculated using following standard formula for Binomial Cofficients.
C(n, k) = C(n-1, k-1) + C(n-1, k)

C(n, 0) = C(n, n) = 1

Following is simple recursive implementation that simply follows the recursive structure mentioned above.
// A Naive Recursive Implementation

#include<stdio.h>
// Returns value of Binomial Coefficient C(n, k)

int binomialCoeff(int n, int k)
{
// Base Cases
if (k==0 || k==n)
return 1;
// Recur
return binomialCoeff(n-1, k-1) + binomialCoeff(n-1, k);
}

int main()
{
int n = 5, k = 2;
printf("Value of C(%d, %d) is %d ", n, k, binomialCoeff(n, k));
return 0;
}

following recursion tree for n = 5 an k = 2. The function C(3, 1) is called two times. For large values of n,
there will be many common subproblems.

C(5, 2)
/ \
C(4, 1) C(4, 2)
/ \ / \
C(3, 0) C(3, 1) C(3, 1) C(3, 2)
/ \ / \ / \
C(2, 0) C(2, 1) C(2, 0) C(2, 1) C(2, 1) C(2, 2)
/ \ / \ / \
C(1, 0) C(1, 1) C(1, 0) C(1, 1) C(1, 0) C(1, 1)

Since same suproblems are called again, this problem has Overlapping Subprolems property. So the
Binomial Coefficient problem has both properties (see this and this) of a dynamic programming problem.
Like other typical Dynamic Programming(DP) problems, recomputations of same subproblems can be
avoided by constructing a temporary array C[][] in bottom up manner. Following is Dynamic Programming
based implementation.

// A Dynamic Programming based solution that uses table C[][] to calculate the
// Binomial Coefficient
#include<stdio.h>
// Prototype of a utility function that returns minimum of two integers

int min(int a, int b);

{
int C[n+1][k+1];
int i, j;
// Caculate value of Binomial Coefficient in bottom up manner

for (i = 0; i <= n; i++)
{
for (j = 0; j <= min(i, k); j++)
{
// Base Cases
if (j == 0 || j == i)
C[i][j] = 1;
// Calculate value using previosly stored values

else
C[i][j] = C[i-1][j-1] + C[i-1][j];
}
}
return C[n][k];
}
// A utility function to return minimum of two integers

{
return (a<b)? a: b;
}

int main()
{
int n = 5, k = 2;
printf ("Value of C(%d, %d) is %d ", n, k, binomialCoeff(n, k) );
return 0;
}

Time Complexity: O(n*k)

Auxiliary Space: O(n*k)
Following is a space optimized version of the above code. The following code only uses O(k). Thanks to AK
for suggesting this method.

// A space optimized Dynamic Programming Solution

{
int* C = (int*)calloc(k+1, sizeof(int));
int i, j, res;
C[0] = 1;
for(i = 1; i <= n; i++)

{
for(j = min(i, k); j > 0; j--)
C[j] = C[j] + C[j-1];
}
res = C[k]; // Store the result before freeing memory
free(C); // free dynamically allocated memory to avoid memory leak
return res;
}

Time Complexity: O(n*k)

References:
http://www.csl.mtu.edu/cs4321/www/Lectures/Lecture%2015%20-
%20Dynamic%20Programming%20Binomial%20Coefficients.htm
discussed above.
Convert a given tree to its Sum Tree
Given a Binary Tree where each node has positive and negative values. Convert this to a tree where each
node contains the sum of the left and right sub trees in the original tree. The values of leaf nodes are changed
to 0.
For example, the following tree
10
/ \
-2 6
/ \ / \
8 -4 7 5

should be changed to
20(4-2+12+6)
/ \
4(8-4) 12(7+5)
/ \ / \
0 0 0 0

Solution:
Do a traversal of the given tree. In the traversal, store the old value of the current node, recursively call for
left and right subtrees and change the value of current node as sum of the values returned by the recursive
calls. Finally return the sum of new value and value (which is sum of values in the subtree rooted with this
node).
#include<stdio.h>

struct node
{
int data;
struct node *left;
struct node *right;
};
// Convert a given tree to a tree where every node contains sum of values of
// nodes in left and right subtrees in the original tree
int toSumTree(struct node *node)
{
// Base case
if(node == NULL)
return 0;
// Store the old value

int old_val = node->data;
// Recursively call for left and right subtrees and store the sum as
// new value of this node
node->data = toSumTree(node->left) + toSumTree(node->right);
// Return the sum of values of nodes in left and right subtrees and
// old_value of this node
return node->data + old_val;
}
// A utility function to print inorder traversal of a Binary Tree

{
if (node == NULL)
return;
}

{
temp->data = data;
temp->left = NULL;
temp->right = NULL;
return temp;
}

int main()
{
int x;

root = newNode(10);
root->left = newNode(-2);
root->left->right = newNode(-4);
toSumTree(root);
// Print inorder traversal of the converted tree to test result of toSumTree()

printf("Inorder Traversal of the resultant tree is: \n");
printInorder(root);
getchar();
return 0;
}

Output:
Inorder Traversal of the resultant tree is:

0 4 0 20 0 12 0

Time Complexity: The solution involves a simple traversal of the given tree. So the time complexity is O(n)
where n is the number of nodes in the given Binary Tree.
See this forum thread for the original question. Please write comments if you find anything incorrect, or you
Find the largest BST subtree in a given Binary Tree
Given a Binary Tree, write a function that returns the size of the largest subtree which is also a Binary Search
Tree (BST). If the complete Binary Tree is BST, then return the size of whole tree.
Examples:
Input:
5
/ \
2 4
/ \
1 3
Output: 3
The following subtree is the maximum size BST subtree
2
/ \
1 3
Input:
50
/ \
30 60
/ \ / \
5 20 45 70
/ \
65 80
Output: 5
The following subtree is the maximum size BST subtree
60
/ \
45 70
/ \
65 80

Method 1 (Simple but inefficient)

Start from root and do an inorder traversal of the tree. For each node N, check whether the subtree rooted
with N is BST or not. If BST, then return size of the subtree rooted with N. Else, recur down the left and right
subtrees and return the maximum of values returned by left and right subtrees.

/*
See http://www.geeksforgeeks.org/archives/632 for implementation of size()
See Method 3 of http://www.geeksforgeeks.org/archives/3042 for

implementation of isBST()
max() returns maximum of two integers

*/
int largestBST(struct node *root)
{
if (isBST(root))
return size(root);
else
return max(largestBST(root->left), largestBST(root->right));
}

Time Complexity: The worst case time complexity of this method will be O(n^2). Consider a skewed tree for
worst case analysis.

In method 1, we traverse the tree in top down manner and do BST test for every node. If we traverse the tree
in bottom up manner, then we can pass information about subtrees to the parent. The passed information
can be used by the parent to do BST test (for parent node) only in constant time (or O(1) time). A left subtree
need to tell the parent whether it is BST or not and also need to pass maximum value in it. So that we can
compare the maximum value with the parent’s data to check the BST property. Similarly, the right subtree
need to pass the minimum value up the tree. The subtrees need to pass the following information up the tree
for the finding the largest BST.
1) Whether the subtree itself is BST or not (In the following code, is_bst_ref is used for this purpose)
2) If the subtree is left subtree of its parent, then maximum value in it. And if it is right subtree then
minimum value in it.
3) Size of this subtree if this subtree is BST (In the following code, return value of largestBSTtil() is used for
this purpose)
max_ref is used for passing the maximum value up the tree and min_ptr is used for passing minimum value
up the tree.
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

struct node
{
int data;
struct node* left;
struct node* right;
};

{
node->data = data;
node->left = NULL;
node->right = NULL;
return(node);
}
int largestBSTUtil(struct node* node, int *min_ref, int *max_ref,

int *max_size_ref, bool *is_bst_ref);
/* Returns size of the largest BST subtree in a Binary Tree

int largestBST(struct node* node)
{
// Set the initial values for calling largestBSTUtil()
int min = INT_MAX; // For minimum value in right subtree
int max = INT_MIN; // For maximum value in left subtree
int max_size = 0; // For size of the largest BST

bool is_bst = 0;
largestBSTUtil(node, &min, &max, &max_size, &is_bst);
return max_size;
}
/* largestBSTUtil() updates *max_size_ref for the size of the largest BST

subtree. Also, if the tree rooted with node is non-empty and a BST,
then returns size of the tree. Otherwise returns 0.*/
int largestBSTUtil(struct node* node, int *min_ref, int *max_ref,
int *max_size_ref, bool *is_bst_ref)
{
/* Base Case */
if (node == NULL)
{
*is_bst_ref = 1; // An empty tree is BST
return 0; // Size of the BST is 0
}
int min = INT_MAX;
/* A flag variable for left subtree property

i.e., max(root->left) < root->data */
bool left_flag = false;
/* A flag variable for right subtree property

i.e., min(root->right) > root->data */
bool right_flag = false;
int ls, rs; // To store sizes of left and right subtrees
/* Following tasks are done by recursive call for left subtree

a) Get the maximum value in left subtree (Stored in *max_ref)
b) Check whether Left Subtree is BST or not (Stored in *is_bst_ref)
c) Get the size of maximum size BST in left subtree (updates *max_size) */
*max_ref = INT_MIN;
ls = largestBSTUtil(node->left, min_ref, max_ref, max_size_ref, is_bst_ref);
if (*is_bst_ref == 1 && node->data > *max_ref)
left_flag = true;
/* Before updating *min_ref, store the min value in left subtree. So that we
have the correct minimum value for this subtree */
min = *min_ref;
/* The following recursive call does similar (similar to left subtree)

task for right subtree */
*min_ref = INT_MAX;
rs = largestBSTUtil(node->right, min_ref, max_ref, max_size_ref, is_bst_ref);
if (*is_bst_ref == 1 && node->data < *min_ref)
right_flag = true;
// Update min and max values for the parent recursive calls
if (min < *min_ref)
*min_ref = min;
if (node->data < *min_ref) // For leaf nodes
*min_ref = node->data;
if (node->data > *max_ref)
*max_ref = node->data;
/* If both left and right subtrees are BST. And left and right
subtree properties hold for this node, then this tree is BST.
So return the size of this tree */
if(left_flag && right_flag)
{
if (ls + rs + 1 > *max_size_ref)
*max_size_ref = ls + rs + 1;
return ls + rs + 1;
}
else
{
//Since this subtree is not BST, set is_bst flag for parent calls
*is_bst_ref = 0;
return 0;
}
}

int main()
{
/* Let us construct the following Tree
50
/ \
10 60
/ \ / \
5 20 55 70
/ / \
45 65 80
*/

root->right->left->left = newNode(45);
/* The complete tree is not BST as 45 is in right subtree of 50.

The following subtree is the largest BST
60
/ \
/ \
55 70
/ / \
45 65 80
*/
printf(" Size of the largest BST is %d", largestBST(root));
getchar();
return 0;
}

discussed above.
Analysis of Algorithms | Set 2 (Worst, Average and Best Cases)
In the previous post, we discussed how Asymptotic analysis overcomes the problems of naive way of
analyzing algorithms. In this post, we will take an example of Linear Search and analyze it using Asymptotic
analysis.
We can have three cases to analyze an algorithm:

1) Worst Case
2) Average Case
3) Best Case
Let us consider the following implementation of Linear Search.
#include <stdio.h>
// Linearly search x in arr[]. If x is present then return the index,

// otherwise return -1
int search(int arr[], int n, int x)
{
int i;
for (i=0; i<n; i++)
{
if (arr[i] == x)
return i;
}
return -1;
}

int main()
{
int arr[] = {1, 10, 30, 15};
int x = 30;
printf("%d is present at index %d", x, search(arr, n, x));
getchar();
return 0;
}

Worst Case Analysis (Usually Done)

In the worst case analysis, we calculate upper bound on running time of an algorithm. We must know the
case that causes maximum number of operations to be executed. For Linear Search, the worst case happens
when the element to be searched (x in the above code) is not present in the array. When x is not present, the
search() functions compares it with all the elements of arr[] one by one. Therefore, the worst case time
complexity of linear search would be Θ(n).
Average Case Analysis (Sometimes done)

In average case analysis, we take all possible inputs and calculate computing time for all of the inputs. Sum
all the calculated values and divide the sum by total number of inputs. We must know (or predict)
distribution of cases. For the linear search problem, let us assume that all cases are uniformly distributed
(including the case of x not being present in array). So we sum all the cases and divide the sum by (n+1).
Following is the value of average case time complexity.

Average Case Time =
= Θ(n)

Best Case Analysis (Bogus)

In the best case analysis, we calculate lower bound on running time of an algorithm. We must know the case
that causes minimum number of operations to be executed. In the linear search problem, the best case
occurs when x is present at the first location. The number of operations in the best case is constant (not
dependent on n). So time complexity in the best case would be Θ(1)
Most of the times, we do worst case analysis to analyze algorithms. In the worst analysis, we guarantee an
upper bound on the running time of an algorithm which is good information.
The average case analysis is not easy to do in most of the practical cases and it is rarely done. In the average
case analysis, we must know (or predict) the mathematical distribution of all possible inputs.
The Best Case analysis is bogus. Guaranteeing a lower bound on an algorithm doesn’t provide any
information as in the worst case, an algorithm may take years to run.
For some algorithms, all the cases are asymptotically same, i.e., there are no worst and best cases. For
example, Merge Sort. Merge Sort does Θ(nLogn) operations in all cases. Most of the other sorting algorithms
have worst and best cases. For example, in the typical implementation of Quick Sort (where pivot is chosen
as a corner element), the worst occurs when the input array is already sorted and the best occur when the
pivot elements always divide array in two halves. For insertion sort, the worst case occurs when the array is
reverse sorted and the best case occurs when the array is sorted in the same order as output.
References:
MIT’s Video lecture 1 on Introduction to Algorithms.
discussed above.
Question 1
#include <stdio.h>

int main()
{
int arr[] = {};
printf("%d", sizeof(arr));
return 0;
}

Output: 0
C (or C++) allows arrays of size 0. When an array is declared with empty initialization list, size of the array
becomes 0.
Question 2
#include<stdio.h>
int main()
{
int i, j;
int arr[4][4] = { {1, 2, 3, 4},
{5, 6, 7, 8},
{9, 10, 11, 12},
{13, 14, 15, 16} };
for(i = 0; i < 4; i++)
for(j = 0; j < 4; j++)
printf("%d ", j[i[arr]] );
printf("\n");
for(i = 0; i < 4; i++)

for(j = 0; j < 4; j++)
printf("%d ", i[j[arr]] );
return 0;
}

Output:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
1 5 9 13 2 6 10 14 3 7 11 15 4 8 12 16

Array elements are accessed using pointer arithmetic. So the meaning of arr[i][j] and j[i[arr]] is same. They
both mean (arr + 4*i + j). Similarly, the meaning of arr[j][i] and i[j[arr]] is same.
Question 3
#include<stdio.h>
int main()
{
int a[2][3] = {2,1,3,2,3,4};
printf("Using pointer notations:\n");
printf("%d %d %d\n", *(*(a+0)+0), *(*(a+0)+1), *(*(a+0)+2));
printf("Using mixed notations:\n");
printf("%d %d %d\n", *(a[1]+0), *(a[1]+1), *(a[1]+2));
return 0;
}

Output:
Using pointer notations:

2 1 3
Using mixed notations:
2 3 4

discussed above.
AVL Tree | Set 1 (Insertion)
AVL tree is a self-balancing Binary Search Tree (BST) where the difference between heights of left and right
subtrees cannot be more than one for all nodes.
Why AVL Trees?

Most of the BST operations (e.g., search, max, min, insert, delete.. etc) take O(h) time where h is the height
of the BST. The cost of these operations may become O(n) for a skewed Binary tree. If we make sure that
height of the tree remains O(Logn) after every insertion and deletion, then we can guarantee an upper bound
of O(Logn) for all these operations. The height of an AVL tree is always O(Logn) where n is the number of
nodes in the tree (See this video lecture for proof).
Insertion
To make sure that the given tree remains AVL after every insertion, we must augment the standard BST
insert operation to perform some re-balancing. Following are two basic operations that can be performed to
re-balance a BST without violating the BST property (keys(left) T1, T2 and T3 are subtrees of the tree rooted
with y (on left side) or x (on right side) y x / \ Right Rotation / \ x T3 – – – – – – – > T1 y / \
Steps to follow for insertion

Let the newly inserted node be w
1) Perform standard BST insert for w.
2) Starting from w, travel up and find the first unbalanced node. Let z be the first unbalanced node, y be the
child of z that comes on the path from w to z and x be the grandchild of z that comes on the path from w to z.
3) Re-balance the tree by performing appropriate rotations on the subtree rooted with z. There can be 4
possible cases that needs to be handled as x, y and z can be arranged in 4 ways. Following are the possible 4
arrangements:
a) y is left child of z and x is left child of y (Left Left Case)
b) y is left child of z and x is right child of y (Left Right Case)
c) y is right child of z and x is right child of y (Right Right Case)
d) y is right child of z and x is left child of y (Right Left Case)
Following are the operations to be performed in above mentioned 4 cases. In all of the cases, we only need to
re-balance the subtree rooted with z and the complete tree becomes balanced as the height of subtree (After
appropriate rotations) rooted with z becomes same as it was before insertion. (See this video lecture for
proof)
a) Left Left Case
T1, T2, T3 and T4 are subtrees.

z y
/ \ / \
y T4 Right Rotate (z) x z
/ \ - - - - - - - - -> / \ / \
x T3 T1 T2 T3 T4
/ \
T1 T2

b) Left Right Case

z z x
/ \ / \ / \
y T4 Left Rotate (y) x T4 Right Rotate(z) y z
/ \ - - - - - - - - -> / \ - - - - - - - -> / \ / \
T1 x y T3 T1 T2 T3 T4
/ \ / \
T2 T3 T1 T2

c) Right Right Case
z y
/ \ / \
T1 y Left Rotate(z) z x
/ \ - - - - - - - -> / \ / \
T2 x T1 T2 T3 T4
/ \
T3 T4

d) Right Left Case
z z x
/ \ / \ / \
T1 y Right Rotate (y) T1 x Left Rotate(z) z y
/ \ - - - - - - - - -> / \ - - - - - - - -> / \ / \
x T4 T2 y T1 T2 T3 T4
/ \ / \
T2 T3 T3 T4

C implementation
Following is the C implementation for AVL Tree Insertion. The following C implementation uses the
recursive BST insert to insert a new node. In the recursive BST insert, after insertion, we get pointers to all
ancestors one by one in bottom up manner. So we don’t need parent pointer to travel up. The recursive code
itself travels up and visits all the ancestors of the newly inserted node.
1) Perform the normal BST insertion.
2) The current node must be one of the ancestors of the newly inserted node. Update the height of the
current node.
3) Get the balance factor (left subtree height – right subtree height) of the current node.
4) If balance factor is greater than 1, then the current node is unbalanced and we are either in Left Left case
or left Right case. To check whether it is left left case or not, compare the newly inserted key with the key in
left subtree root.
5) If balance factor is less than -1, then the current node is unbalanced and we are either in Right Right case
or Right Left case. To check whether it is Right Right case or not, compare the newly inserted key with the
key in right subtree root.
#include<stdio.h>
#include<stdio.h>
#include<stdlib.h>
// An AVL tree node

struct node
{
int key;
struct node *left;
struct node *right;
int height;
};

// A utility function to get height of the tree

{
if (N == NULL)
return 0;
return N->height;
}

{
}
{
node->key = key;
node->left = NULL;
node->right = NULL;
return(node);
}

// See the diagram given above.
{
// Perform rotation
x->right = y;
y->left = T2;
// Update heights
// Return new root

return x;
}

{
{
// Perform rotation
y->left = x;
x->right = T2;
// Update heights
// Return new root

return y;
}

{
if (N == NULL)
return 0;
}
struct node* insert(struct node* node, int key)

{
if (node == NULL)

node->left = insert(node->left, key);
else
node->right = insert(node->right, key);
/* 2. Update height of this ancestor node */


// Left Left Case

// Right Right Case

// Left Right Case

{
}
// Right Left Case

{
}

return node;
}
// A utility function to print preorder traversal of the tree.

// The function also prints height of every node
void preOrder(struct node *root)
{
if(root != NULL)
{
printf("%d ", root->key);
preOrder(root->left);
preOrder(root->right);
}
}

int main()
{

/* The constructed AVL Tree would be

30
/ \
20 40
/ \ \
10 25 50
*/
printf("Pre order traversal of the constructed AVL tree is \n");

preOrder(root);
return 0;
}

Output:
Pre order traversal of the constructed AVL tree is

30 20 10 25 40 50

Time Complexity: The rotation operations (left and right rotate) take constant time as only few pointers are
being changed there. Updating the height and getting the balance factor also take constant time. So the time
complexity of AVL insert remains same as BST insert which is O(h) where h is height of the tree. Since AVL
tree is balanced, the height is O(Logn). So time complexity of AVL insert is O(Logn).
The AVL tree and other self balancing search trees like Red Black are useful to get all basic operations done
in O(Logn) time. The AVL trees are more balanced compared to Red Black Trees, but they may cause more
rotations during insertion and deletion. So if your application involves many frequent insertions and
deletions, then Red Black trees should be preferred. And if the insertions and deletions are less frequent and
search is more frequent operation, then AVL tree should be preferred over Red Black Tree.
Following is the post for delete.

AVL Tree | Set 2 (Deletion)
Following are some previous posts that have used self-balancing search trees.
Median in a stream of integers (running integers)

Maximum of all subarrays of size k
Count smaller elements on right side
References:
IITD Video Lecture on AVL Tree Introduction
IITD Video Lecture on AVL Tree Insertion and Deletion
discussed above.
Vertical Sum in a given Binary Tree
Given a Binary Tree, find vertical sum of the nodes that are in same vertical line. Print all sums through
different vertical lines.
Examples:
1
/ \
2 3
/ \ / \
4 5 6 7

The tree has 5 vertical lines
Vertical-Line-1 has only one node 4 => vertical sum is 4

Vertical-Line-2: has only one node 2=> vertical sum is 2
Vertical-Line-3: has three nodes: 1,5,6 => vertical sum is 1+5+6 = 12
Vertical-Line-4: has only one node 3 => vertical sum is 3
Vertical-Line-5: has only one node 7 => vertical sum is 7
So expected output is 4, 2, 12, 3 and 7
Solution:
We need to check the Horizontal Distances from root for all nodes. If two nodes have the same Horizontal
Distance (HD), then they are on same vertical line. The idea of HD is simple. HD for root is 0, a right edge
(edge connecting to right subtree) is considered as +1 horizontal distance and a left edge is considered as -1
horizontal distance. For example, in the above tree, HD for Node 4 is at -2, HD for Node 2 is -1, HD for 5 and
6 is 0 and HD for node 7 is +2.
We can do inorder traversal of the given Binary Tree. While traversing the tree, we can recursively calculate
HDs. We initially pass the horizontal distance as 0 for root. For left subtree, we pass the Horizontal Distance
as Horizontal distance of root minus 1. For right subtree, we pass the Horizontal Distance as Horizontal
Distance of root plus 1.
Following is Java implementation for the same. HashMap is used to store the vertical sums for different
horizontal distances. Thanks to Nages for suggesting this method.
import java.util.HashMap;

// Class for a tree node
class TreeNode {

// data members
private int key;
private TreeNode left;
private TreeNode right;

// Accessor methods
public int key() { return key; }
public TreeNode left() { return left; }
public TreeNode right() { return right; }

// Constructor
public TreeNode(int key) { this.key = key; left = null; right = null; }
public TreeNode(int key) { this.key = key; left = null; right = null; }

// Methods to set left and right subtrees
public void setLeft(TreeNode left) { this.left = left; }
public void setRight(TreeNode right) { this.right = right; }
}

// Class for a Binary Tree
class Tree {

private TreeNode root;

// Constructors
public Tree() { root = null; }
public Tree(TreeNode n) { root = n; }

// Method to be called by the consumer classes like Main class
public void VerticalSumMain() { VerticalSum(root); }

// A wrapper over VerticalSumUtil()
private void VerticalSum(TreeNode root) {

// base case
if (root == null) { return; }

// Creates an empty hashMap hM
HashMap<Integer, Integer> hM = new HashMap<Integer, Integer>();

// Calls the VerticalSumUtil() to store the vertical sum values in hM
VerticalSumUtil(root, 0, hM);

// Prints the values stored by VerticalSumUtil()
if (hM != null) {
System.out.println(hM.entrySet());
}
}

// Traverses the tree in Inoorder form and builds a hashMap hM that
// contains the vertical sum
private void VerticalSumUtil(TreeNode root, int hD,
HashMap<Integer, Integer> hM) {

// base case

// Store the values in hM for left subtree
VerticalSumUtil(root.left(), hD - 1, hM);

// Update vertical sum for hD of this node
int prevSum = (hM.get(hD) == null) ? 0 : hM.get(hD);
hM.put(hD, prevSum + root.key());

// Store the values in hM for right subtree
VerticalSumUtil(root.right(), hD + 1, hM);
}
}

// Driver class to test the verticalSum methods
public class Main {

/* Create following Binary Tree
1
/ \
2 3
2 3
/ \ / \
4 5 6 7

*/
TreeNode root = new TreeNode(1);
root.setLeft(new TreeNode(2));
root.setRight(new TreeNode(3));
root.left().setLeft(new TreeNode(4));
root.left().setRight(new TreeNode(5));
root.right().setLeft(new TreeNode(6));
root.right().setRight(new TreeNode(7));
Tree t = new Tree(root);

System.out.println("Following are the values of vertical sums with "
+ "the positions of the columns with respect to root ");
t.VerticalSumMain();
}
}

See this for a sample run.
discussed above.
AVL Tree | Set 2 (Deletion)
We have discussed AVL insertion in the previous post. In this post, we will follow a similar approach for
deletion.
Steps to follow for deletion .

To make sure that the given tree remains AVL after every deletion, we must augment the standard BST
delete operation to perform some re-balancing. Following are two basic operations that can be performed to
re-balance a BST without violating the BST property (keys(left) T1, T2 and T3 are subtrees of the tree rooted
with y (on left side) or x (on right side) y x / \ Right Rotation / \ x T3 – – – – – – – > T1 y / \
Let w be the node to be deleted

1) Perform standard BST delete for w.
2) Starting from w, travel up and find the first unbalanced node. Let z be the first unbalanced node, y be the
larger height child of z, and x be the larger height child of y. Note that the definitions of x and y are different
from insertion here.
3) Re-balance the tree by performing appropriate rotations on the subtree rooted with z. There can be 4
possible cases that needs to be handled as x, y and z can be arranged in 4 ways. Following are the possible 4
arrangements:
a) y is left child of z and x is left child of y (Left Left Case)
b) y is left child of z and x is right child of y (Left Right Case)
c) y is right child of z and x is right child of y (Right Right Case)
d) y is right child of z and x is left child of y (Right Left Case)
Like insertion, following are the operations to be performed in above mentioned 4 cases. Note that, unlike
insertion, fixing the node z won’t fix the complete AVL tree. After fixing z, we may have to fix ancestors of z
as well (See this video lecture for proof)
a) Left Left Case
T1, T2, T3 and T4 are subtrees.

z y
/ \ / \
y T4 Right Rotate (z) x z
/ \ - - - - - - - - -> / \ / \
x T3 T1 T2 T3 T4
/ \
T1 T2

b) Left Right Case
z z x
/ \ / \ / \
y T4 Left Rotate (y) x T4 Right Rotate(z) y z
/ \ - - - - - - - - -> / \ - - - - - - - -> / \ / \
T1 x y T3 T1 T2 T3 T4
/ \ / \
T2 T3 T1 T2

c) Right Right Case

z y
/ \ / \
T1 y Left Rotate(z) z x
/ \ - - - - - - - -> / \ / \
T2 x T1 T2 T3 T4
/ \
T3 T4

d) Right Left Case
z z x
/ \ / \ / \
T1 y Right Rotate (y) T1 x Left Rotate(z) z x
/ \ - - - - - - - - -> / \ - - - - - - - -> / \ / \
x T4 T2 y T1 T2 T3 T4
/ \ / \
T2 T3 T3 T4

Unlike insertion, in deletion, after we perform a rotation at z, we may have to perform a rotation at ancestors
of z. Thus, we must continue to trace the path until we reach the root.
C implementation
Following is the C implementation for AVL Tree Deletion. The following C implementation uses the
recursive BST delete as basis. In the recursive BST delete, after deletion, we get pointers to all ancestors one
by one in bottom up manner. So we don’t need parent pointer to travel up. The recursive code itself travels
up and visits all the ancestors of the deleted node.
1) Perform the normal BST deletion.
2) The current node must be one of the ancestors of the deleted node. Update the height of the current node.
3) Get the balance factor (left subtree height – right subtree height) of the current node.
4) If balance factor is greater than 1, then the current node is unbalanced and we are either in Left Left case
or Left Right case. To check whether it is Left Left case or Left Right case, get the balance factor of left
subtree. If balance factor of the left subtree is greater than or equal to 0, then it is Left Left case, else Left
Right case.
5) If balance factor is less than -1, then the current node is unbalanced and we are either in Right Right case
or Right Left case. To check whether it is Right Right case or Right Left case, get the balance factor of right
subtree. If the balance factor of the right subtree is smaller than or equal to 0, then it is Right Right case, else
Right Left case.
#include<stdio.h>
#include<stdlib.h>
// An AVL tree node

struct node
{
int key;
struct node *left;
struct node *right;
int height;
};
};


{
if (N == NULL)
return 0;
return N->height;
}

{
}
{
node->key = key;
node->left = NULL;
node->right = NULL;
return(node);
}

{
// Perform rotation
x->right = y;
y->left = T2;
// Update heights
// Return new root

return x;
}

{
// Perform rotation
y->left = x;
x->right = T2;
// Update heights
// Return new root

return y;
}

{
if (N == NULL)
return 0;
}

{
if (node == NULL)

else
/* 2. Update height of this ancestor node */


// Left Left Case

// Right Right Case

// Left Right Case

{
}
// Right Left Case

{
}

return node;
}
/* Given a non-empty binary search tree, return the node with minimum
key value found in that tree. Note that the entire tree does not
need to be searched. */
struct node * minValueNode(struct node* node)
{

while (current->left != NULL)
return current;
}
struct node* deleteNode(struct node* root, int key)

{
// STEP 1: PERFORM STANDARD BST DELETE
if (root == NULL)
return root;
// If the key to be deleted is smaller than the root's key,

// then it lies in left subtree
if ( key < root->key )
root->left = deleteNode(root->left, key);
// If the key to be deleted is greater than the root's key,

// then it lies in right subtree
else if( key > root->key )
root->right = deleteNode(root->right, key);
// if key is same as root's key, then This is the node

// to be deleted
else
{
// node with only one child or no child
if( (root->left == NULL) || (root->right == NULL) )
{
struct node *temp = root->left ? root->left : root->right;
// No child case
if(temp == NULL)
{
temp = root;
root = NULL;
}
else // One child case
*root = *temp; // Copy the contents of the non-empty child
free(temp);
}
else
{
// node with two children: Get the inorder successor (smallest
// in the right subtree)
struct node* temp = minValueNode(root->right);
// Copy the inorder successor's data to this node

root->key = temp->key;
// Delete the inorder successor

root->right = deleteNode(root->right, temp->key);
}
}
// If the tree had only one node then return

if (root == NULL)
return root;
// STEP 2: UPDATE HEIGHT OF THE CURRENT NODE
root->height = max(height(root->left), height(root->right)) + 1;
// STEP 3: GET THE BALANCE FACTOR OF THIS NODE (to check whether
// this node became unbalanced)
int balance = getBalance(root);
// Left Left Case

if (balance > 1 && getBalance(root->left) >= 0)
return rightRotate(root);
// Left Right Case

if (balance > 1 && getBalance(root->left) < 0)
{
root->left = leftRotate(root->left);
return rightRotate(root);
}
// Right Right Case

if (balance < -1 && getBalance(root->right) <= 0)
return leftRotate(root);
// Right Left Case

if (balance < -1 && getBalance(root->right) > 0)
{
root->right = rightRotate(root->right);
return leftRotate(root);
}
return root;
}

{
if(root != NULL)
{
}
}

int main()
{

root = insert(root, -1);

9
/ \
1 10
/ \ \
0 5 11
/ / \
-1 2 6
*/
printf("Pre order traversal of the constructed AVL tree is \n");

preOrder(root);
root = deleteNode(root, 10);
/* The AVL Tree after deletion of 10

1
/ \
0 9
/ / \
-1 5 11
/ \
2 6
*/
printf("\nPre order traversal after deletion of 10 \n");

preOrder(root);
return 0;
}

Output:
Pre order traversal of the constructed AVL tree is

9 1 0 -1 5 2 6 10 11
Pre order traversal after deletion of 10
1 0 -1 9 5 2 6 11

Time Complexity: The rotation operations (left and right rotate) take constant time as only few pointers are
being changed there. Updating the height and getting the balance factor also take constant time. So the time
complexity of AVL delete remains same as BST delete which is O(h) where h is height of the tree. Since AVL
tree is balanced, the height is O(Logn). So time complexity of AVL delete is O(Logn).
References:
IITD Video Lecture on AVL Tree Insertion and Deletion
discussed above.
Depth First Traversal for a Graph
Depth First Traversal (or Search) for a graph is similar to Depth First Traversal of a tree. The only catch here
is, unlike trees, graphs may contain cycles, so we may come to the same node again. To avoid processing a
node more than once, we use a boolean visited array.
For example, in the following graph, we start traversal from vertex 2. When we come to vertex 0, we look for
all adjacent vertices of it. 2 is also an adjacent vertex of 0. If we don’t mark visited vertices, then 2 will be
processed again and it will become a non-terminating process. Depth First Traversal of the following graph
is 2, 0, 1, 3
See this post for all applications of Depth First Traversal.

Following is C++ implementation of simple Depth First Traversal. The implementation uses adjacency list
representation of graphs. STL‘s list container is used to store lists of adjacent nodes.
#include<iostream>
#include <list>
// Graph class represents a directed graph using adjacency list representation

class Graph
{
int V; // No. of vertices
list<int> *adj; // Pointer to an array containing adjacency lists
void DFSUtil(int v, bool visited[]); // A function used by DFS
public:
Graph(int V); // Constructor
void addEdge(int v, int w); // function to add an edge to graph
void DFS(int v); // DFS traversal of the vertices reachable from v
};
Graph::Graph(int V)
{
this->V = V;
adj = new list<int>[V];
}
void Graph::addEdge(int v, int w)

{
adj[v].push_back(w); // Add w to v’s list.
}
void Graph::DFSUtil(int v, bool visited[])

{
// Mark the current node as visited and print it
visited[v] = true;
cout << v << " ";
// Recur for all the vertices adjacent to this vertex
list<int>::iterator i;
for(i = adj[v].begin(); i != adj[v].end(); ++i)
if(!visited[*i])
DFSUtil(*i, visited);
}
// DFS traversal of the vertices reachable from v. It uses recursive DFSUtil()

void Graph::DFS(int v)
{
// Mark all the vertices as not visited
bool *visited = new bool[V];
for(int i = 0; i < V; i++)
visited[i] = false;
// Call the recursive helper function to print DFS traversal

DFSUtil(v, visited);
}
int main()
{
// Create a graph given in the above diagram
Graph g(4);
g.addEdge(0, 1);
g.addEdge(0, 2);
g.addEdge(1, 2);
g.addEdge(2, 0);
g.addEdge(2, 3);
g.addEdge(3, 3);
cout << "Following is Depth First Traversal (starting from vertex 2) \n";
g.DFS(2);
return 0;
}

Output:
Following is Depth First Traversal (starting from vertex 2)

2 0 1 3

Note that the above code traverses only the vertices reachable from a given source vertex. All the vertices
may not be reachable from a given vertex (example Disconnected graph). To do complete DFS traversal of
such graphs, we must call DFSUtil() for every vertex. Also, before calling DFSUtil(), we should check if it is
already printed by some other call of DFSUtil(). Following implementation does the complete graph
traversal even if the nodes are unreachable. The differences from the above code are highlighted in the below
code.
#include<iostream>
#include <list>
class Graph
{
{
void DFSUtil(int v, bool visited[]); // A function used by DFS
public:
void DFS(); // prints DFS traversal of the complete graph
};
Graph::Graph(int V)
{
this->V = V;
}

{
}

{
visited[v] = true;
cout << v << " ";

if(!visited[*i])
}
// The function to do DFS traversal. It uses recursive DFSUtil()

void Graph::DFS()
{
for(int i = 0; i < V; i++)
visited[i] = false;
// Call the recursive helper function to print DFS traversal

// starting from all vertices one by one
for(int i = 0; i < V; i++)
if(visited[i] == false)
DFSUtil(i, visited);
}
int main()
{
Graph g(4);
g.addEdge(0, 1);
g.addEdge(0, 2);
g.addEdge(1, 2);
g.addEdge(2, 0);
g.addEdge(2, 3);
g.addEdge(3, 3);
cout << "Following is Depth First Traversal (starting from vertex 0) \n";
g.DFS();
return 0;
}

Time Complexity: O(V+E) where V is number of vertices in the graph and E is number of edges in the graph.
discussed above.
Add two numbers without using arithmetic operators
Write a function Add() that returns sum of two integers. The function should not use any of the arithmetic
operators (+, ++, –, -, .. etc).
Sum of two bits can be obtained by performing XOR (^) of the two bits. Carry bit can be obtained by
performing AND (&) of two bits.
Above is simple Half Adder logic that can be used to add 2 single bits. We can extend this logic for integers. If
x and y don’t have set bits at same position(s), then bitwise XOR (^) of x and y gives the sum of x and y. To
incorporate common set bits also, bitwise AND (&) is used. Bitwise AND of x and y gives all carry bits. We
calculate (x & y) #include<stdio.h> int Add(int x, int y) { // Iterate till there is no carry while (y != 0) { //
carry now contains common set bits of x and y int carry = x & y; // Sum of bits of x and y where at least one of
the bits is not set x = x ^ y; // Carry is shifted by one so that adding it to x gives the required sum y = carry
<< 1; } return x; } int main() { printf("%d", Add(15, 32)); return 0; }
Following is recursive implementation for the same approach.
int Add(int x, int y)

{
if (y == 0)
return x;
else
return Add( x ^ y, (x & y) << 1);
}

discussed above.
Dynamic Programming | Set 10 ( 0-1 Knapsack Problem)
Given weights and values of n items, put these items in a knapsack of capacity W to get the maximum total
value in the knapsack. In other words, given two integer arrays val[0..n-1] and wt[0..n-1] which represent
values and weights associated with n items respectively. Also given an integer W which represents knapsack
capacity, find out the maximum value subset of val[] such that sum of the weights of this subset is smaller
than or equal to W. You cannot break an item, either pick the complete item, or don’t pick it (0-1 property).
A simple solution is to consider all subsets of items and calculate the total weight and value of all subsets.
Consider the only subsets whose total weight is smaller than W. From all such subsets, pick the maximum
value subset.
To consider all subsets of items, there can be two cases for every item: (1) the item is included in the optimal
subset, (2) not included in the optimal set.
Therefore, the maximum value that can be obtained from n items is max of following two values.
1) Maximum value obtained by n-1 items and W weight (excluding nth item).
2) Value of nth item plus maximum value obtained by n-1 items and W minus weight of the nth item
(including nth item).
If weight of nth item is greater than W, then the nth item cannot be included and case 1 is the only
possibility.
Following is recursive implementation that simply follows the recursive structure mentioned above.

/* A Naive recursive implementation of 0-1 Knapsack problem */

#include<stdio.h>
// A utility function that returns maximum of two integers

int max(int a, int b) { return (a > b)? a : b; }
// Returns the maximum value that can be put in a knapsack of capacity W

int knapSack(int W, int wt[], int val[], int n)
{
// Base Case
if (n == 0 || W == 0)
return 0;
// If weight of the nth item is more than Knapsack capacity W, then

// this item cannot be included in the optimal solution
if (wt[n-1] > W)
return knapSack(W, wt, val, n-1);
// Return the maximum of two cases: (1) nth item included (2) not included
else return max( val[n-1] + knapSack(W-wt[n-1], wt, val, n-1),
knapSack(W, wt, val, n-1)
);
}

int main()
{
int val[] = {60, 100, 120};
int wt[] = {10, 20, 30};
int W = 50;
int n = sizeof(val)/sizeof(val[0]);
printf("%d", knapSack(W, wt, val, n));
return 0;
}

following recursion tree, K(1, 1) is being evaluated twice. Time complexity of this naive recursive solution is
exponential (2^n).

In the following recursion tree, K() refers to knapSack(). The two

parameters indicated in the following recursion tree are n and W.
The recursion tree is for following sample inputs.
wt[] = {1, 1, 1}, W = 2, val[] = {10, 20, 30}
K(3, 2) ---------> K(n, W)

/ \
/ \
K(2,2) K(2,1)
/ \ / \
/ \ / \
K(1,2) K(1,1) K(1,1) K(1,0)
/ \ / \ / \
/ \ / \ / \
K(0,2) K(0,1) K(0,1) K(0,0) K(0,1) K(0,0)
Recursion tree for Knapsack capacity 2 units and 3 items of 1 unit weight.

Since suproblems are evaluated again, this problem has Overlapping Subprolems property. So the 0-1
Knapsack problem has both properties (see this and this) of a dynamic programming problem. Like other
constructing a temporary array K[][] in bottom up manner. Following is Dynamic Programming based
implementation.

// A Dynamic Programming based solution for 0-1 Knapsack problem

#include<stdio.h>
// A utility function that returns maximum of two integers

// Returns the maximum value that can be put in a knapsack of capacity W

int knapSack(int W, int wt[], int val[], int n)
{
int i, w;
int K[n+1][W+1];
// Build table K[][] in bottom up manner

for (i = 0; i <= n; i++)
{
for (w = 0; w <= W; w++)
{
if (i==0 || w==0)
K[i][w] = 0;
else if (wt[i-1] <= w)
K[i][w] = max(val[i-1] + K[i-1][w-wt[i-1]], K[i-1][w]);
else
K[i][w] = K[i-1][w];
}
}
return K[n][W];
}
int main()
{
int val[] = {60, 100, 120};
int wt[] = {10, 20, 30};
int W = 50;
int n = sizeof(val)/sizeof(val[0]);
printf("%d", knapSack(W, wt, val, n));
return 0;
}

Time Complexity: O(nW) where n is the number of items and W is the capacity of knapsack.
References:
http://www.es.ele.tue.nl/education/5MC10/Solutions/knapsack.pdf
http://www.cse.unl.edu/~goddard/Courses/CSCE310J/Lectures/Lecture8-DynamicProgramming.pdf
discussed above.
Breadth First Traversal for a Graph
Breadth First Traversal (or Search) for a graph is similar to Breadth First Traversal of a tree (See mthod 2 of
this post). The only catch here is, unlike trees, graphs may contain cycles, so we may come to the same node
again. To avoid processing a node more than once, we use a boolean visited array. For simplicity, it is
assumed that all vertices are reachable from the starting vertex.
For example, in the following graph, we start traversal from vertex 2. When we come to vertex 0, we look for
all adjacent vertices of it. 2 is also an adjacent vertex of 0. If we don’t mark visited vertices, then 2 will be
processed again and it will become a non-terminating process. Breadth First Traversal of the following graph
is 2, 0, 3, 1.
Following is C++ implementation of simple Breadth First Traversal from a given source. The
implementation uses adjacency list representation of graphs. STL‘s list container is used to store lists of
adjacent nodes and queue of nodes needed for BFS traversal.
// Program to print BFS traversal from a given source vertex. BFS(int s)

// traverses vertices reachable from s.
#include<iostream>
#include <list>
// This class represents a directed graph using adjacency list representation

class Graph
{
public:
void BFS(int s); // prints BFS traversal from a given source s
};
Graph::Graph(int V)
{
this->V = V;
}

{
}
void Graph::BFS(int s)
{
for(int i = 0; i < V; i++)
visited[i] = false;
// Create a queue for BFS

list<int> queue;
// Mark the current node as visited and enqueue it

visited[s] = true;
queue.push_back(s);
// 'i' will be used to get all adjacent vertices of a vertex

while(!queue.empty())
{
// Dequeue a vertex from queue and print it
s = queue.front();
cout << s << " ";
queue.pop_front();
// Get all adjacent vertices of the dequeued vertex s

// If a adjacent has not been visited, then mark it visited
// and enqueue it
for(i = adj[s].begin(); i != adj[s].end(); ++i)
{
if(!visited[*i])
{
visited[*i] = true;
queue.push_back(*i);
}
}
}
}
// Driver program to test methods of graph class

int main()
{
Graph g(4);
g.addEdge(0, 1);
g.addEdge(0, 2);
g.addEdge(1, 2);
g.addEdge(2, 0);
g.addEdge(2, 3);
g.addEdge(3, 3);
cout << "Following is Breadth First Traversal (starting from vertex 2) \n";
g.BFS(2);
return 0;
}

Output:
Following is Breadth First Traversal (starting from vertex 2)

2 0 3 1

Note that the above code traverses only the vertices reachable from a given source vertex. All the vertices
may not be reachable from a given vertex (example Disconnected graph). To print all the vertices, we can
modify the BFS function to do traversal starting from all nodes one by one (Like the DFS modified version) .
Time Complexity: O(V+E) where V is number of vertices in the graph and E is number of edges in the graph.
Also see Depth First Traversal
discussed above.
Greedy Algorithms | Set 1 (Activity Selection Problem)
Greedy is an algorithmic paradigm that builds up a solution piece by piece, always choosing the next piece
that offers the most obvious and immediate benefit. Greedy algorithms are used for optimization problems.
An optimization problem can be solved using Greedy if the problem has the following property: At every
step, we can make a choice that looks best at the moment, and we get the optimal solution of the complete
problem.
If a Greedy Algorithm can solve a problem, then it generally becomes the best method to solve that problem
as the Greedy algorithms are in general more efficient than other techniques like Dynamic Programming.
But Greedy algorithms cannot always be applied. For example, Fractional Knapsack problem (See this) can
be solved using Greedy, but 0-1 Knapsack cannot be solved using Greedy.
Following are some standard algorithms that are Greedy algorithms.

1) Kruskal’s Minimum Spanning Tree (MST) : In Kruskal’s algorithm, we create a MST by picking
edges one by one. The Greedy Choice is to pick the smallest weight edge that doesn’t cause a cycle in the
MST constructed so far.
2) Prim’s Minimum Spanning Tree : In Prim’s algorithm also, we create a MST by picking edges one by
one. We maintain two sets: set of the vertices already included in MST and the set of the vertices not yet
included. The Greedy Choice is to pick the smallest weight edge that connects the two sets.
3) Dijkstra’s Shortest Path: The Dijkstra’s algorithm is very similar to Prim’s algorithm. The shortest
path tree is built up, edge by edge. We maintain two sets: set of the vertices already included in the tree and
the set of the vertices not yet included. The Greedy Choice is to pick the edge that connects the two sets and
is on the smallest weight path from source to the set that contains not yet included vertices.
4) Huffman Coding: Huffman Coding is a loss-less compression technique. It assigns variable length bit
codes to different characters. The Greedy Choice is to assign least bit length code to the most frequent
character.
The greedy algorithms are sometimes also used to get an approximation for Hard optimization problems.
For example, Traveling Salesman Problem is a NP Hard problem. A Greedy choice for this problem is to pick
the nearest unvisited city from the current city at every step. This solutions doesn’t always produce the best
optimal solution, but can be used to get an approximate optimal solution.
Let us consider the Activity Selection problem as our first example of Greedy algorithms. Following is the
problem statement.
You are given n activities with their start and finish times. Select the maximum number of activities that
can be performed by a single person, assuming that a person can only work on a single activity at a time.
Example:
Consider the following 6 activities.

start[] = {1, 3, 0, 5, 8, 5};
finish[] = {2, 4, 6, 7, 9, 9};
The maximum set of activities that can be executed
by a single person is {0, 1, 3, 4}

The greedy choice is to always pick the next activity whose finish time is least among the remaining activities
and the start time is more than or equal to the finish time of previously selected activity. We can sort the
activities according to their finishing time so that we always consider the next activity as minimum finishing
time activity.
1) Sort the activities according to their finishing time

2) Select the first activity from the sorted array and print it.
3) Do following for remaining activities in the sorted array.
…….a) If the start time of this activity is greater than the finish time of previously selected activity then select
this activity and print it.
In the following C implementation, it is assumed that the activities are already sorted according to their
finish time.
#include<stdio.h>
// Prints a maximum set of activities that can be done by a single

// person, one at a time.
// n --> Total number of activities
// s[] --> An array that contains start time of all activities
// f[] --> An array that contains finish time of all activities
void printMaxActivities(int s[], int f[], int n)
{
int i, j;
printf ("Following activities are selected \n");
// The first activity always gets selected

i = 0;
printf("%d ", i);
// Consider rest of the activities

for (j = 1; j < n; j++)
{
// If this activity has start time greater than or equal to the finish
// time of previously selected activity, then select it
if (s[j] >= f[i])
{
printf ("%d ", j);
i = j;
}
}
}

int main()
{
int s[] = {1, 3, 0, 5, 8, 5};
int f[] = {2, 4, 6, 7, 9, 9};
int n = sizeof(s)/sizeof(s[0]);
printMaxActivities(s, f, n);
getchar();
return 0;
}

Output:
Following activities are selected

0 1 3 4

How does Greedy Choice work for Activities sorted according to finish time?
Let the give set of activities be S = {1, 2, 3, ..n} and activities be sorted by finish time. The greedy choice is to
always pick activity 1. How come the activity 1 always provides one of the optimal solutions. We can prove it
by showing that if there is another solution B with first activity other than 1, then there is also a solution A of
same size with activity 1 as first activity. Let the first activity selected by B be k, then there always exist A =
{B – {k}} U {1}.(Note that the activities in B are independent and k has smallest finishing time among all.
Since k is not 1, finish(k) >= finish(1)).
References:
Introduction to Algorithms by Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, Clifford Stein
Algorithms by S. Dasgupta, C.H. Papadimitriou, and U.V. Vazirani
http://en.wikipedia.org/wiki/Greedy_algorithm
discussed above.
Merge Two Balanced Binary Search Trees
You are given two balanced binary search trees e.g., AVL or Red Black Tree. Write a function that merges the
two given balanced BSTs into a balanced binary search tree. Let there be m elements in first tree and n
elements in the other tree. Your merge function should take O(m+n) time.
In the following solutions, it is assumed that sizes of trees are also given as input. If the size is not given,
then we can get the size by traversing the tree (See this).
Method 1 (Insert elements of first tree to second)

Take all elements of first BST one by one, and insert them into the second BST. Inserting an element to a self
balancing BST takes Logn time (See this) where n is size of the BST. So time complexity of this method is
Log(n) + Log(n+1) … Log(m+n-1). The value of this expression will be between mLogn and mLog(m+n-1).
As an optimization, we can pick the smaller tree as first tree.
Method 2 (Merge Inorder Traversals)

1) Do inorder traversal of first tree and store the traversal in one temp array arr1[]. This step takes O(m)
time.
2) Do inorder traversal of second tree and store the traversal in another temp array arr2[]. This step takes
O(n) time.
3) The arrays created in step 1 and 2 are sorted arrays. Merge the two sorted arrays into one array of size m +
n. This step takes O(m+n) time.
4) Construct a balanced tree from the merged array using the technique discussed in this post. This step
takes O(m+n) time.
Time complexity of this method is O(m+n) which is better than method 1. This method takes O(m+n) time
even if the input BSTs are not balanced.
#include <stdio.h>
#include <stdlib.h>

struct node
{
int data;
struct node* left;
struct node* right;
};
// A utility unction to merge two sorted arrays into one

int *merge(int arr1[], int arr2[], int m, int n);
// A helper function that stores inorder traversal of a tree in inorder array

void storeInorder(struct node* node, int inorder[], int *index_ptr);
/* A function that constructs Balanced Binary Search Tree from a sorted array
See http://www.geeksforgeeks.org/archives/17138 */
struct node* sortedArrayToBST(int arr[], int start, int end);
/* This function merges two balanced BSTs with roots as root1 and root2.
m and n are the sizes of the trees respectively */
struct node* mergeTrees(struct node *root1, struct node *root2, int m, int n)
{
// Store inorder traversal of first tree in an array arr1[]
int *arr1 = new int[m];
int i = 0;
int i = 0;
storeInorder(root1, arr1, &i);
// Store inorder traversal of second tree in another array arr2[]

int *arr2 = new int[n];
int j = 0;
storeInorder(root2, arr2, &j);
// Merge the two sorted array into one

int *mergedArr = merge(arr1, arr2, m, n);
// Construct a tree from the merged array and return root of the tree
return sortedArrayToBST (mergedArr, 0, m+n-1);
}

{
node->data = data;
node->left = NULL;
node->right = NULL;
return(node);
}
// A utility function to print inorder traversal of a given binary tree

{
if (node == NULL)
return;


}
// A utility unction to merge two sorted arrays into one

int *merge(int arr1[], int arr2[], int m, int n)
{
// mergedArr[] is going to contain result
int *mergedArr = new int[m + n];
int i = 0, j = 0, k = 0;
// Traverse through both arrays

{
// Pick the smaler element and put it in mergedArr
{
mergedArr[k] = arr1[i];
i++;
}
else
{
mergedArr[k] = arr2[j];
j++;
}
k++;
k++;
}
// If there are more elements in first array

while (i < m)
{
mergedArr[k] = arr1[i];
i++; k++;
}
// If there are more elements in second array

while (j < n)
{
mergedArr[k] = arr2[j];
j++; k++;
}
return mergedArr;
}
// A helper function that stores inorder traversal of a tree rooted with node
void storeInorder(struct node* node, int inorder[], int *index_ptr)
{
if (node == NULL)
return;

storeInorder(node->left, inorder, index_ptr);
inorder[*index_ptr] = node->data;
(*index_ptr)++; // increase index for next entry

storeInorder(node->right, inorder, index_ptr);
}
/* A function that constructs Balanced Binary Search Tree from a sorted array
See http://www.geeksforgeeks.org/archives/17138 */
struct node* sortedArrayToBST(int arr[], int start, int end)
{
/* Base Case */
if (start > end)
return NULL;
/* Get the middle element and make it root */

int mid = (start + end)/2;
struct node *root = newNode(arr[mid]);
/* Recursively construct the left subtree and make it

left child of root */
root->left = sortedArrayToBST(arr, start, mid-1);
/* Recursively construct the right subtree and make it

right child of root */
root->right = sortedArrayToBST(arr, mid+1, end);
return root;
}

int main()
{
/* Create following tree as first balanced BST
100
/ \
50 300
/ \
20 70
*/
/* Create following tree as second balanced BST

80
/ \
40 120
*/
struct node *mergedTree = mergeTrees(root1, root2, 5, 3);
printf ("Following is Inorder traversal of the merged tree \n");

printInorder(mergedTree);
getchar();
return 0;
}

Output:
Following is Inorder traversal of the merged tree

20 40 50 70 80 100 120 300

Method 3 (In-Place Merge using DLL)

We can use a Doubly Linked List to merge trees in place. Following are the steps.
1) Convert the given two Binary Search Trees into doubly linked list in place (Refer this post for this step).
2) Merge the two sorted Linked Lists (Refer this post for this step).
3) Build a Balanced Binary Search Tree from the merged list created in step 2. (Refer this post for this step)
Time complexity of this method is also O(m+n) and this method does conversion in place.
Thanks to Dheeraj and Ronzii for suggesting this method.
discussed above.
Union and Intersection of two Linked Lists
Given two Linked Lists, create union and intersection lists that contain union and intersection of the
elements present in the given lists. Order of elments in output lists doesn’t matter.
Example:
Input:
List1: 10->15->4->20
lsit2: 8->4->2->10
Output:
Intersection List: 4->10
Union List: 2->8->20->4->15->10

Method 1 (Simple)
Following are simple algorithms to get union and intersection lists respectively.
Intersection (list1, list2)

Initialize result list as NULL. Traverse list1 and look for its each element in list2, if the element is present in
list2, then add the element to result.
Union (list1, list2):

Initialize result list as NULL. Traverse list1 and add all of its elements to the result.
Traverse list2. If an element of list2 is already present in result then do not insert it to result, otherwise
insert.
This method assumes that there are no duplicates in the given lists.
Thanks to Shekhu for suggesting this method. Following is C implementation of this method.
#include<stdio.h>
#include<stdlib.h>

struct node
{
int data;
struct node* next;
};
/* A utility function to insert a node at the begining of a linked list*/

void push (struct node** head_ref, int new_data);
/* A utilty function to chec if given data is present in a list */

bool isPresent (struct node *head, int data);
/* Function to get union of two linked lists head1 and head2 */

struct node *getUnion (struct node *head1, struct node *head2)
{
struct node *result = NULL;
struct node *t1 = head1, *t2 = head2;
// Insert all elements of list1 to the result list

while (t1 != NULL)
{
push(&result, t1->data);
t1 = t1->next;
}
// Insert those elements of list2 which are not present in result list
while (t2 != NULL)
{
if (!isPresent(result, t2->data))
t2 = t2->next;
}
return result;
}
/* Function to get intersection of two linked lists head1 and head2 */

struct node *getIntersection (struct node *head1, struct node *head2)
{
struct node *result = NULL;
struct node *t1 = head1;
// Traverse list1 and search each element of it in list2. If the element

// is present in list 2, then insert the element to result
while (t1 != NULL)
{
if (isPresent(head2, t1->data))
push (&result, t1->data);
t1 = t1->next;
}
return result;
}

void push (struct node** head_ref, int new_data)
{
/* allocate node */



}
/* A utility function to print a linked list*/

void printList (struct node *node)
{
{
printf ("%d ", node->data);
node = node->next;
}
}
/* A utilty function that returns true if data is present in linked list

else return false */
bool isPresent (struct node *head, int data)
{
struct node *t = head;
struct node *t = head;
while (t != NULL)
{
if (t->data == data)
return 1;
t = t->next;
}
return 0;
}

int main()
{
struct node* head1 = NULL;
struct node* head2 = NULL;
struct node* intersecn = NULL;
struct node* unin = NULL;
/*create a linked lits 10->15->5->20 */

push (&head1, 20);
push (&head1, 4);
push (&head1, 15);
push (&head1, 10);
/*create a linked lits 8->4->2->10 */

push (&head2, 10);
push (&head2, 2);
push (&head2, 4);
push (&head2, 8);
intersecn = getIntersection (head1, head2);

unin = getUnion (head1, head2);
printf ("\n First list is \n");

printList (head1);
printf ("\n Second list is \n");

printList (head2);
printf ("\n Intersection list is \n");

printList (intersecn);
printf ("\n Union list is \n");

printList (unin);
return 0;
}

Output:

First list is
10 15 4 20
Second list is
8 4 2 10
Intersection list is
4 10
Union list is
2 8 20 4 15 10

Time Complexity: O(mn) for both union and intersection operations. Here m is the number of elements in
first list and n is the number of elements in second list.
Method 2 (Use Merge Sort)

In this method, algorithms for Union and Intersection are very similar. First we sort the given lists, then we
traverse the sorted lists to get union and intersection.
Following are the steps to be followed to get union and intersection lists.
1) Sort the first Linked List using merge sort. This step takes O(mLogm) time. Refer this post for details of
this step.
2) Sort the second Linked List using merge sort. This step takes O(nLogn) time. Refer this post for details of
this step.
3) Linearly scan both sorted lists to get the union and intersection. This step takes O(m + n) time. This step
can be implemented using the same algorithm as sorted arrays algorithm discussed here.
Time complexity of this method is O(mLogm + nLogn) which is better than method 1’s time complexity.

Union (list1, list2)
Initialize the result list as NULL and create an empty hash table. Traverse both lists one by one, for each
element being visited, look the element in hash table. If the element is not present, then insert the element
to result list. If the element is present, then ignore it.
Intersection (list1, list2)

Initialize the result list as NULL and create an empty hash table. Traverse list1. For each element being
visited in list1, insert the element in hash table. Traverse list2, for each element being visited in list2, look
the element in hash table. If the element is present, then insert the element to result list. If the element is
not present, then ignore it.
Both of the above methods assume that there are no duplicates.
Time complexity of this method depends on the hashing technique used and the distribution of elements in
input lists. In practical, this approach may turn out to be better than above 2 methods.
Source: http://geeksforgeeks.org/forum/topic/union-intersection-of-unsorted-lists
discussed above.
Detect Cycle in a Directed Graph
Given a directed graph, check whether the graph contains a cycle or not. Your function should return true if
the given graph contains at least one cycle, else return false. For example, the following graph contains three
cycles 0->2->0, 0->1->2->0 and 3->3, so your function must return true.
Solution
Depth First Traversal can be used to detect cycle in a Graph. DFS for a connected graph produces a tree.
There is a cycle in a graph only if there is a back edge present in the graph. A back edge is an edge that is
from a node to itself (selfloop) or one of its ancestor in the tree produced by DFS. In the following graph,
there are 3 back edges, marked with cross sign. We can observe that these 3 back edges indicate 3 cycles
present in the graph.
For a disconnected graph, we get the DFS forrest as output. To detect cycle, we can check for cycle in
individual trees by checking back edges.
To detect a back edge, we can keep track of vertices currently in recursion stack of function for DFS traversal.
If we reach a vertex that is already in the recursion stack, then there is a cycle in the tree. The edge that
connects current vertex to the vertex in the recursion stack is back edge. We have used recStack[] array to
keep track of vertices in the recursion stack.
// A C++ Program to detect cycle in a graph

#include<iostream>
#include <list>
#include <limits.h>
class Graph
{
bool isCyclicUtil(int v, bool visited[], bool *rs); // used by isCyclic()
public:
void addEdge(int v, int w); // to add an edge to graph
bool isCyclic(); // returns true if there is a cycle in this graph
};
Graph::Graph(int V)
{
this->V = V;
}

{
{
}
// This function is a variation of DFSUytil() in

http://www.geeksforgeeks.org/archives/18212
bool Graph::isCyclicUtil(int v, bool visited[], bool *recStack)
{
if(visited[v] == false)
{
// Mark the current node as visited and part of recursion stack
visited[v] = true;
recStack[v] = true;

{
if ( !visited[*i] && isCyclicUtil(*i, visited, recStack) )
return true;
else if (recStack[*i])
return true;
}
}
recStack[v] = false; // remove the vertex from recursion stack
return false;
}
// Returns true if the graph contains a cycle, else false.

// This function is a variation of DFS() in http://www.geeksforgeeks.org/archives/18212
bool Graph::isCyclic()
{
// Mark all the vertices as not visited and not part of recursion
// stack
bool *recStack = new bool[V];
for(int i = 0; i < V; i++)
{
visited[i] = false;
recStack[i] = false;
}
// Call the recursive helper function to detect cycle in different

// DFS trees
for(int i = 0; i < V; i++)
if (isCyclicUtil(i, visited, recStack))
return true;
return false;
}
int main()
{
Graph g(4);
g.addEdge(0, 1);
g.addEdge(0, 2);
g.addEdge(1, 2);
g.addEdge(2, 0);
g.addEdge(2, 3);
g.addEdge(3, 3);
if(g.isCyclic())
cout << "Graph contains cycle";
cout << "Graph contains cycle";
else
cout << "Graph doesn't contain cycle";
return 0;
}

Output:
Graph contains cycle

Time Complexity of this method is same as time complexity of DFS traversal which is O(V+E).
discussed above.
Find the maximum sum leaf to root path in a Binary Tree
Given a Binary Tree, find the maximum sum path from a leaf to root. For example, in the following tree,
there are three leaf to root paths 8->-2->10, -4->-2->10 and 7->10. The sums of these three paths are 16, 4
and 17 respectively. The maximum of them is 17 and the path for maximum is 7->10.
10
/ \
-2 7
/ \
8 -4

Solution
1) First find the leaf node that is on the maximum sum path. In the following code getTargetLeaf() does this
by assigning the result to *target_leaf_ref.
2) Once we have the target leaf node, we can print the maximum sum path by traversing the tree. In the
following code, printPath() does this.
The main function is maxSumPath() that uses above two functions to get the complete solution.
#include<stdio.h>
#include<limits.h>

struct node
{
int data;
struct node *left;
struct node *right;
};
// A utility function that prints all nodes on the path from root to target_leaf
bool printPath (struct node *root, struct node *target_leaf)
{
// base case
if (root == NULL)
return false;
// return true if this node is the target_leaf or target leaf is present in

// one of its descendants
if (root == target_leaf || printPath(root->left, target_leaf) ||
printPath(root->right, target_leaf) )
{
return true;
}
return false;
}
// This function Sets the target_leaf_ref to refer the leaf node of the maximum
// path sum. Also, returns the max_sum using max_sum_ref
void getTargetLeaf (struct node *node, int *max_sum_ref, int curr_sum,
struct node **target_leaf_ref)
{
if (node == NULL)
if (node == NULL)
return;
// Update current sum to hold sum of nodes on path from root to this node
curr_sum = curr_sum + node->data;
// If this is a leaf node and path to this node has maximum sum so far,
// then make this node target_leaf
if (node->left == NULL && node->right == NULL)
{
if (curr_sum > *max_sum_ref)
{
*max_sum_ref = curr_sum;
*target_leaf_ref = node;
}
}
// If this is not a leaf node, then recur down to find the target_leaf
getTargetLeaf (node->left, max_sum_ref, curr_sum, target_leaf_ref);
getTargetLeaf (node->right, max_sum_ref, curr_sum, target_leaf_ref);
}
// Returns the maximum sum and prints the nodes on max sum path
int maxSumPath (struct node *node)
{
// base case
if (node == NULL)
return 0;
struct node *target_leaf;

int max_sum = INT_MIN;
// find the target leaf and maximum sum

getTargetLeaf (node, &max_sum, 0, &target_leaf);
// print the path from root to the target leaf

printPath (node, target_leaf);
return max_sum; // return maximum sum

}

struct node* newNode (int data)
{
temp->data = data;
temp->left = NULL;
temp->right = NULL;
return temp;
}

int main()
{

root = newNode(10);
root->left = newNode(-2);
root->left->right = newNode(-4);
printf ("Following are the nodes on the maximum sum path \n");
int sum = maxSumPath(root);
int sum = maxSumPath(root);
printf ("\nSum of the nodes is %d ", sum);
getchar();
return 0;
}

Output:
Following are the nodes on the maximum sum path

7 10
Sum of the nodes is 17

Time Complexity: Time complexity of the above solution is O(n) as it involves tree traversal two times.
discussed above.
Implement two stacks in an array
Create a data structure twoStacks that represents two stacks. Implementation of twoStacks should use only
one array, i.e., both stacks should use the same array for storing elements. Following functions must be
supported by twoStacks.
push1(int x) –> pushes x to first stack

push2(int x) –> pushes x to second stack
pop1() –> pops an element from first stack and return the popped element
pop2() –> pops an element from second stack and return the popped element
Implementation of twoStack should be space efficient.
Method 1 (Divide the space in two halves)

A simple way to implement two stacks is to divide the array in two halves and assign the half half space to
two stacks, i.e., use arr[0] to arr[n/2] for stack1, and arr[n/2+1] to arr[n-1] for stack2 where arr[] is the
array to be used to implement two stacks and size of array be n.
The problem with this method is inefficient use of array space. A stack push operation may result in stack
overflow even if there is space available in arr[]. For example, say the array size is 6 and we push 3 elements
to stack1 and do not push anything to second stack2. When we push 4th element to stack1, there will be
overflow even if we have space for 3 more elements in array.
Method 2 (A space efficient implementation)

This method efficiently utilizes the available space. It doesn’t cause an overflow if there is space available in
arr[]. The idea is to start two stacks from two extreme corners of arr[]. stack1 starts from the leftmost
element, the first element in stack1 is pushed at index 0. The stack2 starts from the rightmost corner, the
first element in stack2 is pushed at index (n-1). Both stacks grow (or shrink) in opposite direction. To check
for overflow, all we need to check is for space between top elements of both stacks. This check is highlighted
in the below code.
#include<iostream>
#include<stdlib.h>
class twoStacks
{
int *arr;
int size;
int top1, top2;
public:
twoStacks(int n) // constructor
{
size = n;
arr = new int[n];
top1 = -1;
top2 = size;
}
// Method to push an element x to stack1

void push1(int x)
{
// There is at least one empty space for new element
if (top1 < top2 - 1)
{
top1++;
top1++;
arr[top1] = x;
}
else
{
cout << "Stack Overflow";
exit(1);
}
}
// Method to push an element x to stack2

void push2(int x)
{
// There is at least one empty space for new element
if (top1 < top2 - 1)
{
top2--;
arr[top2] = x;
}
else
{
cout << "Stack Overflow";
exit(1);
}
}
// Method to pop an element from first stack

int pop1()
{
if (top1 >= 0 )
{
int x = arr[top1];
top1--;
return x;
}
else
{
cout << "Stack UnderFlow";
exit(1);
}
}
// Method to pop an element from second stack

int pop2()
{
if (top2 < size)
{
int x = arr[top2];
top2++;
return x;
}
else
{
cout << "Stack UnderFlow";
exit(1);
}
}
};
/* Driver program to test twStacks class */

int main()
{
twoStacks ts(5);
ts.push1(5);
ts.push1(5);
ts.push2(10);
ts.push2(15);
ts.push1(11);
ts.push2(7);
cout << "Popped element from stack1 is " << ts.pop1();
ts.push2(40);
cout << "\nPopped element from stack2 is " << ts.pop2();
return 0;
}

Output:
Popped element from stack1 is 11

Popped element from stack2 is 40

Time complexity of all 4 operations of twoStack is O(1).

We will extend to 3 stacks in an array in a separate post.
discussed above.
Find if there is a path between two vertices in a directed graph
Given a Directed Graph and two vertices in it, check whether there is a path from the first given vertex to
second. For example, in the following graph, there is a path from vertex 1 to 3. As another example, there is
no path from 3 to 0.
We can either use Breadth First Search (BFS) or Depth First Search (DFS) to find path between two vertices.
Take the first vertex as source in BFS (or DFS), follow the standard BFS (or DFS). If we see the second vertex
in our traversal, then return true. Else return false.
Following is C++ code that uses BFS for finding reachability of second vertex from first vertex.
// Program to check if there is exist a path between two vertices of a graph.

#include<iostream>
#include <list>
// This class represents a directed graph using adjacency list representation

class Graph
{
public:
bool isReachable(int s, int d); // returns true if there is a path from s to d
};
Graph::Graph(int V)
{
this->V = V;
}

{
}
// A BFS based function to check whether d is reachable from s.

bool Graph::isReachable(int s, int d)
{
// Base case
if (s == d)
return true;

for (int i = 0; i < V; i++)
visited[i] = false;

list<int> queue;
// Mark the current node as visited and enqueue it

visited[s] = true;
queue.push_back(s);
// it will be used to get all adjacent vertices of a vertex

while (!queue.empty())
{
// Dequeue a vertex from queue and print it
s = queue.front();
queue.pop_front();
// Get all adjacent vertices of the dequeued vertex s

// If a adjacent has not been visited, then mark it visited
// and enqueue it
for (i = adj[s].begin(); i != adj[s].end(); ++i)
{
// If this adjacent node is the destination node, then return true
if (*i == d)
return true;
// Else, continue to do BFS

if (!visited[*i])
{
visited[*i] = true;
queue.push_back(*i);
}
}
}
return false;
}

int main()
{
Graph g(4);
g.addEdge(0, 1);
g.addEdge(0, 2);
g.addEdge(1, 2);
g.addEdge(2, 0);
g.addEdge(2, 3);
g.addEdge(3, 3);
int u = 1, v = 3;
if(g.isReachable(u, v))
cout<< "\n There is a path from " << u << " to " << v;
else
cout<< "\n There is no path from " << u << " to " << v;
u = 3, v = 1;
if(g.isReachable(u, v))
cout<< "\n There is a path from " << u << " to " << v;
else
cout<< "\n There is no path from " << u << " to " << v;
return 0;
}

Output:
There is a path from 1 to 3

There is no path from 3 to 1

As an exercise, try an extended version of the problem where the complete path between two vertices is also
needed.
discussed above.
Check whether two strings are anagram of each other
Write a function to check whether two given strings are anagram of each other or not. An anagram of a string
is another string that contains same characters, only the order of characters can be different. For example,
“abcd” and “dabc” are anagram of each other.

1) Sort both strings
2) Compare the sorted strings
#include <stdio.h>
#include <string.h>
/* Fucntion prototype for srting a given string using quick sort */

void quickSort(char *arr, int si, int ei);
/* function to check whether two strings are anagram of each other */

bool areAnagram(char *str1, char *str2)
{
// Get lenghts of both strings
int n1 = strlen(str1);
int n2 = strlen(str2);
// If lenght of both strings is not same, then they cannot

// be anagram
if (n1 != n2)
return false;
// Sort both strings

quickSort (str1, 0, n1 - 1);
quickSort (str2, 0, n2 - 1);
// Compare sorted strings

for (int i = 0; i < n1; i++)
if (str1[i] != str2[i])
return false;
return true;
}
// Following functions (exchange and partition are needed for quickSort)

void exchange(char *a, char *b)
{
char temp;
temp = *a;
*a = *b;
*b = temp;
}
int partition(char A[], int si, int ei)

{
char x = A[ei];
int i = (si - 1);
int j;
for (j = si; j <= ei - 1; j++)

{
if(A[j] <= x)
{
i++;
}
}
return (i + 1);
}

ei --> Ending index
*/
void quickSort(char A[], int si, int ei)
{
if(si < ei)
{
}
}

int main()
{
char str1[] = "test";
char str2[] = "ttew";
if ( areAnagram(str1, str2) )
printf("The two strings are anagram of each other");
else
printf("The two strings are not anagram of each other");
return 0;
}

Output:
The two strings are not anagram of each other

Time Complexity: Time complexity of this method depends upon the sorting technique used. In the above
implementation, quickSort is used which may be O(n^2) in worst case. If we use a O(nLogn) sorting
algorithm like merge sort, then the complexity becomes O(nLogn)
Method 2 (Count characters)

This method assumes that the set of possible characters in both strings is small. In the following
implementation, it is assumed that the characters are stored using 8 bit and there can be 256 possible
characters.
1) Create count arrays of size 256 for both strings. Initialize all values in count arrays as 0.
2) Iterate through every character of both strings and increment the count of character in the corresponding
count arrays.
3) Compare count arrays. If both count arrays are same, then return true.

# include <stdio.h>
/* function to check whether two strings are anagram of each other */

{
// Create two count arrays and initialize all values as 0
int count1[NO_OF_CHARS] = {0};
int count2[NO_OF_CHARS] = {0};
int i;
// For each character in input strings, increment count in

// the corresponding count array
for (i = 0; str1[i] && str2[i]; i++)
{
count1[str1[i]]++;
count2[str2[i]]++;
}
// If both strings are of different length. Removing this condition

// will make the program fail for strings like "aaca" and "aca"
if (str1[i] || str2[i])
return false;
// Compare count arrays

if (count1[i] != count2[i])
return false;
return true;
}

int main()
{
char str1[] = "geeksforgeeks";
char str2[] = "forgeeksgeeks";
if ( areAnagram(str1, str2) )
printf("The two strings are anagram of each other");
else
printf("The two strings are not anagram of each other");
return 0;
}

Output:
The two strings are anagram of each other

The above implementation can be further to use only one count array instead of two. We can increment the
value in count array for characters in str1 and decrement for characters in str2. Finally, if all count values are
0, then the two strings are anagram of each other. Thanks to Ace for suggesting this optimization.


{
// Create a count array and initialize all values as 0
int count[NO_OF_CHARS] = {0};
int i;
// For each character in input strings, increment count in

// the corresponding count array
for (i = 0; str1[i] && str2[i]; i++)
{
count[str1[i]]++;
count[str2[i]]--;
}
// If both strings are of different length. Removing this condition

// will make the program fail for strings like "aaca" and "aca"
if (str1[i] || str2[i])
return false;
// See if there is any non-zero value in count array

if (count[i])
return false;
return true;
}

If the possible set of characters contains only English alphabets, then we can reduce the size of arrays to 52
and use str[i] – ‘A’ as an index for count arrays. This will further optimize this method.
discussed above.
Dynamic Programming | Set 11 (Egg Dropping Puzzle)
The following is a description of the instance of this famous puzzle involving n=2 eggs and a building with
k=36 floors.
Suppose that we wish to know which stories in a 36-story building are safe to drop eggs from, and which will
cause the eggs to break on landing. We make a few assumptions:
…..An egg that survives a fall can be used again.

…..A broken egg must be discarded.
…..The effect of a fall is the same for all eggs.
…..If an egg breaks when dropped, then it would break if dropped from a higher floor.
…..If an egg survives a fall then it would survive a shorter fall.
…..It is not ruled out that the first-floor windows break eggs, nor is it ruled out that the 36th-floor do not
cause an egg to break.
If only one egg is available and we wish to be sure of obtaining the right result, the experiment can be carried
out in only one way. Drop the egg from the first-floor window; if it survives, drop it from the second floor
window. Continue upward until it breaks. In the worst case, this method may require 36 droppings. Suppose
2 eggs are available. What is the least number of egg-droppings that is guaranteed to work in all cases?
The problem is not actually to find the critical floor, but merely to decide floors from which eggs should be
dropped so that total number of trials are minimized.
Source: Wiki for Dynamic Programming
In this post, we will discuss solution to a general problem with n eggs and k floors. The solution is to try
dropping an egg from every floor (from 1 to k) and recursively calculate the minimum number of droppings
needed in worst case. The floor which gives the minimum value in worst case is going to be part of the
solution.
In the following solutions, we return the minimum number of trails in worst case; these solutions can be
easily modified to print floor numbers of every trials also.
When we drop an egg from a floor x, there can be two cases (1) The egg breaks (2) The egg doesn’t break.
1) If the egg breaks after dropping from xth floor, then we only need to check for floors lower than x with
remaining eggs; so the problem reduces to x-1 floors and n-1 eggs
2) If the egg doesn’t break after dropping from the xth floor, then we only need to check for floors higher
than x; so the problem reduces to k-x floors and n eggs.
Since we need to minimize the number of trials in worst case, we take the maximum of two cases. We
consider the max of above two cases for every floor and choose the floor which yields minimum number of
trials.
k ==> Number of floors

n ==> Number of Eggs
eggDrop(n, k) ==> Minimum number of trails needed to find the critical
floor in worst case.
eggDrop(n, k) = 1 + min{max(eggDrop(n - 1, x - 1), eggDrop(n, k - x)):
x in {1, 2, ..., k}}


# include <stdio.h>

int max(int a, int b) { return (a > b)? a: b; }
/* Function to get minimum number of trails needed in worst

case with n eggs and k floors */
int eggDrop(int n, int k)
{
// If there are no floors, then no trials needed. OR if there is
// one floor, one trial needed.
if (k == 1 || k == 0)
return k;
// We need k trials for one egg and k floors

if (n == 1)
return k;
int min = INT_MAX, x, res;
// Consider all droppings from 1st floor to kth floor and

// return the minimum of these values plus 1.
for (x = 1; x <= k; x++)
{
res = max(eggDrop(n-1, x-1), eggDrop(n, k-x));
if (res < min)
min = res;
}
return min + 1;
}

int main()
{
int n = 2, k = 10;
printf ("\nMinimum number of trials in worst case with %d eggs and "
"%d floors is %d \n", n, k, eggDrop(n, k));
return 0;
}

Output:
Minimum number of trials in worst case with 2 eggs and 10 floors is 4

following partial recursion tree, E(2, 2) is being evaluated twice. There will many repeated subproblems
when you draw the complete recursion tree even for small values of n and k.

E(2,4)
|
-------------------------------------
| | | |
| | | |
x=1/\ x=2/\ x=3/ \ x=4/ \
/ \ / \ .... ....
/ \ / \
E(1,0) E(2,3) E(1,1) E(2,2)
/\ /\... / \
x=1/ \ .....
/ \
E(1,0) E(2,2)
/ \
......
Partial recursion tree for 2 eggs and 4 floors.

Since same suproblems are called again, this problem has Overlapping Subprolems property. So Egg
Dropping Puzzle has both properties (see this and this) of a dynamic programming problem. Like other
constructing a temporary array eggFloor[][] in bottom up manner.

Following is C/C++ implementation for Egg Dropping problem using Dynamic Programming.

# include <stdio.h>

int max(int a, int b) { return (a > b)? a: b; }
/* Function to get minimum number of trails needed in worst

case with n eggs and k floors */
int eggDrop(int n, int k)
{
/* A 2D table where entery eggFloor[i][j] will represent minimum
number of trials needed for i eggs and j floors. */
int eggFloor[n+1][k+1];
int res;
int i, j, x;
// We need one trial for one floor and0 trials for 0 floors
for (i = 1; i <= n; i++)
{
eggFloor[i][1] = 1;
eggFloor[i][0] = 0;
}
// We always need j trials for one egg and j floors.

for (j = 1; j <= k; j++)
eggFloor[1][j] = j;
// Fill rest of the entries in table using optimal substructure

// property
for (i = 2; i <= n; i++)
{
for (j = 2; j <= k; j++)
{
eggFloor[i][j] = INT_MAX;
for (x = 1; x <= j; x++)
{
res = 1 + max(eggFloor[i-1][x-1], eggFloor[i][j-x]);
if (res < eggFloor[i][j])
eggFloor[i][j] = res;
}
}
}
// eggFloor[n][k] holds the result

return eggFloor[n][k];
}

int main()
{
int n = 2, k = 36;
printf ("\nMinimum number of trials in worst case with %d eggs and "
"%d floors is %d \n", n, k, eggDrop(n, k));
return 0;
}

Output:
Minimum number of trials in worst case with 2 eggs and 36 floors is 8

Time Complexity: O(nk^2)

Auxiliary Space: O(nk)
As an exercise, you may try modifying the above DP solution to print all intermediate floors (The floors used
for minimum trail solution).
References:
http://archive.ite.journal.informs.org/Vol4No1/Sniedovich/index.php
discussed above.
Searching for Patterns | Set 5 (Finite Automata)
Examples:
1) Input:

pat[] = "TEST"

Output:
2) Input:

pat[] = "AABA"

Output:


We have discussed the following algorithms in the previous posts:
Naive Algorithm
KMP Algorithm
Rabin Karp Algorithm
In this post, we will discuss Finite Automata (FA) based pattern searching algorithm. In FA based algorithm,
we preprocess the pattern and build a 2D array that represents a Finite Automata. Construction of the FA is
the main tricky part of this algorithm. Once the FA is built, the searching is simple. In search, we simply
need to start from the first state of the automata and first character of the text. At every step, we consider
next character of text, look for the next state in the built FA and move to new state. If we reach final state,
then pattern is found in text. Time complexity of the search prcess is O(n).
Before we discuss FA construction, let us take a look at the following FA for pattern ACACAGA.
The abvoe diagrams represent graphical and tabular representations of pattern ACACAGA.
Number of states in FA will be M+1 where M is length of the pattern. The main thing to construct FA is to get
the next state from the current state for every possible character. Given a character x and a state k, we can
get the next state by considering the string “pat[0..k-1]x” which is basically concatenation of pattern
characters pat[0], pat[1] … pat[k-1] and the character x. The idea is to get length of the longest prefix of the
given pattern such that the prefix is also suffix of “pat[0..k-1]x”. The value of length gives us the next state.
For example, let us see how to get the next state from current state 5 and character ‘C’ in the above diagram.
We need to consider the string, “pat[0..5]C” which is “ACACAC”. The lenght of the longest prefix of the
pattern such that the prefix is suffix of “ACACAC”is 4 (“ACAC”). So the next state (from state 5) is 4 for
character ‘C’.
In the following code, computeTF() constructs the FA. The time complexity of the computeTF() is
O(m^3*NO_OF_CHARS) where m is length of the pattern and NO_OF_CHARS is size of alphabet (total
number of possible characters in pattern and text). The implementation tries all possible prefixes starting
from the longest possible that can be a suffix of “pat[0..k-1]x”. There are better implementations to construct
FA in O(m*NO_OF_CHARS) (Hint: we can use something like lps array construction in KMP algorithm).
We have covered the better implementation in our next post on pattern searching.
#include<stdio.h>
#include<string.h>
int getNextState(char *pat, int M, int state, int x)

{
// If the character c is same as next character in pattern,
// then simply increment state
if (state < M && x == pat[state])
return state+1;
int ns, i; // ns stores the result which is next state
// ns finally contains the longest prefix which is also suffix

// in "pat[0..state-1]c"
// in "pat[0..state-1]c"
// Start from the largest possible value and stop when you find
// a prefix which is also suffix
for (ns = state; ns > 0; ns--)
{
if(pat[ns-1] == x)
{
for(i = 0; i < ns-1; i++)
{
if (pat[i] != pat[state-ns+1+i])
break;
}
if (i == ns-1)
return ns;
}
}
return 0;
}
/* This function builds the TF table which represents Finite Automata for a
given pattern */
void computeTF(char *pat, int M, int TF[][NO_OF_CHARS])
{
int state, x;
for (state = 0; state <= M; ++state)
for (x = 0; x < NO_OF_CHARS; ++x)
TF[state][x] = getNextState(pat, M, state, x);
}
/* Prints all occurrences of pat in txt */

{
int TF[M+1][NO_OF_CHARS];
computeTF(pat, M, TF);
// Process txt over FA.

int i, state=0;
for (i = 0; i < N; i++)
{
state = TF[state][txt[i]];
if (state == M)
{
printf ("\n patterb found at index %d", i-M+1);
}
}
}

int main()
{
char *txt = "AABAACAADAABAAABAA";
char *pat = "AABA";
search(pat, txt);
return 0;
}

Output:


References:
Introduction to Algorithms by Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, Clifford Stein
discussed above.
Swap bits in a given number
Given a number x and two positions (from right side) in binary representation of x, write a function that
swaps n bits at given two positions and returns the result. It is also given that the two sets of bits do not
overlap.
Examples:
Let p1 and p2 be the two given positions.
Example 1
Input:
x = 47 (00101111)
p1 = 1 (Start from second bit from right side)
p2 = 5 (Start from 6th bit from right side)
n = 3 (No of bits to be swapped)
Output:
227 (11100011)
The 3 bits starting from the second bit (from right side) are
swapped with 3 bits starting from 6th position (from right side)
Example 2
Input:
x = 28 (11100)
p1 = 0 (Start from first bit from right side)
p2 = 3 (Start from 4th bit from right side)
n = 2 (No of bits to be swapped)
Output:
7 (00111)
The 2 bits starting from 0th postion (from right side) are
swapped with 2 bits starting from 4th position (from right side)

Solution
We need to swap two sets of bits. XOR can be used in a similar way as it is used to swap 2 numbers.
Following is the algorithm.
1) Move all bits of first set to rightmost side

set1 = (x >> p1) & ((1U (1U gives a number that
contains last n bits set and other bits as 0. We do &
with this expression so that bits other than the last
n bits become 0.
2) Move all bits of second set to rightmost side
set2 = (x >> p2) & ((1U
Implementation:

#include<stdio.h>
int swapBits(unsigned int x, unsigned int p1, unsigned int p2, unsigned int n)
{
/* Move all bits of first set to rightmost side */
unsigned int set1 = (x >> p1) & ((1U << n) - 1);
/* Moce all bits of second set to rightmost side */

/* Moce all bits of second set to rightmost side */
unsigned int set2 = (x >> p2) & ((1U << n) - 1);
/* XOR the two sets */

unsigned int xor = (set1 ^ set2);
/* Put the xor bits back to their original positions */

xor = (xor << p1) | (xor << p2);
/* XOR the 'xor' with the original number so that the

two sets are swapped */
unsigned int result = x ^ xor;
return result;
}

int main()
{
int res = swapBits(28, 0, 3, 2);
printf("\nResult = %d ", res);
return 0;
}

Output:

Result = 7

Following is a shorter implementation of the same logic

int swapBits(unsigned int x, unsigned int p1, unsigned int p2, unsigned int n)
{
/* xor contains xor of two sets */
unsigned int xor = ((x >> p1) ^ (x >> p2)) & ((1U << n) - 1);
/* To swap two sets, we need to again XOR the xor with original sets */
return x ^ ((xor << p1) | (xor << p2));
}

References:
Swapping individual bits with XOR
Please write comments if you find anything incorrect, or you want to share more

Backtracking | Set 5 (m Coloring Problem)
Given an undirected graph and a number m, determine if the graph can be colored with at most m colors
such that no two adjacent vertices of the graph are colored with same color. Here coloring of a graph means
assignment of colors to all vertices.
Input:
1) A 2D array graph[V][V] where V is the number of vertices in graph and graph[V][V] is adjacency matrix
representation of the graph. A value graph[i][j] is 1 if there is a direct edge from i to j, otherwise graph[i][j]
is 0.
2) An integer m which is maximum number of colors that can be used.
Output:
An array color[V] that should have numbers from 1 to m. color[i] should represent the color assigned to the
ith vertex. The code should also return false if the graph cannot be colored with m colors.
Following is an example graph (from Wiki page ) that can be colored with 3 colors.
Naive Algorithm
Generate all possible configurations of colors and print a configuration that satisfies the given constraints.

{
if no adjacent vertices are colored with same color
{
}
}

There will be V^m configurations of colors.
The idea is to assign colors one by one to different vertices, starting from the vertex 0. Before assigning a
color, we check for safety by considering already assigned colors to the adjacent vertices. If we find a color
assignment which is safe, we mark the color assignment as part of solution. If we do not a find color due to
clashes then we backtrack and return false.
#include<stdio.h>
// Number of vertices in the graph
#define V 4
void printSolution(int color[]);
/* A utility function to check if the current color assignment

is safe for vertex v */
bool isSafe (int v, bool graph[V][V], int color[], int c)
{
for (int i = 0; i < V; i++)
if (graph[v][i] && c == color[i])
return false;
return true;
}
/* A recursive utility function to solve m coloring problem */

bool graphColoringUtil(bool graph[V][V], int m, int color[], int v)
{
/* base case: If all vertices are assigned a color then
return true */
if (v == V)
return true;
/* Consider this vertex v and try different colors */

for (int c = 1; c <= m; c++)
{
/* Check if assignment of color c to v is fine*/
if (isSafe(v, graph, color, c))
{
color[v] = c;
/* recur to assign colors to rest of the vertices */

if (graphColoringUtil (graph, m, color, v+1) == true)
return true;
/* If assigning color c doesn't lead to a solution

then remove it */
color[v] = 0;
}
}
/* If no color can be assigned to this vertex then return false */

return false;
}
/* This function solves the m Coloring problem using Backtracking.

It mainly uses graphColoringUtil() to solve the problem. It returns
false if the m colors cannot be assigned, otherwise return true and
prints assignments of colors to all vertices. Please note that there
may be more than one solutions, this function prints one of the
feasible solutions.*/
bool graphColoring(bool graph[V][V], int m)
{
// Initialize all color values as 0. This initialization is needed
// correct functioning of isSafe()
int *color = new int[V];
for (int i = 0; i < V; i++)
color[i] = 0;
// Call graphColoringUtil() for vertex 0

if (graphColoringUtil(graph, m, color, 0) == false)
{
return false;
}
// Print the solution

printSolution(color);
return true;
}

void printSolution(int color[])
{
printf("Solution Exists:"
" Following are the assigned colors \n");
for (int i = 0; i < V; i++)
printf(" %d ", color[i]);
printf("\n");
}

int main()
{
/* Create following graph and test whether it is 3 colorable
(3)---(2)
| / |
| / |
| / |
(0)---(1)
*/
bool graph[V][V] = {{0, 1, 1, 1},
{1, 0, 1, 0},
{1, 1, 0, 1},
{1, 0, 1, 0},
};
int m = 3; // Number of colors
graphColoring (graph, m);
return 0;
}

Output:
Solution Exists: Following are the assigned colors

1 2 3 2

References:
http://en.wikipedia.org/wiki/Graph_coloring
discussed above.
Pattern Searching | Set 6 (Efficient Construction of Finite Automata)
In the previous post, we discussed Finite Automata based pattern searching algorithm. The FA (Finite
Automata) construction method discussed in previous post takes O((m^3)*NO_OF_CHARS) time. FA can
be constructed in O(m*NO_OF_CHARS) time. In this post, we will discuss the O(m*NO_OF_CHARS)
algorithm for FA construction. The idea is similar to lps (longest prefix suffix) array construction discussed
in the KMP algorithm. We use previously filled rows to fill a new row.
The abvoe diagrams represent graphical and tabular representations of pattern ACACAGA.
Algorithm:
1) Fill the first row. All entries in first row are always 0 except the entry for pat[0] character. For pat[0]
character, we always need to go to state 1.
2) Initialize lps as 0. lps for the first index is always 0.
3) Do following for rows at index i = 1 to M. (M is the length of the pattern)
…..a) Copy the entries from the row at index equal to lps.
…..b) Update the entry for pat[i] character to i+1.
…..c) Update lps “lps = TF[lps][pat[i]]” where TF is the 2D array which is being constructed.
Implementation
Following is C implementation for the above algorithm.
#include<stdio.h>
#include<string.h>
/* This function builds the TF table which represents Finite Automata for a
given pattern */
void computeTransFun(char *pat, int M, int TF[][NO_OF_CHARS])
{
int i, lps = 0, x;
// Fill entries in first row

for (x =0; x < NO_OF_CHARS; x++)
for (x =0; x < NO_OF_CHARS; x++)
TF[0][x] = 0;
TF[0][pat[0]] = 1;
// Fill entries in other rows

for (i = 1; i<= M; i++)
{
// Copy values from row at index lps
for (x = 0; x < NO_OF_CHARS; x++)
TF[i][x] = TF[lps][x];
// Update the entry corresponding to this character

TF[i][pat[i]] = i + 1;
// Update lps for next row to be filled

if (i < M)
lps = TF[lps][pat[i]];
}
}
/* Prints all occurrences of pat in txt */

{
int TF[M+1][NO_OF_CHARS];
computeTransFun(pat, M, TF);
// process text over FA.

int i, j=0;
for (i = 0; i < N; i++)
{
j = TF[j][txt[i]];
if (j == M)
{
printf ("\n pattern found at index %d", i-M+1);
}
}
}

int main()
{
char *txt = "GEEKS FOR GEEKS";
char *pat = "GEEKS";
search(pat, txt);
getchar();
return 0;
}

Output:
pattern found at index 0

pattern found at index 10

Time Complexity for FA construction is O(M*NO_OF_CHARS). The code for search is same as the previous
post and time complexity for it is O(n).
discussed above.
Backtracking | Set 6 (Hamiltonian Cycle)
Hamiltonian Path in an undirected graph is a path that visits each vertex exactly once. A Hamiltonian cycle
(or Hamiltonian circuit) is a Hamiltonian Path such that there is an edge (in graph) from the last vertex to
the first vertex of the Hamiltonian Path. Determine whether a given graph contains Hamiltonian Cycle or
not. If it contains, then print the path. Following are the input and output of the required function.
Input:
A 2D array graph[V][V] where V is the number of vertices in graph and graph[V][V] is adjacency matrix
representation of the graph. A value graph[i][j] is 1 if there is a direct edge from i to j, otherwise graph[i][j]
is 0.
Output:
An array path[V] that should contain the Hamiltonian Path. path[i] should represent the ith vertex in the
Hamiltonian Path. The code should also return false if there is no Hamiltonian Cycle in the graph.
For example, a Hamiltonian Cycle in the following graph is {0, 1, 2, 4, 3, 0}. There are more Hamiltonian
Cycles in the graph like {0, 3, 4, 2, 1, 0}
(0)--(1)--(2)
| / \ |
| / \ |
| / \ |
(3)-------(4)

And the following graph doesn’t contain any Hamiltonian Cycle.
(0)--(1)--(2)
| / \ |
| / \ |
| / \ |
(3) (4)

Naive Algorithm
Generate all possible configurations of vertices and print a configuration that satisfies the given constraints.
There will be n! (n factorial) configurations.

{
if ( there are edges between two consecutive vertices of this
configuration and there is an edge from the last vertex to
the first ).
{
break;
}
}

Create an empty path array and add vertex 0 to it. Add other vertices, starting from the vertex 1. Before
adding a vertex, check for whether it is adjacent to the previously added vertex and not already added. If we
find such a vertex, we add the vertex as part of the solution. If we do not find a vertex then we return false.

Following is C/C++ implementation of the Backtracking solution.
// Program to print Hamiltonian cycle

#include<stdio.h>

#define V 5
void printSolution(int path[]);
/* A utility function to check if the vertex v can be added at index 'pos'

in the Hamiltonian Cycle constructed so far (stored in 'path[]') */
bool isSafe(int v, bool graph[V][V], int path[], int pos)
{
/* Check if this vertex is an adjacent vertex of the previously
added vertex. */
if (graph [ path[pos-1] ][ v ] == 0)
return false;
/* Check if the vertex has already been included.

This step can be optimized by creating an array of size V */
for (int i = 0; i < pos; i++)
if (path[i] == v)
return false;
return true;
}
/* A recursive utility function to solve hamiltonian cycle problem */

bool hamCycleUtil(bool graph[V][V], int path[], int pos)
{
/* base case: If all vertices are included in Hamiltonian Cycle */
if (pos == V)
{
// And if there is an edge from the last included vertex to the
// first vertex
if ( graph[ path[pos-1] ][ path[0] ] == 1 )
return true;
else
return false;
}
// Try different vertices as a next candidate in Hamiltonian Cycle.

// We don't try for 0 as we included 0 as starting point in in hamCycle()
for (int v = 1; v < V; v++)
{
/* Check if this vertex can be added to Hamiltonian Cycle */
if (isSafe(v, graph, path, pos))
{
path[pos] = v;
/* recur to construct rest of the path */

if (hamCycleUtil (graph, path, pos+1) == true)
return true;
/* If adding vertex v doesn't lead to a solution,
then remove it */
path[pos] = -1;
}
}
/* If no vertex can be added to Hamiltonian Cycle constructed so far,

return false;
}
/* This function solves the Hamiltonian Cycle problem using Backtracking.

It mainly uses hamCycleUtil() to solve the problem. It returns false
if there is no Hamiltonian Cycle possible, otherwise return true and
prints the path. Please note that there may be more than one solutions,
this function prints one of the feasible solutions. */
bool hamCycle(bool graph[V][V])
{
int *path = new int[V];
for (int i = 0; i < V; i++)
path[i] = -1;
/* Let us put vertex 0 as the first vertex in the path. If there is

a Hamiltonian Cycle, then the path can be started from any point
of the cycle as the graph is undirected */
path[0] = 0;
if ( hamCycleUtil(graph, path, 1) == false )
{
printf("\nSolution does not exist");
return false;
}
printSolution(path);
return true;
}

void printSolution(int path[])
{
printf ("Solution Exists:"
" Following is one Hamiltonian Cycle \n");
for (int i = 0; i < V; i++)
printf(" %d ", path[i]);
// Let us print the first vertex again to show the complete cycle
printf(" %d ", path[0]);
printf("\n");
}

int main()
{
/* Let us create the following graph
(0)--(1)--(2)
| / \ |
| / \ |
| / \ |
(3)-------(4) */
bool graph1[V][V] = {{0, 1, 0, 1, 0},
{1, 0, 1, 1, 1},
{0, 1, 0, 0, 1},
{1, 1, 0, 0, 1},
{0, 1, 1, 1, 0},
};

hamCycle(graph1);

(0)--(1)--(2)
| / \ |
| / \ |
| / \ |
(3) (4) */
bool graph2[V][V] = {{0, 1, 0, 1, 0},
{1, 0, 1, 1, 1},
{0, 1, 0, 0, 1},
{1, 1, 0, 0, 0},
{0, 1, 1, 0, 0},
};

hamCycle(graph2);
return 0;
}

Output:
Solution Exists: Following is one Hamiltonian Cycle

0 1 2 4 3 0
Solution does not exist

Note that the above code always prints cycle starting from 0. Starting point should not matter as cycle can be
started from any point. If you want to change the starting point, you should make two changes to above
code.
Change “path[0] = 0;” to “path[0] = s;” where s is your new starting point. Also change loop “for (int v = 1; v
Dynamic Programming | Set 12 (Longest Palindromic Subsequence)
Given a sequence, find the length of the longest palindromic subsequence in it. For example, if the given
sequence is “BBABCBCAB”, then the output should be 7 as “BABCBAB” is the longest palindromic
subseuqnce in it. “BBBBB” and “BBCBB” are also palindromic subsequences of the given sequence, but not
the longest ones.
The naive solution for this problem is to generate all subsequences of the given sequence and find the
longest palindromic subsequence. This solution is exponential in term of time complexity. Let us see how
this problem possesses both important properties of a Dynamic Programming (DP) Problem and can
efficiently solved using Dynamic Programming.
Let X[0..n-1] be the input sequence of length n and L(0, n-1) be the length of the longest palindromic
subsequence of X[0..n-1].
If last and first characters of X are same, then L(0, n-1) = L(1, n-2) + 2.
Else L(0, n-1) = MAX (L(1, n-1), L(0, n-2)).
Following is a general recursive solution with all cases handled.
// Everay single character is a palindrom of length 1

L(i, i) = 1 for all indexes i in given sequence
// IF first and last characters are not same

If (X[i] != X[j]) L(i, j) = max{L(i + 1, j),L(i, j - 1)}
// If there are only 2 characters and both are same

Else if (j == i + 1) L(i, j) = 2
// If there are more than two characters, and first and last
// characters are same
Else L(i, j) = L(i + 1, j - 1) + 2

Following is simple recursive implementation of the LPS problem. The implementation simply follows the

#include<stdio.h>
#include<string.h>
// A utility function to get max of two integers

int max (int x, int y) { return (x > y)? x : y; }
// Returns the length of the longest palindromic subsequence in seq

int lps(char *seq, int i, int j)
{
// Base Case 1: If there is only 1 character
if (i == j)
return 1;
// Base Case 2: If there are only 2 characters and both are same
if (seq[i] == seq[j] && i + 1 == j)
return 2;
// If the first and last characters match

if (seq[i] == seq[j])
return lps (seq, i+1, j-1) + 2;
// If the first and last characters do not match

return max( lps(seq, i, j-1), lps(seq, i+1, j) );
}

int main()
{
char seq[] = "GEEKSFORGEEKS";
int n = strlen(seq);
printf ("The lnegth of the LPS is %d", lps(seq, 0, n-1));
getchar();
return 0;
}

Output:
The lnegth of the LPS is 5

Considering the above implementation, following is a partial recursion tree for a sequence of length 6 with
all different characters.
L(0, 5)
/ \
/ \
L(1,5) L(0,4)
/ \ / \
/ \ / \
L(2,5) L(1,4) L(1,4) L(0,3)

In the above partial recursion tree, L(1, 4) is being solved twice. If we draw the complete recursion tree, then
we can see that there are many subproblems which are solved again and again. Since same suproblems are
called again, this problem has Overlapping Subprolems property. So LPS problem has both properties (see
this and this) of a dynamic programming problem. Like other typical Dynamic Programming(DP) problems,
recomputations of same subproblems can be avoided by constructing a temporary array L[][] in bottom up
manner.
#include<stdio.h>
#include<string.h>
// A utility function to get max of two integers

int max (int x, int y) { return (x > y)? x : y; }
// Returns the length of the longest palindromic subsequence in seq

int lps(char *str)
{
int i, j, cl;
int L[n][n]; // Create a table to store results of subproblems
// Strings of length 1 are palindrome of lentgh 1

for (i = 0; i < n; i++)
L[i][i] = 1;
// Build the table. Note that the lower diagonal values of table are
// useless and not filled in the process. The values are filled in a
// manner similar to Matrix Chain Multiplication DP solution (See
// http://www.geeksforgeeks.org/archives/15553). cl is length of
// substring
for (cl=2; cl<=n; cl++)
{
for (i=0; i<n-cl+1; i++)
{
j = i+cl-1;
if (str[i] == str[j] && cl == 2)
L[i][j] = 2;
else if (str[i] == str[j])
L[i][j] = L[i+1][j-1] + 2;
else
L[i][j] = max(L[i][j-1], L[i+1][j]);
}
}
return L[0][n-1];
}

int main()
{
char seq[] = "GEEKS FOR GEEKS";
int n = strlen(seq);
printf ("The lnegth of the LPS is %d", lps(seq));
getchar();
return 0;
}

Output:
The lnegth of the LPS is 7

Time Complexity of the above implementation is O(n^2) which is much better than the worst case time
This problem is close to the Longest Common Subsequence (LCS) problem. In fact, we can use LCS as a
subroutine to solve this problem. Following is the two step solution that uses LCS.
1) Reverse the given sequence and store the reverse in another array say rev[0..n-1]
2) LCS of the given sequence and rev[] will be the longest palindromic sequence.
This solution is also a O(n^2) solution.
discussed above.
References:
http://users.eecs.northwestern.edu/~dda902/336/hw6-sol.pdf
Dynamic Programming | Set 13 (Cutting a Rod)
Given a rod of length n inches and an array of prices that contains prices of all pieces of size smaller than n.
Determine the maximum value obtainable by cutting up the rod and selling the pieces. For example, if
length of the rod is 8 and the values of different pieces are given as following, then the maximum obtainable
value is 22 (by cutting in two pieces of lengths 2 and 6)
length | 1 2 3 4 5 6 7 8
--------------------------------------------
price | 1 5 8 9 10 17 17 20

And if the prices are as following, then the maximum obtainable value is 24 (by cutting in eight pieces of
length 1)
length | 1 2 3 4 5 6 7 8
--------------------------------------------
price | 3 5 8 9 10 17 17 20

The naive solution for this problem is to generate all configurations of different pieces and find the highest
priced configuration. This solution is exponential in term of time complexity. Let us see how this problem
possesses both important properties of a Dynamic Programming (DP) Problem and can efficiently solved
using Dynamic Programming.
We can get the best price by making a cut at different positions and comparing the values obtained after a
cut. We can recursively call the same function for a piece obtained after a cut.
Let cutRoad(n) be the required (best possible price) value for a rod of lenght n. cutRod(n) can be written as
following.
cutRod(n) = max(price[i] + cutRod(n-i-1)) for all i in {0, 1 .. n-1}
Following is simple recursive implementation of the Rod Cutting problem. The implementation simply
follows the recursive structure mentioned above.

// A Naive recursive solution for Rod cutting problem

#include<stdio.h>
#include<limits.h>
// A utility function to get the maximum of two integers

int max(int a, int b) { return (a > b)? a : b;}
/* Returns the best obtainable price for a rod of length n and

price[] as prices of different pieces */
int cutRod(int price[], int n)
{
if (n <= 0)
return 0;
int max_val = INT_MIN;
// Recursively cut the rod in different pieces and compare different

// configurations
for (int i = 0; i<n; i++)
max_val = max(max_val, price[i] + cutRod(price, n-i-1));
return max_val;
}

int main()
{
int arr[] = {1, 5, 8, 9, 10, 17, 17, 20};
printf("Maximum Obtainable Value is %d\n", cutRod(arr, size));
getchar();
return 0;
}

Output:
Maximum Obtainable Value is 22

Considering the above implementation, following is recursion tree for a Rod of length 4.

cR() ---> cutRod()
cR(4)
/ / \ \
/ / \ \
cR(3) cR(2) cR(1) cR(0)
/ | \ / \ |
/ | \ / \ |
cR(2) cR(1) cR(0) cR(1) cR(0) cR(0)
/ \ | |
/ \ | |
cR(1) cR(0) cR(0) cR(0)

In the above partial recursion tree, cR(2) is being solved twice. We can see that there are many subproblems
which are solved again and again. Since same suproblems are called again, this problem has Overlapping
Subprolems property. So the Rod Cutting problem has both properties (see this and this) of a dynamic
programming problem. Like other typical Dynamic Programming(DP) problems, recomputations of same
subproblems can be avoided by constructing a temporary array val[] in bottom up manner.

// A Dynamic Programming solution for Rod cutting problem

#include<stdio.h>
#include<limits.h>
// A utility function to get the maximum of two integers

/* Returns the best obtainable price for a rod of length n and

price[] as prices of different pieces */
int cutRod(int price[], int n)
{
int val[n+1];
val[0] = 0;
int i, j;
// Build the table val[] in bottom up manner and return the last entry
// from the table
for (i = 1; i<=n; i++)
{
int max_val = INT_MIN;
for (j = 0; j < i; j++)
max_val = max(max_val, price[j] + val[i-j-1]);
val[i] = max_val;
}
return val[n];
}

int main()
{
int arr[] = {1, 5, 8, 9, 10, 17, 17, 20};
printf("Maximum Obtainable Value is %d\n", cutRod(arr, size));
getchar();
return 0;
}

Output:
Maximum Obtainable Value is 22

Time Complexity of the above implementation is O(n^2) which is much better than the worst case time
discussed above.
Find subarray with given sum
Given an unsorted array of nonnegative integers, find a continous subarray which adds to a given number.
Examples:
Input: arr[] = {1, 4, 20, 3, 10, 5}, sum = 33

Ouptut: Sum found between indexes 2 and 4
Input: arr[] = {1, 4, 0, 0, 3, 10, 5}, sum = 7

Ouptut: Sum found between indexes 1 and 4
Input: arr[] = {1, 4}, sum = 0

Output: No subarray found

There may be more than one subarrays with sum as the given sum. The following solutions print first such
subarray.
Source: Google Interview Question
Method 1 (Simple)
A simple solution is to consider all subarrays one by one and check the sum of every subarray. Following
program implements the simple solution. We run two loops: the outer loop picks a starting point i and the
inner loop tries all subarrays starting from i.

/* A simple program to print subarray with sum as given sum */

#include<stdio.h>
/* Returns true if the there is a subarray of arr[] with sum equal to 'sum'
otherwise returns false. Also, prints the result */
int subArraySum(int arr[], int n, int sum)
{
int curr_sum, i, j;
// Pick a starting point

for (i = 0; i < n; i++)
{
curr_sum = arr[i];
// try all subarrays starting with 'i'

for (j = i+1; j <= n; j++)
{
if (curr_sum == sum)
{
printf ("Sum found between indexes %d and %d", i, j-1);
return 1;
}
if (curr_sum > sum || j == n)
break;
curr_sum = curr_sum + arr[j];
}
}
printf("No subarray found");

return 0;
}

int main()
{
int arr[] = {15, 2, 4, 8, 9, 5, 10, 23};
int sum = 23;
subArraySum(arr, n, sum);
return 0;
}

Output:
Sum found between indexes 1 and 4

Time Complexity: O(n^2) in worst case.
Method 2 (Efficient)
Initialize a variable curr_sum as first element. curr_sum indicates the sum of current subarray. Start from
the second element and add all elements one by one to the curr_sum. If curr_sum becomes equal to sum,
then print the solution. If curr_sum exceeds the sum, then remove trailing elemnents while curr_sum is
greater than sum.
Following is C implementation of the above approach.
/* An efficient program to print subarray with sum as given sum */

#include<stdio.h>
/* Returns true if the there is a subarray of arr[] with sum equal to 'sum'
otherwise returns false. Also, prints the result */
int subArraySum(int arr[], int n, int sum)
{
/* Initialize curr_sum as value of first element
and starting point as 0 */
int curr_sum = arr[0], start = 0, i;
/* Add elements one by one to curr_sum and if the curr_sum exceeds the
sum, then remove starting element */
for (i = 1; i <= n; i++)
{
// If curr_sum exceeds the sum, then remove the starting elements
while (curr_sum > sum && start < i-1)
{
curr_sum = curr_sum - arr[start];
start++;
}
// If curr_sum becomes equal to sum, then return true

if (curr_sum == sum)
{
printf ("Sum found between indexes %d and %d", start, i-1);
return 1;
}
// Add this element to curr_sum

if (i < n)
curr_sum = curr_sum + arr[i];
}
// If we reach here, then no subarray

printf("No subarray found");
return 0;
}

int main()
{
int arr[] = {15, 2, 4, 8, 9, 5, 10, 23};
int sum = 23;
subArraySum(arr, n, sum);
return 0;
}

Output:

Sum found between indexes 1 and 4

Time complexity of method 2 looks more than O(n), but if we take a closer look at the program, then we can
figure out the time complexity is O(n). We can prove it by counting the number of operations performed on
every element of arr[] in worst case. There are at most 2 operations performed on every element: (a) the
element is added to the curr_sum (b) the element is subtracted from curr_sum. So the upper bound on
number of operations is 2n which is O(n).
discussed above.
Dynamic Programming | Set 14 (Maximum Sum Increasing Subsequence)
Given an array of n positive integers. Write a program to find the sum of maximum sum subsequence of the
given array such that the intgers in the subsequence are sorted in increasing order. For example, if input is
{1, 101, 2, 3, 100, 4, 5}, then output should be 106 (1 + 2 + 3 + 100), if the input array is {3, 4, 5, 10}, then
output should be 22 (3 + 4 + 5 + 10) and if the input array is {10, 5, 4, 3}, then output should be 10
Solution
This problem is a variation of standard Longest Increasing Subsequence (LIS) problem. We need a slight
change in the Dynamic Programming solution of LIS problem. All we need to change is to use sum as a
criteria instead of length of increasing subsequence.
Following is C implementation for Dynamic Programming solution of the problem.
/* Dynamic Programming implementation of Maximum Sum Increasing

Subsequence (MSIS) problem */
#include<stdio.h>
/* maxSumIS() returns the maximum sum of increasing subsequence in arr[] of

size n */
int maxSumIS( int arr[], int n )
{
int *msis, i, j, max = 0;
msis = (int*) malloc ( sizeof( int ) * n );
/* Initialize msis values for all indexes */

for ( i = 0; i < n; i++ )
msis[i] = arr[i];
/* Compute maximum sum values in bottom up manner */

for ( i = 1; i < n; i++ )
for ( j = 0; j < i; j++ )
if ( arr[i] > arr[j] && msis[i] < msis[j] + arr[i])
msis[i] = msis[j] + arr[i];
/* Pick maximum of all msis values */

for ( i = 0; i < n; i++ )
if ( max < msis[i] )
max = msis[i];

free( msis );
return max;
}

int main()
{
int arr[] = {1, 101, 2, 3, 100, 4, 5};
printf("Sum of maximum sum increasing subsequence is %d\n",
maxSumIS( arr, n ) );
getchar();
return 0;
}

Source: Maximum Sum Increasing Subsequence Problem
discussed above.
Longest Monotonically Increasing Subsequence Size (N log N)
After few months of gap posting an algo. The current post is pending from long time, and many readers
(e.g. here, here, here may be few more, I am not keeping track of all) are posting requests for explanation of
the below problem.
Given an array of random numbers. Find longest monotonically increasing

subsequence (LIS) in the array. I know many of you might have read recursive and dynamic
programming (DP) solutions. There are few requests for O(N log N) algo in the forum posts.
For the time being, forget about recursive and DP solutions. Let us take small samples and extend the
solution to large instances. Even though it may look complex at first time, once if we understood the logic,
coding is simple.
Consider an input array A = {2, 5, 3}. I will extend the array during explanation.
By observation we know that the LIS is either {2, 3} or {2, 5}. Note that I am considering only strictly
increasing monotone sequences.
Let us add two more elements, say 7, 11 to the array. These elements will extend the existing sequences. Now
the increasing sequences are {2, 3, 7, 11} and {2, 5, 7, 11} for the input array {2, 5, 3, 7, 11}.
Further, we add one more element, say 8 to the array i.e. input array becomes {2, 5, 3, 7, 11, 8}. Note that the
latest element 8 is greater than smallest element of any active sequence (will discuss shortly about active
sequences). How can we extend the existing sequences with 8? First of all, can 8 be part of LIS? If yes, how?
If we want to add 8, it should come after 7 (by replacing 11).
Since the approach is offline (what we mean by offline?), we are not sure whether adding 8 will extend the
series or not. Assume there is 9 in the input array, say {2, 5, 3, 7, 11, 8, 7, 9 …}. We can replace 11 with 8, as
there is potentially best candidate (9) that can extend the new series {2, 3, 7, 8} or {2, 5, 7, 8}.
Our observation is, assume that the end element of largest sequence is E. We can add (replace) current
element A[i] to the existing sequence if there is an element A[j] (j > i) such that E < A[i] < A[j] or (E > A[i] <
A[j] – for replace). In the above example, E = 11, A[i] = 8 and A[j] = 9.
In case of our original array {2, 5, 3}, note that we face same situation when we are adding 3 to increasing
sequence {2, 5}. I just created two increasing sequences to make explanation simple. Instead of two
sequences, 3 can replace 5 in the sequence {2, 5}.
I know it will be confusing, I will clear it shortly!
The question is, when will it be safe to add or replace an element in the existing sequence?
Let us consider another sample A = {2, 5, 3}. Say, the next element is 1. How can it extend the current
sequences {2,3} or {2, 5}. Obviously, it can’t extend either. Yet, there is a potential that the new smallest
element can be start of an LIS. To make it clear, consider the array is {2, 5, 3, 1, 2, 3, 4, 5, 6}. Making 1 as
new sequence will create new sequence which is largest.
The observation is, when we encounter new smallest element in the array, it can be a potential candidate
to start new sequence.
From the observations, we need to maintain lists of increasing sequences.
In general, we have set of active lists of varying length. We are adding an element A[i] to these lists. We
scan the lists (for end elements) in decreasing order of their length. We will verify the end elements of all the
lists to find a list whose end element is smaller than A[i] (floor value).
Our strategy determined by the following conditions,
1. If A[i] is smallest among all end candidates of active lists, we will start new active list of
length 1.
2. If A[i] is largest among all end candidates of active lists, we will clone the largest active
list, and extend it by A[i].
3. If A[i] is in between, we will find a list with largest end element that is smaller than A[i].
Clone and extend this list by A[i]. We will discard all other lists of same length as that of this
modified list.
Note that at any instance during our construction of active lists, the following condition is maintained.
“end element of smaller list is smaller than end elements of larger lists”.
It will be clear with an example, let us take example from wiki {0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15}.

A[0] = 0. Case 1. There are no active lists, create one.
0.
-----------------------------------------------------------------------------
A[1] = 8. Case 2. Clone and extend.
0.
0, 8.
-----------------------------------------------------------------------------
A[2] = 4. Case 3. Clone, extend and discard.
0.
0, 4.
0, 8. Discarded
-----------------------------------------------------------------------------
0.
0, 4.
0, 4, 12.
-----------------------------------------------------------------------------
0.
0, 2.
0, 4. Discarded.
0, 4, 12.
-----------------------------------------------------------------------------
0.
0, 2.
0, 2, 10.
0, 4, 12. Discarded.
-----------------------------------------------------------------------------
0.
0, 2.
0, 2, 6.
0, 2, 10. Discarded.
-----------------------------------------------------------------------------
0.
0, 2.
0, 2, 6.
0, 2, 6, 14.
-----------------------------------------------------------------------------
0.
0, 1.
0, 2. Discarded.
0, 2, 6.
0, 2, 6, 14.
-----------------------------------------------------------------------------
0.
0, 1.
0, 2, 6.
0, 2, 6, 9.
0, 2, 6, 14. Discarded.
-----------------------------------------------------------------------------
0.
0, 1.
0, 1, 5.
0, 2, 6. Discarded.
0, 2, 6, 9.
-----------------------------------------------------------------------------
0.
0, 1.
0, 1, 5.
0, 2, 6, 9.
0, 2, 6, 9, 13.
-----------------------------------------------------------------------------
0.
0, 1.
0, 1, 3.
0, 1, 5. Discarded.
0, 2, 6, 9.
0, 2, 6, 9, 13.
-----------------------------------------------------------------------------
0.
0, 1.
0, 1, 3.
0, 2, 6, 9.
0, 2, 6, 9, 11.
0, 2, 6, 9, 13. Discarded.
-----------------------------------------------------------------------------
0.
0, 1.
0, 1, 3.
0, 1, 3, 7.
0, 2, 6, 9. Discarded.
0, 2, 6, 9, 11.
----------------------------------------------------------------------------
0.
0, 1.
0, 1, 3.
0, 1, 3, 7.
0, 2, 6, 9, 11.
0, 2, 6, 9, 11, 15. <-- LIS List
----------------------------------------------------------------------------

It is required to understand above strategy to devise an algorithm. Also, ensure we have maintained the
condition, “end element of smaller list is smaller than end elements of larger lists“. Try with few other
examples, before reading further. It is important to understand what happening to end elements.
Algorithm:
Querying length of longest is fairly easy. Note that we are dealing with end elements only. We need not to
maintain all the lists. We can store the end elements in an array. Discarding operation can be simulated with
replacement, and extending a list is analogous to adding more elements to array.
We will use an auxiliary array to keep end elements. The maximum length of this array is that of input. In the
worst case the array divided into N lists of size one (note that it does’t lead to worst case complexity). To
discard an element, we will trace ceil value of A[i] in auxiliary array (again observe the end elements in your
rough work), and replace ceil value with A[i]. We extend a list by adding element to auxiliary array. We also
maintain a counter to keep track of auxiliary array length.
Bonus: You have learnt Patience Sorting technique partially :).
Here is a proverb, “Tell me and I will forget. Show me and I will remember. Involve me and I will
understand.” So, pick a suit from deck of cards. Find the longest increasing sub-sequence of cards from the
shuffled suit. You will never forget the approach.
Given below is code to find length of LIS,

#include <iostream>
#include <string.h>
#include <stdio.h>
#define ARRAY_SIZE(A) sizeof(A)/sizeof(A[0])

// Binary search (note boundaries in the caller)
// A[] is ceilIndex in the caller
int CeilIndex(int A[], int l, int r, int key) {
int m;
while( r - l > 1 ) {
m = l + (r - l)/2;
(A[m] >= key ? r : l) = m; // ternary expression returns an l-value
}
return r;
}
int LongestIncreasingSubsequenceLength(int A[], int size) {

// Add boundary case, when array size is one
int *tailTable = new int[size];

int len; // always points empty slot
memset(tailTable, 0, sizeof(tailTable[0])*size);
tailTable[0] = A[0];
len = 1;
for( int i = 1; i < size; i++ ) {
if( A[i] < tailTable[0] )
// new smallest value
tailTable[0] = A[i];
else if( A[i] > tailTable[len-1] )
// A[i] wants to extend largest subsequence
tailTable[len++] = A[i];
else
// A[i] wants to be current end candidate of an existing subsequence
// It will replace ceil value in tailTable
tailTable[CeilIndex(tailTable, -1, len-1, A[i])] = A[i];
}
delete[] tailTable;
return len;
}
int main() {
int A[] = { 2, 5, 3, 7, 11, 8, 10, 13, 6 };
int n = ARRAY_SIZE(A);
printf("Length of Longest Increasing Subsequence is %d\n",

LongestIncreasingSubsequenceLength(A, n));
return 0;
}

Complexity:
The loop runs for N elements. In the worst case (what is worst case input?), we may end up querying ceil
value using binary search (log i) for many A[i].
Therefore, T(n) < O( log N! ) = O(N log N). Analyse to ensure that the upper and lower bounds are also O( N
log N ). The complexity is THETA (N log N).
Exercises:
1. Design an algorithm to construct the longest increasing list. Also, model your solution using DAGs.
2. Design an algorithm to construct all monotonically increasing lists of equal longest size.
3. Is the above algorithm an online algorithm?
4. Design an algorithm to construct the longest decreasing list..
— Venki. Please write comments if you find anything incorrect, or you want to share more information about
the topic discussed above.
Find a triplet that sum to a given value
Given an array and a value, find if there is a triplet in array whose sum is equal to the given value. If there is
such a triplet present in array, then print the triplet and return true. Else return false. For example, if the
given array is {12, 3, 4, 1, 6, 9} and given sum is 24, then there is a triplet (12, 3 and 9) present in array
whose sum is 24.
Method 1 (Naive)
A simple method is to generate all possible triplets and compare the sum of every triplet with the given
value. The following code implements this simple method using three nested loops.
# include <stdio.h>
// returns true if there is triplet with sum equal

// to 'sum' present in A[]. Also, prints the triplet
bool find3Numbers(int A[], int arr_size, int sum)
{
int l, r;
// Fix the first element as A[i]

for (int i = 0; i < arr_size-2; i++)
{
// Fix the second element as A[j]
for (int j = i+1; j < arr_size-1; j++)
{
// Now look for the third number
for (int k = j+1; k < arr_size; k++)
{
if (A[i] + A[j] + A[k] == sum)
{
printf("Triplet is %d, %d, %d", A[i], A[j], A[k]);
return true;
}
}
}
}
// If we reach here, then no triplet was found

return false;
}

int main()
{
int A[] = {1, 4, 45, 6, 10, 8};
int sum = 22;
int arr_size = sizeof(A)/sizeof(A[0]);
find3Numbers(A, arr_size, sum);
getchar();
return 0;
}

Output:

Triplet is 4, 10, 8


Time complexity of the method 1 is O(n^3). The complexity can be reduced to O(n^2) by sorting the array
first, and then using method 1 of this post in a loop.
2) Fix the first element as A[i] where i is from 0 to array size – 2. After fixing the first element of triplet, find
the other two elements using method 1 of this post.
# include <stdio.h>
// A utility function to sort an array using Quicksort

// returns true if there is triplet with sum equal

// to 'sum' present in A[]. Also, prints the triplet
bool find3Numbers(int A[], int arr_size, int sum)
{
int l, r;

quickSort(A, 0, arr_size-1);
/* Now fix the first element one by one and find the
other two elements */
for (int i = 0; i < arr_size - 2; i++)
{
// To find the other two elements, start two index variables

// from two corners of the array and move them toward each
// other
l = i + 1; // index of the first element in the remaining elements
r = arr_size-1; // index of the last element
while (l < r)
{
if( A[i] + A[l] + A[r] == sum)
{
printf("Triplet is %d, %d, %d", A[i], A[l], A[r]);
return true;
}
else if (A[i] + A[l] + A[r] < sum)
l++;
else // A[i] + A[l] + A[r] > sum
r--;
}
}
// If we reach here, then no triplet was found

return false;
}
/* FOLLOWING 2 FUNCTIONS ARE ONLY FOR SORTING

PURPOSE */
PURPOSE */
{
int temp;
temp = *a;
*a = *b;
*b = temp;
}

{
int x = A[ei];
int i = (si - 1);
int j;
for (j = si; j <= ei - 1; j++)

{
if(A[j] <= x)
{
i++;
}
}
return (i + 1);
}

ei --> Ending index
*/
{
if(si < ei)
{
}
}

int main()
{
int A[] = {1, 4, 45, 6, 10, 8};
int sum = 22;
int arr_size = sizeof(A)/sizeof(A[0]);
find3Numbers(A, arr_size, sum);
getchar();
return 0;
}

Output:

Triplet is 4, 8, 10

Note that there can be more than one triplet with the given sum. We can easily modify the above methods to
print all triplets.
discussed above.
Find the smallest positive number missing from an unsorted array
You are given an unsorted array with both positive and negative elements. You have to find the smallest
positive number missing from the array in O(n) time using constant extra space. You can modify the original
array.
Examples
Input: {2, 3, 7, 6, 8, -1, -10, 15}

Output: 1
Input: { 2, 3, -7, 6, 8, 1, -10, 15 }

Output: 4
Input: {1, 1, 0, -1, -2}

Output: 2

Source: To find the smallest positive no missing from an unsorted array
A naive method to solve this problem is to search all positive integers, starting from 1 in the given array.
We may have to search at most n+1 numbers in the given array. So this solution takes O(n^2) in worst case.
We can use sorting to solve it in lesser time complexity. We can sort the array in O(nLogn) time. Once the
array is sorted, then all we need to do is a linear scan of the array. So this approach takes O(nLogn + n) time
which is O(nLogn).
We can also use hashing. We can build a hash table of all positive elements in the given array. Once the
hash table is built. We can look in the hash table for all positive integers, starting from 1. As soon as we find a
number which is not there in hash table, we return it. This approach may take O(n) time on average, but it
requires O(n) extra space.
A O(n) time and O(1) extra space solution:

The idea is similar to this post. We use array elements as index. To mark presence of an element x, we change
the value at the index x to negative. But this approach doesn’t work if there are non-positive (-ve and 0)
numbers. So we segregate positive from negative numbers as first step and then apply the approach.
Following is the two step algorithm.

1) Segregate positive numbers from others i.e., move all non-positive numbers to left side. In the following
code, segregate() function does this part.
2) Now we can ignore non-positive elements and consider only the part of array which contains all positive
elements. We traverse the array containing all positive numbers and to mark presence of an element x, we
change the sign of value at index x to negative. We traverse the array again and print the first index which
has positive value. In the following code, findMissingPositive() function does this part. Note that in
findMissingPositive, we have subtracted 1 from the values as indexes start from 0 in C.
/* Program to find the smallest positive missing number */

#include <stdio.h>
#include <stdlib.h>
/* Utility to swap to integers */

{
int temp;
temp = *a;
*a = *b;
*b = temp;
}
/* Utility function that puts all non-positive (0 and negative) numbers on left
side of arr[] and return count of such numbers */
int segregate (int arr[], int size)
{
int j = 0, i;
{
if (arr[i] <= 0)
{
swap(&arr[i], &arr[j]);
j++; // increment count of non-positive integers
}
}
return j;
}
/* Find the smallest positive missing number in an array that contains

all positive integers */
int findMissingPositive(int arr[], int size)
{
int i;
// Mark arr[i] as visited by making arr[arr[i] - 1] negative. Note that

// 1 is subtracted because index start from 0 and positive numbers start from 1
{
if(abs(arr[i]) - 1 < size && arr[abs(arr[i]) - 1] > 0)
arr[abs(arr[i]) - 1] = -arr[abs(arr[i]) - 1];
}
// Return the first index value at which is positive

if (arr[i] > 0)
return i+1; // 1 is added becuase indexes start from 0
return size+1;
}
/* Find the smallest positive missing number in an array that contains

both positive and negative integers */
int findMissing(int arr[], int size)
{
// First separate positive and negative numbers
int shift = segregate (arr, size);
// Shift the array and call findMissingPositive for

// positive part
return findMissingPositive(arr+shift, size-shift);
}
int main()
{
int arr[] = {0, 10, 2, -10, -20};
int missing = findMissing(arr, arr_size);
printf("The smallest positive missing number is %d ", missing);
getchar();
return 0;
return 0;
}

Output:
The smallest positive missing number is 1

Note that this method modifies the original array. We can change the sign of elements in the segregated
array to get the same set of elements back. But we still loose the order of elements. If we want to keep the
original array as it was, then we can create a copy of the array and run this approach on the temp array.
discussed above.
Find the two numbers with odd occurrences in an unsorted array
Given an unsorted array that contains even number of occurrences for all numbers except two numbers. Find
the two numbers which have odd occurrences in O(n) time complexity and O(1) extra space.
Examples:
Input: {12, 23, 34, 12, 12, 23, 12, 45}

Output: 34 and 45
Input: {4, 4, 100, 5000, 4, 4, 4, 4, 100, 100}

Output: 100 and 5000
Input: {10, 20}

Output: 10 and 20

A naive method to solve this problem is to run two nested loops. The outer loop picks an element and the
inner loop counts the number of occurrences of the picked element. If the count of occurrences is odd then
print the number. The time complexity of this method is O(n^2).
We can use sorting to get the odd occurring numbers in O(nLogn) time. First sort the numbers using an
O(nLogn) sorting algorithm like Merge Sort, Heap Sort.. etc. Once the array is sorted, all we need to do is a
linear scan of the array and print the odd occurring number.
We can also use hashing. Create an empty hash table which will have elements and their counts. Pick all
elements of input array one by one. Look for the picked element in hash table. If the element is found in
hash table, increment its count in table. If the element is not found, then enter it in hash table with count as
1. After all elements are entered in hash table, scan the hash table and print elements with odd count. This
approach may take O(n) time on average, but it requires O(n) extra space.
A O(n) time and O(1) extra space solution:

The idea is similar to method 2 of this post. Let the two odd occurring numbers be x and y. We use bitwise
XOR to get x and y. The first step is to do XOR of all elements present in array. XOR of all elements gives us
XOR of x and y because of the following properties of XOR operation.
1) XOR of any number n with itself gives us 0, i.e., n ^ n = 0
2) XOR of any number n with 0 gives us n, i.e., n ^ 0 = n
3) XOR is cumulative and associative.
So we have XOR of x and y after the first step. Let the value of XOR be xor2. Every set bit in xor2 indicates
that the corresponding bits in x and y have values different from each other. For example, if x = 6 (0110) and
y is 15 (1111), then xor2 will be (1001), the two set bits in xor2 indicate that the corresponding bits in x and y
are different. In the second step, we pick a set bit of xor2 and divide array elements in two groups. Both x
and y will go to different groups. In the following code, the rightmost set bit of xor2 is picked as it is easy to
get rightmost set bit of a number. If we do XOR of all those elements of array which have the corresponding
bit set (or 1), then we get the first odd number. And if we do XOR of all those elements which have the
corresponding bit 0, then we get the other odd occurring number. This step works because of the same
properties of XOR. All the occurrences of a number will go in same set. XOR of all occurrences of a number
which occur even number number of times will result in 0 in its set. And the xor of a set will be one of the
odd occurring elements.

// Program to find the two odd occurring elements

#include<stdio.h>
/* Prints two numbers that occur odd number of times. The

function assumes that the array size is at least 2 and
there are exactly two numbers occurring odd number of times. */
void printTwoOdd(int arr[], int size)
{
int xor2 = arr[0]; /* Will hold XOR of two odd occurring elements */
int set_bit_no; /* Will have only single set bit of xor2 */
int i;
int n = size - 2;
int x = 0, y = 0;
/* Get the xor of all elements in arr[]. The xor will basically
be xor of two odd occurring elements */
xor2 = xor2 ^ arr[i];
/* Get one set bit in the xor2. We get rightmost set bit
in the following line as it is easy to get */
set_bit_no = xor2 & ~(xor2-1);
/* Now divide elements in two sets:

1) The elements having the corresponding bit as 1.
2) The elements having the corresponding bit as 0. */
{
/* XOR of first set is finally going to hold one odd
occurring number x */
x = x ^ arr[i];
/* XOR of second set is finally going to hold the other

odd occurring number y */
else
y = y ^ arr[i];
}
printf("\n The two ODD elements are %d & %d ", x, y);

}

int main()
{
int arr[] = {4, 2, 4, 5, 2, 3, 3, 1};
printTwoOdd(arr, arr_size);
getchar();
return 0;
}

Output:

The two ODD elements are 5 & 1


discussed above.
Pattern Searching | Set 7 (Boyer Moore Algorithm – Bad Character
Heuristic)
Given a text txt[0..n-1] and a pattern pat[0..m-1], write a function search(char pat[], char txt[]) that prints all
occurrences of pat[] in txt[]. You may assume that n > m.
Examples:
1) Input:

pat[] = "TEST"
Output:
2) Input:
pat[] = "AABA"
Output:


Naive Algorithm
KMP Algorithm
Finite Automata based Algorithm
In this post, we will discuss Boyer Moore pattern searching algorithm. Like KMP and Finite Automata
algorithms, Boyer Moore algorithm also preprocesses the pattern.
Boyer Moore is a combination of following two approaches.
1) Bad Character Heuristic
2) Good Suffix Heuristic
Both of the above heuristics can also be used independently to search a pattern in a text. Let us first
understand how two independent approaches work together in the Boyer Moore algorithm. If we take a look
at the Naive algorithm, it slides the pattern over the text one by one. KMP algorithm does preprocessing over
the pattern so that the pattern can be shifted by more than one. The Boyer Moore algorithm does
preprocessing for the same reason. It preporcesses the pattern and creates different arrays for both
heuristics. At every step, it slides the pattern by max of the slides suggested by the two heuristics. So it uses
best of the two heuristics at every step. Unlike the previous pattern searching algorithms, Boyer Moore
algorithm starts matching from the last character of the pattern.
In this post, we will discuss bad character heuristic, and discuss Good Suffix heuristic in the next post.
The idea of bad character heuristic is simple. The character of the text which doesn’t match with the current
character of pattern is called the Bad Character. Whenever a character doesn’t match, we slide the pattern in
such a way that aligns the bad character with the last occurrence of it in pattern. We preprocess the pattern
and store the last occurrence of every possible character in an array of size equal to alphabet size. If the
character is not present at all, then it may result in a shift by m (length of pattern). Therefore, the bad
character heuristic takes O(n/m) time in the best case.
/* Program for Bad Character Heuristic of Boyer Moore String Matching Algorithm */
# include <stdio.h>

int max (int a, int b) { return (a > b)? a: b; }
// The preprocessing function for Boyer Moore's bad character heuristic

void badCharHeuristic( char *str, int size, int badchar[NO_OF_CHARS])
{
int i;
// Initialize all occurrences as -1

badchar[i] = -1;
// Fill the actual value of last occurrence of a character

for (i = 0; i < size; i++)
badchar[(int) str[i]] = i;
}
/* A pattern searching function that uses Bad Character Heuristic of

Boyer Moore Algorithm */
void search( char *txt, char *pat)
{
int m = strlen(pat);
int n = strlen(txt);
int badchar[NO_OF_CHARS];
/* Fill the bad character array by calling the preprocessing

function badCharHeuristic() for given pattern */
badCharHeuristic(pat, m, badchar);
int s = 0; // s is shift of the pattern with respect to text

while(s <= (n - m))
{
int j = m-1;
/* Keep reducing index j of pattern while characters of

pattern and text are matching at this shift s */
while(j >= 0 && pat[j] == txt[s+j])
j--;
/* If the pattern is present at current shift, then index j

will become -1 after the above loop */
if (j < 0)
{
printf("\n pattern occurs at shift = %d", s);
/* Shift the pattern so that the next character in text

/* Shift the pattern so that the next character in text
aligns with the last occurrence of it in pattern.
The condition s+m < n is necessary for the case when
pattern occurs at the end of text */
s += (s+m < n)? m-badchar[txt[s+m]] : 1;
else
/* Shift the pattern so that the bad character in text
aligns with the last occurrence of it in pattern. The
max function is used to make sure that we get a positive
shift. We may get a negative shift if the last occurrence
of bad character in pattern is on the right side of the
current character. */
s += max(1, j - badchar[txt[s+j]]);
}
}
/* Driver program to test above funtion */

int main()
{
char txt[] = "ABAAABCD";
char pat[] = "ABC";
search(txt, pat);
return 0;
}

Output:
pattern occurs at shift = 4

The Bad Character Heuristic may take O(mn) time in worst case. The worst case occurs when all characters
of the text and pattern are same. For example, txt[] = “AAAAAAAAAAAAAAAAAA” and pat[] = “AAAAA”.
discussed above.
Josephus problem | Set 1 (A O(n) Solution)
In computer science and mathematics, the Josephus Problem (or Josephus permutation) is a theoretical
problem. Following is the problem statement:
There are n people standing in a circle waiting to be executed. The counting out begins at some point in the
circle and proceeds around the circle in a fixed direction. In each step, a certain number of people are
skipped and the next person is executed. The elimination proceeds around the circle (which is becoming
smaller and smaller as the executed people are removed), until only the last person remains, who is given
freedom. Given the total number of persons n and a number k which indicates that k-1 persons are skipped
and kth person is killed in circle. The task is to choose the place in the initial circle so that you are the last
one remaining and so survive.
For example, if n = 5 and k = 2, then the safe position is 3. Firstly, the person at position 2 is killed, then
person at position 4 is killed, then person at position 1 is killed. Finally, the person at position 5 is killed. So
the person at position 3 survives.
If n = 7 and k = 3, then the safe position is 4. The persons at positions 3, 6, 2, 7, 5, 1 are killed in order, and
person at position 4 survives.
The problem has following recursive structure.
josephus(n, k) = (josephus(n - 1, k) + k-1) % n + 1

josephus(1, k) = 1

After the first person (kth from begining) is killed, n-1 persons are left. So we call josephus(n – 1, k) to get
the position with n-1 persons. But the position returned by josephus(n – 1, k) will consider the position
starting from k%n + 1. So, we must make adjustments to the position returned by josephus(n – 1, k).
Following is simple recursive implementation of the Josephus problem. The implementation simply follows
the recursive structure mentioned above.

#include <stdio.h>
int josephus(int n, int k)

{
if (n == 1)
return 1;
else
/* The position returned by josephus(n - 1, k) is adjusted because the
recursive call josephus(n - 1, k) considers the original position
k%n + 1 as position 1 */
return (josephus(n - 1, k) + k-1) % n + 1;
}
// Driver Program to test above function

int main()
{
int n = 14;
int k = 2;
printf("The chosen place is %d", josephus(n, k));
return 0;
}

Output:
The chosen place is 13

The problem can also be solved in O(kLogn) time complexity which is a better solution for large n and small
k. We will cover that solution in a separate post.
Source:
http://en.wikipedia.org/wiki/Josephus_problem
discussed above.
Merge two BSTs with limited extra space
Given two Binary Search Trees(BST), print the elements of both BSTs in sorted form. The expected time
complexity is O(m+n) where m is the number of nodes in first tree and n is the number of nodes in second
tree. Maximum allowed auxiliary space is O(height of the first tree + height of the second tree).
Examples:
First BST
3
/ \
1 5
Second BST
4
/ \
2 6
Output: 1 2 3 4 5 6
First BST
8
/ \
2 10
/
1
Second BST
5
/
3
/
0
Output: 0 1 2 3 5 8 10

Source: Google interview question
A similar question has been discussed earlier. Let us first discuss already discussed methods of the previous
post which was for Balanced BSTs. The method 1 can be applied here also, but the time complexity will be
O(n^2) in worst case. The method 2 can also be applied here, but the extra space required will be O(n) which
violates the constraint given in this question. Method 3 can be applied here but the step 3 of method 3 can’t
be done in O(n) for an unbalanced BST.
Thanks to Kumar for suggesting the following solution.
The idea is to use iterative inorder traversal. We use two auxiliary stacks for two BSTs. Since we need to
print the elements in sorted form, whenever we get a smaller element from any of the trees, we print it. If the
element is greater, then we push it back to stack for the next iteration.
#include<stdio.h>
#include<stdlib.h>
// Structure of a BST Node

struct node
{
int data;
struct node *left;
struct node *right;
struct node *right;
};
//.................... START OF STACK RELATED STUFF....................

// A stack node
struct snode
{
struct node *t;
struct snode *next;
};
// Function to add an elemt k to stack

void push(struct snode **s, struct node *k)
{
struct snode *tmp = (struct snode *) malloc(sizeof(struct snode));
//perform memory check here

tmp->t = k;
tmp->next = *s;
(*s) = tmp;
}
// Function to pop an element t from stack

struct node *pop(struct snode **s)
{
struct node *t;
struct snode *st;
st=*s;
(*s) = (*s)->next;
t = st->t;
free(st);
return t;
}
// Fucntion to check whether the stack is empty or not

int isEmpty(struct snode *s)
{
if (s == NULL )
return 1;
return 0;
}
//.................... END OF STACK RELATED STUFF....................

{
temp->data = data;
temp->left = NULL;
temp->right = NULL;
return temp;
}
/* A utility function to print Inoder traversal of a Binary Tree */

void inorder(struct node *root)
{
if (root != NULL)
{
inorder(root->left);
inorder(root->right);
}
}
// The function to print data of two BSTs in sorted order

void merge(struct node *root1, struct node *root2)
{
// s1 is stack to hold nodes of first BST
struct snode *s1 = NULL;
// Current node of first BST

struct node *current1 = root1;
// s2 is stack to hold nodes of second BST

struct snode *s2 = NULL;
// Current node of second BST

struct node *current2 = root2;
// If first BST is empty, then output is inorder

// traversal of second BST
if (root1 == NULL)
{
inorder(root2);
return;
}
// If second BST is empty, then output is inorder
// traversal of first BST
if (root2 == NULL)
{
inorder(root1);
return ;
}
// Run the loop while there are nodes not yet printed.
// The nodes may be in stack(explored, but not printed)
// or may be not yet explored
while (current1 != NULL || !isEmpty(s1) ||
current2 != NULL || !isEmpty(s2))
{
// Following steps follow iterative Inorder Traversal
if (current1 != NULL || current2 != NULL )
{
// Reach the leftmost node of both BSTs and push ancestors of
// leftmost nodes to stack s1 and s2 respectively
if (current1 != NULL)
{
push(&s1, current1);
current1 = current1->left;
}
if (current2 != NULL)
{
current2 = current2->left;
}
}
else
{
// If we reach a NULL node and either of the stacks is empty,
// then one tree is exhausted, ptint the other tree
if (isEmpty(s1))
{
while (!isEmpty(s2))
{
current2 = pop (&s2);
current2->left = NULL;
inorder(current2);
}
return ;
}
if (isEmpty(s2))
{
{
current1 = pop (&s1);
current1->left = NULL;
inorder(current1);
}
return ;
}
// Pop an element from both stacks and compare the

// popped elements
current1 = pop(&s1);
current2 = pop(&s2);
// If element of first tree is smaller, then print it

// and push the right subtree. If the element is larger,
// then we push it back to the corresponding stack.
if (current1->data < current2->data)
{
printf("%d ", current1->data);
current1 = current1->right;
current2 = NULL;
}
else
{
printf("%d ", current2->data);
current2 = current2->right;
current1 = NULL;
}
}
}
}

int main()
{
struct node *root1 = NULL, *root2 = NULL;
/* Let us create the following tree as first tree

3
/ \
1 5
*/
root1 = newNode(3);
/* Let us create the following tree as second tree

4
/ \
2 6
*/
root2 = newNode(4);
// Print sorted nodes of both trees

merge(root1, root2);
return 0;
}


Auxiliary Space: O(height of the first tree + height of the second tree)
discussed above.
The Celebrity Problem
Another classical problem.
In a party of N people, only one person is known to everyone. Such a person may be present in the
party, if yes, (s)he doesn’t know anyone in the party. We can only ask questions like “does A know B? “.
Find the stranger (celebrity) in minimum number of questions.
We can describe the problem input as an array of numbers/characters representing persons in the party. We
also have a hypothetical function HaveAcquaintance(A, B) which returns true if A knows B, false otherwise.
How can we solve the problem, try yourself first.
We measure the complexity in terms of calls made to HaveAcquaintance().
Graph:
We can model the solution using graphs. Initialize indegree and outdegree of every vertex as 0. If A knows B,
draw a directed edge from A to B, increase indegree of B and outdegree of A by 1. Construct all possible edges
of the graph for every possible pair [i, j]. We have NC2 pairs. If celebrity is present in the party, we will have
one sink node in the graph with outdegree of zero, and indegree of N-1. We can find the sink node in (N)
time, but the overall complexity is O(N2) as we need to construct the graph first.
Recursion:
We can decompose the problem into combination of smaller instances. Say, if we know celebrity of N-1
persons, can we extend the solution to N? We have two possibilities, Celebrity(N-1) may know N, or N
already knew Celebrity(N-1). In the former case, N will be celebrity if N doesn’t know anyone else. In the
later case we need to check that Celebrity(N-1) doesn’t know N.
Solve the problem of smaller instance during divide step. On the way back, we may find a celebrity from the
smaller instance. During combine stage, check whether the returned celebrity is known to everyone and he
doesn’t know anyone. The recurrence of the recursive decomposition is,
T(N) = T(N-1) + O(N)
T(N) = O(N2). You may try Writing pseudo code to check your recursion skills.
Using Stack:
The graph construction takes O(N2) time, it is similar to brute force search. In case of recursion, we reduce
the problem instance by not more than one, and also combine step may examine M-1 persons (M – instance
size).
We have following observation based on elimination technique (Refer Polya’s How to Solve It book).
If A knows B, then A can’t be celebrity. Discard A, and B may be celebrity.

If A doesn’t know B, then B can’t be celebrity. Discard B, and A may be celebrity.
Repeat above two steps till we left with only one person.
Ensure the remained person is celebrity. (Why do we need this step?)
We can use stack to verity celebrity.
1. Push all the celebrities into a stack.

2. Pop off top two persons from the stack, discard one person based on return status of
HaveAcquaintance(A, B).
3. Push the remained person onto stack.
4. Repeat step 2 and 3 until only one person remains in the stack.
5. Check the remained person in stack doesn’t have acquaintance with anyone else.
We will discard N elements utmost (Why?). If the celebrity is present in the party, we will call
HaveAcquaintance() 3(N-1) times. Here is code using stack.
#include <iostream>
#include <list>
// Max # of persons in the party

#define N 8
// Celebrities identified with numbers from 0 through size-1

int size = 4;
// Person with 2 is celebrity
bool MATRIX[N][N] = {{0, 0, 1, 0}, {0, 0, 1, 0}, {0, 0, 0, 0}, {0, 0, 1, 0}};
bool HaveAcquiantance(int a, int b) { return MATRIX[a][b]; }
int CelebrityUsingStack(int size)

{
// Handle trivial case of size = 2
list<int> stack; // Careful about naming

int i;
int C; // Celebrity
i = 0;
while( i < size )
{
stack.push_back(i);
i = i + 1;
}
int A = stack.back();
stack.pop_back();
int B = stack.back();
stack.pop_back();
while( stack.size() != 1 )
{
if( HaveAcquiantance(A, B) )
{
A = stack.back();
stack.pop_back();
}
else
{
B = stack.back();
stack.pop_back();
}
}
// Potential candidate?
C = stack.back();
stack.pop_back();
// Last candidate was not examined, it leads one excess comparison (optimise)
if( HaveAcquiantance(C, B) )
C = B;
if( HaveAcquiantance(C, A) )
C = A;
// I know these are redundant,
// we can simply check i against C
i = 0;
while( i < size )
{
if( C != i )
stack.push_back(i);
i = i + 1;
}
while( !stack.empty() )
{
i = stack.back();
stack.pop_back();
// C must not know i

if( HaveAcquiantance(C, i) )
return -1;
// i must know C
if( !HaveAcquiantance(i, C) )
return -1;
}
return C;
}
int main()
{
int id = CelebrityUsingStack(size);
id == -1 ? cout << "No celebrity" : cout << "Celebrity ID " << id;
return 0;
}

Output

Celebrity ID 2

Complexity O(N). Total comparisons 3(N-1). Try the above code for successful MATRIX {{0, 0, 0, 1}, {0, 0,
0, 1}, {0, 0, 0, 1}, {0, 0, 0, 1}}.
A Note:
You may think that why do we need a new graph as we already have access to input matrix. Note that the
matrix MATRIX used to help the hypothetical function HaveAcquaintance(A, B), but never accessed via
usual notation MATRIX[i, j]. We have access to the input only through the function HaveAcquiantance(A,
B). Matrix is just a way to code the solution. We can assume the cost of hypothetical function as O(1).
If still not clear, assume that the function HaveAcquiantance accessing information stored in a set of linked
lists arranged in levels. List node will have next and nextLevel pointers. Every level will have N nodes i.e. an
N element list, next points to next node in the current level list and the nextLevel pointer in last node of
every list will point to head of next level list. For example the linked list representation of above matrix looks
like,

L0 0->0->1->0
|
L1 0->0->1->0
|
L2 0->0->1->0
|
L3 0->0->1->0

The function HaveAcquanintance(i, j) will search in the list for j-th node in the i-th level. Out goal is to
minimize calls to HaveAcquanintance function.
Exercises:
1. Write code to find celebrity. Don’t use any data structures like graphs, stack, etc… you have access to
N
and HaveAcquaintance(int, int) only.
2. Implement the algorithm using Queues. What is your observation? Compare your solution with Finding
Maximum and Minimum in an array and Tournament Tree. What are minimum number of comparisons do
we need (optimal number of calls to HaveAcquaintance())?
Dynamic Programming | Set 15 (Longest Bitonic Subsequence)
Given an array arr[0 … n-1] containing n positive integers, a subsequence of arr[] is called Bitonic if it is first
increasing, then decreasing. Write a function that takes an array as argument and returns the length of the
longest bitonic subsequence.
A sequence, sorted in increasing order is considered Bitonic with the decreasing part as empty. Similarly,
decreasing order sequence is considered Bitonic with the increasing part as empty.
Examples:
Input arr[] = {1, 11, 2, 10, 4, 5, 2, 1};

Output: 6 (A Longest Bitonic Subsequence of length 6 is 1, 2, 10, 4, 2, 1)
Input arr[] = {12, 11, 40, 5, 3, 1}

Output: 5 (A Longest Bitonic Subsequence of length 5 is 12, 11, 5, 3, 1)
Input arr[] = {80, 60, 30, 40, 20, 10}

Output: 5 (A Longest Bitonic Subsequence of length 5 is 80, 60, 30, 20, 10)

Source: Microsoft Interview Question
Solution
This problem is a variation of standard Longest Increasing Subsequence (LIS) problem. Let the input array
be arr[] of length n. We need to construct two arrays lis[] and lds[] using Dynamic Programming solution of
LIS problem. lis[i] stores the length of the Longest Increasing subsequence ending with arr[i]. lds[i] stores
the length of the longest Decreasing subsequence starting from arr[i]. Finally, we need to return the max
value of lis[i] + lds[i] – 1 where i is from 0 to n-1.
Following is C++ implementation of the above Dynamic Programming solution.

/* Dynamic Programming implementation of longest bitonic subsequence problem */

#include<stdio.h>
#include<stdlib.h>
/* lbs() returns the length of the Longest Bitonic Subsequence in

arr[] of size n. The function mainly creates two temporary arrays
lis[] and lds[] and returns the maximum lis[i] + lds[i] - 1.
lis[i] ==> Longest Increasing subsequence ending with arr[i]

lds[i] ==> Longest decreasing subsequence starting with arr[i]
*/
int lbs( int arr[], int n )
{
int i, j;
/* Allocate memory for LIS[] and initialize LIS values as 1 for

all indexes */
int *lis = new int[n];
for ( i = 0; i < n; i++ )
lis[i] = 1;
/* Compute LIS values from left to right */

for ( i = 1; i < n; i++ )
for ( j = 0; j < i; j++ )
if ( arr[i] > arr[j] && lis[i] < lis[j] + 1)
lis[i] = lis[j] + 1;
/* Allocate memory for lds and initialize LDS values for

all indexes */
int *lds = new int [n];
for ( i = 0; i < n; i++ )
lds[i] = 1;
/* Compute LDS values from right to left */

for ( i = n-2; i >= 0; i-- )
for ( j = n-1; j > i; j-- )
if ( arr[i] > arr[j] && lds[i] < lds[j] + 1)
lds[i] = lds[j] + 1;
/* Return the maximum value of lis[i] + lds[i] - 1*/

int max = lis[0] + lds[0] - 1;
for (i = 1; i < n; i++)
if (lis[i] + lds[i] - 1 > max)
max = lis[i] + lds[i] - 1;
return max;
}

int main()
{
int arr[] = {0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15};
printf("Length of LBS is %d\n", lbs( arr, n ) );
getchar();
return 0;
}

Output:

Length of LBS is 7


discussed above
Dynamic Programming | Set 16 (Floyd Warshall Algorithm)
The Floyd Warshall Algorithm is for solving the All Pairs Shortest Path problem. The problem is to find
shortest distances between every pair of vertices in a given edge weighted directed Graph.
Example:
Input:
graph[][] = { {0, 5, INF, 10},
{INF, 0, 3, INF},
{INF, INF, 0, 1},
{INF, INF, INF, 0} }
which represents the following graph
10
(0)------->(3)
| /|\
5 | |
| | 1
\|/ |
(1)------->(2)
3
Note that the value of graph[i][j] is 0 if i is equal to j
And graph[i][j] is INF (infinite) if there is no edge from vertex i to j.
Output:
Shortest distance matrix
0 5 8 9
INF 0 3 4
INF INF 0 1
INF INF INF 0

Floyd Warshall Algorithm

We initialize the solution matrix same as the input graph matrix as a first step. Then we update the solution
matrix by considering all vertices as an intermediate vertex. The idea is to one by one pick all vertices and
update all shortest paths which include the picked vertex as an intermediate vertex in the shortest path.
When we pick vertex number k as an intermediate vertex, we already have considered vertices {0, 1, 2, .. k-1}
as intermediate vertices. For every pair (i, j) of source and destination vertices respectively, there are two
possible cases.
1) k is not an intermediate vertex in shortest path from i to j. We keep the value of dist[i][j] as it is.
2) k is an intermediate vertex in shortest path from i to j. We update the value of dist[i][j] as dist[i][k] +
dist[k][j].
The following figure is taken from the Cormen book. It shows the above optimal substructure property in
the all-pairs shortest path problem.
Following is C implementation of the Floyd Warshall algorithm.

// Program for Floyd Warshall Algorithm
#include<stdio.h>

#define V 4
/* Define Infinite as a large enough value. This value will be used

for vertices not connected to each other */
#define INF 99999
// A function to print the solution matrix

void printSolution(int dist[][V]);
// Solves the all-pairs shortest path problem using Floyd Warshall algorithm
void floydWarshell (int graph[][V])
{
/* dist[][] will be the output matrix that will finally have the shortest
distances between every pair of vertices */
int dist[V][V], i, j, k;
/* Initialize the solution matrix same as input graph matrix. Or

we can say the initial values of shortest distances are based
on shortest paths considering no intermediate vertex. */
for (i = 0; i < V; i++)
for (j = 0; j < V; j++)
dist[i][j] = graph[i][j];
/* Add all vertices one by one to the set of intermediate vertices.

---> Before start of a iteration, we have shortest distances between all
pairs of vertices such that the shortest distances consider only the
vertices in set {0, 1, 2, .. k-1} as intermediate vertices.
----> After the end of a iteration, vertex no. k is added to the set of
intermediate vertices and the set becomes {0, 1, 2, .. k} */
for (k = 0; k < V; k++)
{
// Pick all vertices as source one by one
for (i = 0; i < V; i++)
{
// Pick all vertices as destination for the
// above picked source
for (j = 0; j < V; j++)
{
// If vertex k is on the shortest path from
// i to j, then update the value of dist[i][j]
if (dist[i][k] + dist[k][j] < dist[i][j])
dist[i][j] = dist[i][k] + dist[k][j];
}
}
}
// Print the shortest distance matrix

printSolution(dist);
}

void printSolution(int dist[][V])
{
printf ("Following matrix shows the shortest distances"
" between every pair of vertices \n");
for (int i = 0; i < V; i++)
{
for (int j = 0; j < V; j++)
{
if (dist[i][j] == INF)
if (dist[i][j] == INF)
printf("%7s", "INF");
else
printf ("%7d", dist[i][j]);
}
printf("\n");
}
}

int main()
{
/* Let us create the following weighted graph
10
(0)------->(3)
| /|\
5 | |
| | 1
\|/ |
(1)------->(2)
3 */
int graph[V][V] = { {0, 5, INF, 10},
{INF, 0, 3, INF},
{INF, INF, 0, 1},
{INF, INF, INF, 0}
};

floydWarshell(graph);
return 0;
}

Output:
Following matrix shows the shortest distances between every pair of vertices
0 5 8 9
INF 0 3 4
INF INF 0 1
INF INF INF 0

Time Complexity: O(V^3)
The above program only prints the shortest distances. We can modify the solution to print the shortest paths
also by storing the predecessor information in a separate 2D matrix.
Also, the value of INF can be taken as INT_MAX from limits.h to make sure that we handle maximum
possible value. When we take INF as INT_MAX, we need to change the if condition in the above program to
avoid arithmatic overflow.

#include<limits.h>
#define INF INT_MAX

..........................
if (dist[i][k] != INF && dist[k][j] != INF && dist[i][k] + dist[k][j] < dist[i][j])
dist[i][j] = dist[i][k] + dist[k][j];
...........................

discussed above
Find a sorted subsequence of size 3 in linear time
Given an array of n integers, find the 3 elements such that a[i]
Examples:
Input: arr[] = {12, 11, 10, 5, 6, 2, 30}

Output: 5, 6, 30
Input: arr[] = {1, 2, 3, 4}

Output: 1, 2, 3 OR 1, 2, 4 OR 2, 3, 4
Input: arr[] = {4, 3, 2, 1}

Output: No such triplet

Source: Amazon Interview Question
Hint: Use Auxiliary Space
Solution:
1) Create an auxiliary array smaller[0..n-1]. smaller[i] should store the index of a number which is smaller
than arr[i] and is on left side of arr[i]. smaller[i] should contain -1 if there is no such element.
2) Create another auxiliary array greater[0..n-1]. greater[i] should store the index of a number which is
greater than arr[i] and is on right side of arr[i]. greater[i] should contain -1 if there is no such element.
3) Finally traverse both smaller[] and greater[] and find the index i for which both smaller[i] and greater[i]
are not -1.
#include<stdio.h>
// A function to fund a sorted subsequence of size 3

void find3Numbers(int arr[], int n)
{
int max = n-1; //Index of maximum element from right side
int min = 0; //Index of minimum element from left side
int i;
// Create an array that will store index of a smaller

// element on left side. If there is no smaller element
// on left side, then smaller[i] will be -1.
int *smaller = new int[n];
smaller[0] = -1; // first entry will always be -1
for (i = 1; i < n; i++)
{
if (arr[i] <= arr[min])
{
min = i;
smaller[i] = -1;
}
else
smaller[i] = min;
}
// Create another array that will store index of a

// greater element on right side. If there is no greater
// element on right side, then greater[i] will be -1.
int *greater = new int[n];
int *greater = new int[n];
greater[n-1] = -1; // last entry will always be -1
for (i = n-2; i >= 0; i--)
{
if (arr[i] >= arr[max])
{
max = i;
greater[i] = -1;
}
else
greater[i] = max;
}
// Now find a number which has both a greater number on

// right side and smaller number on left side
for (i = 0; i < n; i++)
{
if (smaller[i] != -1 && greater[i] != -1)
{
printf("%d %d %d", arr[smaller[i]],
arr[i], arr[greater[i]]);
return;
}
}
// If we reach number, then there are no such 3 numbers

printf("No such triplet found");
// Free the dynamically alloced memory to avoid memory leak

delete [] smaller;
delete [] greater;
return;
}

int main()
{
int arr[] = {12, 11, 10, 5, 6, 2, 30};
find3Numbers(arr, n);
return 0;
}

Output:
5 6 30


Auxliary Space: O(n)
Source: How to find 3 numbers in increasing order and increasing indices in an array in linear time
Exercise:
1. Find a subsequence of size 3 such that arr[i] arr[k].
2. Find a sorted subsequence of size 4 in linear time
discussed above
In the previous post, we discussed how a Doubly Linked can be created using only one space for address field
with every node. In this post, we will discuss implementation of memory efficient doubly linked list. We will
mainly discuss following two simple functions.
1) A function to insert a new node at the beginning.

2) A function to traverse the list in forward direction.
In the following code, insert() function inserts a new node at the beginning. We need to change the head
pointer of Linked List, that is why a double pointer is used (See this). Let use first discuss few things again
that have been discussed in the previous post. We store XOR of next and previous nodes with every node
and we call it npx, which is the only address member we have with every node. When we insert a new node at
the beginning, npx of new node will always be XOR of NULL and current head. And npx of current head
must be changed to XOR of new node and node next to current head.
printList() traverses the list in forward direction. It prints data values from every node. To traverse the list,
we need to get pointer to the next node at every point. We can get the address of next node by keeping track
of current node and previous node. If we do XOR of curr->npx and prev, we get the address of next node.
/* C/C++ Implementation of Memory efficient Doubly Linked List */

#include <stdio.h>
#include <stdlib.h>
// Node structure of a memory efficient doubly linked list

struct node
{
int data;
struct node* npx; /* XOR of next and previous node */
};
/* returns XORed value of the node addresses */

struct node* XOR (struct node *a, struct node *b)
{
return (struct node*) ((unsigned int) (a) ^ (unsigned int) (b));
}
/* Insert a node at the begining of the XORed linked list and makes the
newly inserted node as head */
void insert(struct node **head_ref, int data)
{
// Allocate memory for new node
struct node *new_node = (struct node *) malloc (sizeof (struct node) );
/* Since new node is being inserted at the begining, npx of new node
will always be XOR of current head and NULL */
new_node->npx = XOR(*head_ref, NULL);
/* If linked list is not empty, then npx of current head node will be XOR
of new node and node next to current head */
if (*head_ref != NULL)
{
// *(head_ref)->npx is XOR of NULL and next. So if we do XOR of
// it with NULL, we get next
struct node* next = XOR((*head_ref)->npx, NULL);
(*head_ref)->npx = XOR(new_node, next);
}
// Change head
}
// prints contents of doubly linked list in forward direction

void printList (struct node *head)
{
struct node *curr = head;
struct node *next;
printf ("Following are the nodes of Linked List: \n");
while (curr != NULL)

{
// print current node
printf ("%d ", curr->data);
// get address of next node: curr->npx is next^prev, so curr->npx^prev

// will be next^prev^prev which is next
next = XOR (prev, curr->npx);
// update prev and curr for next iteration

prev = curr;
curr = next;
}
}

int main ()
{
/* Create following Doubly Linked List
head-->40<-->30<-->20<-->10 */
insert(&head, 10);
insert(&head, 20);
insert(&head, 30);
insert(&head, 40);
// print the created list

printList (head);
return (0);
}

Output:
Following are the nodes of Linked List:

40 30 20 10

Note that XOR of pointers is not defined by C/C++ standard. So the above implementation may not work on
all platforms.
discussed above
Binary Tree to Binary Search Tree Conversion
Given a Binary Tree, convert it to a Binary Search Tree. The conversion must be done in such a way that
keeps the original structure of Binary Tree.
Examples.
Example 1
Input:
10
/ \
2 7
/ \
8 4
Output:
8
/ \
4 10
/ \
2 7
Example 2
Input:
10
/ \
30 15
/ \
20 5
Output:
15
/ \
10 20
/ \
5 30

Solution
Following is a 3 step solution for converting Binary tree to Binary Search Tree.
1) Create a temp array arr[] that stores inorder traversal of the tree. This step takes O(n) time.
2) Sort the temp array arr[]. Time complexity of this step depends upon the sorting algorithm. In the
following implementation, Quick Sort is used which takes (n^2) time. This can be done in O(nLogn) time
using Heap Sort or Merge Sort.
3) Again do inorder traversal of tree and copy array elements to tree nodes one by one. This step takes O(n)
time.
Following is C implementation of the above approach. The main function to convert is highlighted in the
following code.
/* A program to convert Binary Tree to Binary Search Tree */

#include<stdio.h>
#include<stdlib.h>
/* A binary tree node structure */

struct node
{
{
int data;
struct node *left;
struct node *right;
};
/* A helper function that stores inorder traversal of a tree rooted

with node */
void storeInorder (struct node* node, int inorder[], int *index_ptr)
{
// Base Case
if (node == NULL)
return;
/* first store the left subtree */

storeInorder (node->left, inorder, index_ptr);
/* Copy the root's data */

inorder[*index_ptr] = node->data;
(*index_ptr)++; // increase index for next entry
/* finally store the right subtree */

storeInorder (node->right, inorder, index_ptr);
}
/* A helper function to count nodes in a Binary Tree */

int countNodes (struct node* root)
{
if (root == NULL)
return 0;
return countNodes (root->left) +
countNodes (root->right) + 1;
}
// Following function is needed for library function qsort()

int compare (const void * a, const void * b)
{
return ( *(int*)a - *(int*)b );
}
/* A helper function that copies contents of arr[] to Binary Tree.

This functon basically does Inorder traversal of Binary Tree and
one by one copy arr[] elements to Binary Tree nodes */
void arrayToBST (int *arr, struct node* root, int *index_ptr)
{
// Base Case
if (root == NULL)
return;
/* first update the left subtree */

arrayToBST (arr, root->left, index_ptr);
/* Now update root's data and increment index */

root->data = arr[*index_ptr];
(*index_ptr)++;
/* finally update the right subtree */

arrayToBST (arr, root->right, index_ptr);
}
// This function converts a given Binary Tree to BST

void binaryTreeToBST (struct node *root)
{
// base case: tree is empty
if(root == NULL)
if(root == NULL)
return;
/* Count the number of nodes in Binary Tree so that

we know the size of temporary array to be created */
int n = countNodes (root);
// Create a temp array arr[] and store inorder traversal of tree in arr[]
int *arr = new int[n];
int i = 0;
storeInorder (root, arr, &i);
// Sort the array using library function for quick sort

qsort (arr, n, sizeof(arr[0]), compare);
// Copy array elements back to Binary Tree

i = 0;
arrayToBST (arr, root, &i);
// delete dynamically allocated memory to avoid meory leak

delete [] arr;
}

{
temp->data = data;
temp->left = NULL;
temp->right = NULL;
return temp;
}
/* Utility function to print inorder traversal of Binary Tree */

void printInorder (struct node* node)
{
if (node == NULL)
return;

printInorder (node->left);


printInorder (node->right);
}

int main()
{
/* Constructing tree given in the above figure

10
/ \
30 15
/ \
20 5 */
root = newNode(10);
// convert Binary Tree to BST

binaryTreeToBST (root);
printf("Following is Inorder Traversal of the converted BST: \n");

printInorder (root);
return 0;
}

Output:
Following is Inorder Traversal of the converted BST:

5 10 15 20 30

We will be covering another method for this problem which converts the tree using O(height of tree) extra
space.
discussed above
Dynamic Programming | Set 17 (Palindrome Partitioning)
Given a string, a partitioning of the string is a palindrome partitioning if every substring of the partition is a
palindrome. For example, “aba|b|bbabb|a|b|aba” is a palindrome partitioning of “ababbbabbababa”.
Determine the fewest cuts needed for palindrome partitioning of a given string. For example, minimum 3
cuts are needed for “ababbbabbababa”. The three cuts are “a|babbbab|b|ababa”. If a string is palindrome,
then minimum 0 cuts are needed. If a string of length n containing all different characters, then minimum n-
1 cuts are needed.
Solution
This problem is a variation of Matrix Chain Multiplication problem. If the string is palindrome, then we
simply return 0. Else, like the Matrix Chain Multiplication problem, we try making cuts at all possible places,
recursively calculate the cost for each cut and return the minimum value.
Let the given string be str and minPalPartion() be the function that returns the fewest cuts needed for
palindrome partitioning. following is the optimal substructure property.
// i is the starting index and j is the ending index. i must be passed as 0 and j as n-1
minPalPartion(str, i, j) = 0 if i == j. // When string is of length 1.
minPalPartion(str, i, j) = 0 if str[i..j] is palindrome.
// If none of the above conditions is true, then minPalPartion(str, i, j) can be

// calculated recursively using the following formula.
minPalPartion(str, i, j) = Min { minPalPartion(str, i, k) + 1 +
minPalPartion(str, k+1, j) }
where k varies from i to j-1

Following is Dynamic Programming solution. It stores the solutions to subproblems in two arrays P[][] and
C[][], and reuses the calculated values.
// Dynamic Programming Solution for Palindrome Partitioning Problem

#include <stdio.h>
#include <string.h>
#include <limits.h>

// A utility function to get minimum of two integers
int min (int a, int b) { return (a < b)? a : b; }

// Returns the minimum number of cuts needed to partition a string
// such that every part is a palindrome
int minPalPartion(char *str)
{
// Get the length of the string

/* Create two arrays to build the solution in bottom up manner
C[i][j] = Minimum number of cuts needed for palindrome partitioning
of substring str[i..j]
P[i][j] = true if substring str[i..j] is palindrome, else false
Note that C[i][j] is 0 if P[i][j] is true */
int C[n][n];
bool P[n][n];

int i, j, k, L; // different looping variables

// Every substring of length 1 is a palindrome
for (i=0; i<n; i++)
{
P[i][i] = true;
C[i][i] = 0;
}

/* L is substring length. Build the solution in bottom up manner by
considering all substrings of length starting from 2 to n.
The loop structure is same as Matrx Chain Multiplication problem (
See http://www.geeksforgeeks.org/archives/15553 )*/
for (L=2; L<=n; L++)
{
// For substring of length L, set different possible starting indexes
for (i=0; i<n-L+1; i++)
{
j = i+L-1; // Set ending index

// If L is 2, then we just need to compare two characters. Else
// need to check two corner characters and value of P[i+1][j-1]
if (L == 2)
P[i][j] = (str[i] == str[j]);
else
P[i][j] = (str[i] == str[j]) && P[i+1][j-1];

// IF str[i..j] is palindrome, then C[i][j] is 0
if (P[i][j] == true)
C[i][j] = 0;
else
{
// Make a cut at every possible localtion starting from i to j,
// and get the minimum cost cut.
C[i][j] = INT_MAX;
for (k=i; k<=j-1; k++)
C[i][j] = min (C[i][j], C[i][k] + C[k+1][j]+1);
}
}
}

// Return the min cut value for complete string. i.e., str[0..n-1]
return C[0][n-1];
}

int main()
{
char str[] = "ababbbabbababa";
printf("Min cuts needed for Palindrome Partitioning is %d",
minPalPartion(str));
return 0;
}

Output:
Min cuts needed for Palindrome Partitioning is 3

Time Complexity: O(n3)

An optimization to above approach
In above approach, we can calculating minimum cut while finding all palindromic substring. If we finding all
palindromic substring 1st and then we calculate minimum cut, time complexity will reduce to O(n).
2
Thanks for Vivek for suggesting this optimization.
// Dynamic Programming Solution for Palindrome Partitioning Problem

#include <stdio.h>
#include <string.h>
#include <limits.h>

// A utility function to get minimum of two integers
int min (int a, int b) { return (a < b)? a : b; }

// Returns the minimum number of cuts needed to partition a string
// such that every part is a palindrome
int minPalPartion(char *str)
{
// Get the length of the string

/* Create two arrays to build the solution in bottom up manner
C[i] = Minimum number of cuts needed for palindrome partitioning
of substring str[0..i]
P[i][j] = true if substring str[i..j] is palindrome, else false
Note that C[i] is 0 if P[0][i] is true */
int C[n];
bool P[n][n];

int i, j, k, L; // different looping variables

// Every substring of length 1 is a palindrome
for (i=0; i<n; i++)
{
P[i][i] = true;
}

/* L is substring length. Build the solution in bottom up manner by
considering all substrings of length starting from 2 to n. */
for (L=2; L<=n; L++)
{
// For substring of length L, set different possible starting indexes
for (i=0; i<n-L+1; i++)
{
j = i+L-1; // Set ending index

// If L is 2, then we just need to compare two characters. Else
// need to check two corner characters and value of P[i+1][j-1]
if (L == 2)
P[i][j] = (str[i] == str[j]);
else
P[i][j] = (str[i] == str[j]) && P[i+1][j-1];
}
}
for (i=0; i<n; i++)

{
if (P[0][i] == true)
C[i] = 0;
else
{
C[i] = INT_MAX;
C[i] = INT_MAX;
for(j=0;j<i;j++)
{
if(P[j+1][i] == true && 1+C[j]<C[i])
C[i]=1+C[j];
}
}
}

// Return the min cut value for complete string. i.e., str[0..n-1]
return C[n-1];
}

int main()
{
char str[] = "ababbbabbababa";
printf("Min cuts needed for Palindrome Partitioning is %d",
minPalPartion(str));
return 0;
}

Output:
Min cuts needed for Palindrome Partitioning is 3

discussed above.
Count total set bits in all numbers from 1 to n
Given a positive integer n, count the total number of set bits in binary representation of all numbers from 1 to
n.
Examples:
Input: n = 3
Output: 4
Input: n = 6
Output: 9
Input: n = 7
Output: 12
Input: n = 8
Output: 13

Method 1 (Simple)
A simple solution is to run a loop from 1 to n and sum the count of set bits in all numbers from 1 to n.

// A simple program to count set bits in all numbers from 1 to n.

#include <stdio.h>
// A utility function to count set bits in a number x

unsigned int countSetBitsUtil(unsigned int x);
// Returns count of set bits present in all numbers from 1 to n

unsigned int countSetBits(unsigned int n)
{
int bitCount = 0; // initialize the result
for(int i = 1; i <= n; i++)

bitCount += countSetBitsUtil(i);
return bitCount;
}
// A utility function to count set bits in a number x

unsigned int countSetBitsUtil(unsigned int x)
{
if (x <= 0)
return 0;
return (x %2 == 0? 0: 1) + countSetBitsUtil (x/2);
}

int main()
{
int n = 4;
printf ("Total set bit count is %d", countSetBits(n));
return 0;
}

Output:

Total set bit count is 6

Method 2 (Tricky)
If the input number is of the form 2^b -1 e.g., 1,3,7,15.. etc, the number of set bits is b * 2^(b-1). This is
because for all the numbers 0 to (2^b)-1, if you complement and flip the list you end up with the same list
(half the bits are on, half off).
If the number does not have all set bits, then some position m is the position of leftmost set bit. The number
of set bits in that position is n – (1 0|0 0 0|0 1 0|1 0 0|1 1 -|– 1|0 0 1|0 1 1|1 0
The leftmost set bit is in position 2 (positions are considered starting from 0). If we mask that off what
remains is 2 (the “1 0″ in the right part of the last row.) So the number of bits in the 2nd position (the lower
left box) is 3 (that is, 2 + 1). The set bits from 0-3 (the upper right box above) is 2*2^(2-1) = 4. The box in the
lower right is the remaining bits we haven’t yet counted, and is the number of set bits for all the numbers up
to 2 (the value of the last entry in the lower right box) which can be figured recursively.

// A O(Logn) complexity program to count set bits in all numbers from 1 to n

#include <stdio.h>
/* Returns position of leftmost set bit. The rightmost

position is considered as 0 */
unsigned int getLeftmostBit (int n)
{
int m = 0;
while (n > 1)
{
n = n >> 1;
m++;
}
return m;
}
/* Given the position of previous leftmost set bit in n (or an upper

bound on leftmost position) returns the new position of leftmost
set bit in n */
unsigned int getNextLeftmostBit (int n, int m)
{
unsigned int temp = 1 << m;
while (n < temp)
{
temp = temp >> 1;
m--;
}
return m;
}
// The main recursive function used by countSetBits()

unsigned int _countSetBits(unsigned int n, int m);
// Returns count of set bits present in all numbers from 1 to n

unsigned int countSetBits(unsigned int n)
{
// Get the position of leftmost set bit in n. This will be
// used as an upper bound for next set bit function
int m = getLeftmostBit (n);
// Use the position

return _countSetBits (n, m);
}
unsigned int _countSetBits(unsigned int n, int m)

{
// Base Case: if n is 0, then set bit count is 0
if (n == 0)
return 0;
/* get position of next leftmost set bit */

m = getNextLeftmostBit(n, m);
// If n is of the form 2^x-1, i.e., if n is like 1, 3, 7, 15, 31,.. etc,

// then we are done.
// Since positions are considered starting from 0, 1 is added to m
if (n == ((unsigned int)1<<(m+1))-1)
return (unsigned int)(m+1)*(1<<m);
// update n for next recursive call

n = n - (1<<m);
return (n+1) + countSetBits(n) + m*(1<<(m-1));
return (n+1) + countSetBits(n) + m*(1<<(m-1));
}

int main()
{
int n = 17;
printf ("Total set bit count is %d", countSetBits(n));
return 0;
}

Total set bit count is 35

Time Complexity: O(Logn). From the first look at the implementation, time complexity looks more. But if we
take a closer look, statements inside while loop of getNextLeftmostBit() are executed for all 0 bits in n. And
the number of times recursion is executed is less than or equal to set bits in n. In other words, if the control
goes inside while loop of getNextLeftmostBit(), then it skips those many bits in recursion.
Thanks to agatsu and IC for suggesting this solution.
See this for another solution suggested by Piyush Kapoor.
discussed above
Largest subarray with equal number of 0s and 1s
Given an array containing only 0s and 1s, find the largest subarray which contain equal no of 0s and 1s.
Expected time complexity is O(n).
Examples:
Input: arr[] = {1, 0, 1, 1, 1, 0, 0}

Output: 1 to 6 (Starting and Ending indexes of output subarray)
Input: arr[] = {1, 1, 1, 1}

Output: No such subarray
Input: arr[] = {0, 0, 1, 1, 0}

Output: 0 to 3 Or 1 to 4

Source: Largest subarray with equal number of 0s and 1s
Method 1 (Simple)
A simple method is to use two nested loops. The outer loop picks a starting point i. The inner loop considers
all subarrays starting from i. If size of a subarray is greater than maximum size so far, then update the
maximum size.
In the below code, 0s are considered as -1 and sum of all values from i to j is calculated. If sum becomes 0,
then size of this subarray is compared with largest size so far.

// A simple program to find the largest subarray with equal number of 0s and 1s
#include <stdio.h>
// This function Prints the starting and ending indexes of the largest subarray
// with equal number of 0s and 1s. Also returns the size of such subarray.
int findSubArray(int arr[], int n)
{
int sum = 0;
int maxsize = -1, startindex;
// Pick a starting point as i

for (int i = 0; i < n-1; i++)
{
sum = (arr[i] == 0)? -1 : 1;
// Consider all subarrays starting from i

for (int j = i+1; j < n; j++)
{
(arr[j] == 0)? sum += -1: sum += 1;
// If this is a 0 sum subarray, then compare it with

// maximum size subarray calculated so far
if(sum == 0 && maxsize < j-i+1)
{
maxsize = j - i + 1;
startindex = i;
}
}
}
if ( maxsize == -1 )
printf("No such subarray");
else
printf("%d to %d", startindex, startindex+maxsize-1);
return maxsize;
}

int main()
{
int arr[] = {1, 0, 0, 1, 0, 1, 1};
findSubArray(arr, size);
return 0;
}

Output:

0 to 5


Method 2 (Tricky)
Following is a solution that uses O(n) extra space and solves the problem in O(n) time complexity.
Let input array be arr[] of size n and maxsize be the size of output subarray.
1) Consider all 0 values as -1. The problem now reduces to find out the maximum length subarray with sum
= 0.
2) Create a temporary array sumleft[] of size n. Store the sum of all elements from arr[0] to arr[i] in
sumleft[i]. This can be done in O(n) time.
3) There are two cases, the output subarray may start from 0th index or may start from some other index.
We will return the max of the values obtained by two cases.
4) To find the maximum length subarray starting from 0th index, scan the sumleft[] and find the maximum
i where sumleft[i] = 0.
5) Now, we need to find the subarray where subarray sum is 0 and start index is not 0. This problem is
equivalent to finding two indexes i & j in sumleft[] such that sumleft[i] = sumleft[j] and j-i is maximum. To
solve this, we can create a hash table with size = max-min+1 where min is the minimum value in the
sumleft[] and max is the maximum value in the sumleft[]. The idea is to hash the leftmost occurrences of all
different values in sumleft[]. The size of hash is chosen as max-min+1 because there can be these many
different possible values in sumleft[]. Initialize all values in hash as -1
6) To fill and use hash[], traverse sumleft[] from 0 to n-1. If a value is not present in hash[], then store its
index in hash. If the value is present, then calculate the difference of current index of sumleft[] and
previously stored value in hash[]. If this difference is more than maxsize, then update the maxsize.
7) To handle corner cases (all 1s and all 0s), we initialize maxsize as -1. If the maxsize remains -1, then print
there is no such subarray.
// A O(n) program to find the largest subarray with equal number of 0s and 1s
#include <stdio.h>
#include <stdlib.h>

int max(int a, int b) { return a>b? a: b; }

// This function Prints the starting and ending indexes of the largest subarray
// with equal number of 0s and 1s. Also returns the size of such subarray.
int findSubArray(int arr[], int n)
{
int maxsize = -1, startindex; // variables to store result values

// Create an auxiliary array sunmleft[]. sumleft[i] will be sum of array
// elements from arr[0] to arr[i]
int sumleft[n];
int min, max; // For min and max values in sumleft[]
int i;

// Fill sumleft array and get min and max values in it.
// Consider 0 values in arr[] as -1
sumleft[0] = ((arr[0] == 0)? -1: 1);
min = arr[0]; max = arr[0];
for (i=1; i<n; i++)
{
sumleft[i] = sumleft[i-1] + ((arr[i] == 0)? -1: 1);
if (sumleft[i] < min)
min = sumleft[i];
if (sumleft[i] > max)
max = sumleft[i];
}

// Now calculate the max value of j - i such that sumleft[i] = sumleft[j].
// The idea is to create a hash table to store indexes of all visited values.
// If you see a value again, that it is a case of sumleft[i] = sumleft[j]. Check
// if this j-i is more than maxsize.
// The optimum size of hash will be max-min+1 as these many different values
// of sumleft[i] are possible. Since we use optimum size, we need to shift
// all values in sumleft[] by min before using them as an index in hash[].
int hash[max-min+1];

// Initialize hash table
for (i=0; i<max-min+1; i++)
hash[i] = -1;

for (i=0; i<n; i++)
{
// Case 1: when the subarray starts from index 0
if (sumleft[i] == 0)
{
maxsize = i+1;
startindex = 0;
}

// Case 2: fill hash table value. If already filled, then use it
if (hash[sumleft[i]-min] == -1)
hash[sumleft[i]-min] = i;
else
{
if ( (i - hash[sumleft[i]-min]) > maxsize )
{
maxsize = i - hash[sumleft[i]-min];
startindex = hash[sumleft[i]-min] + 1;
}
}
}
if ( maxsize == -1 )
printf("No such subarray");
else
printf("%d to %d", startindex, startindex+maxsize-1);

return maxsize;
}

int main()
{
int arr[] = {1, 0, 0, 1, 0, 1, 1};

findSubArray(arr, size);
return 0;
}

Output:

0 to 5


Thanks to Aashish Barnwal for suggesting this solution.
discussed above
Dynamic Programming | Set 18 (Partition problem)
Partition problem is to determine whether a given set can be partitioned into two subsets such that the sum
of elements in both subsets is same.
Examples
arr[] = {1, 5, 11, 5}

Output: true
The array can be partitioned as {1, 5, 5} and {11}
arr[] = {1, 5, 3}
Output: false
The array cannot be partitioned into equal sum sets.

Following are the two main steps to solve this problem:

1) Calculate sum of the array. If sum is odd, there can not be two subsets with equal sum, so return false.
2) If sum of array elements is even, calculate sum/2 and find a subset of array with sum equal to sum/2.
The first step is simple. The second step is crucial, it can be solved either using recursion or Dynamic
Programming.
Recursive Solution
Following is the recursive property of the second step mentioned above.
Let isSubsetSum(arr, n, sum/2) be the function that returns true if

there is a subset of arr[0..n-1] with sum equal to sum/2
The isSubsetSum problem can be divided into two subproblems

a) isSubsetSum() without considering last element
(reducing n to n-1)
b) isSubsetSum considering the last element
(reducing sum/2 by arr[n-1] and n to n-1)
If any of the above the above subproblems return true, then return true.
isSubsetSum (arr, n, sum/2) = isSubsetSum (arr, n-1, sum/2) ||
isSubsetSum (arr, n-1, sum/2 - arr[n-1])

// A recursive solution for partition problem

#include <stdio.h>
// A utility function that returns true if there is a subset of arr[]

// with sun equal to given sum
bool isSubsetSum (int arr[], int n, int sum)
{
// Base Cases
if (sum == 0)
return true;
if (n == 0 && sum != 0)
return false;
// If last element is greater than sum, then ignore it

if (arr[n-1] > sum)
return isSubsetSum (arr, n-1, sum);
/* else, check if sum can be obtained by any of the following

(a) including the last element
(b) excluding the last element
*/
return isSubsetSum (arr, n-1, sum) || isSubsetSum (arr, n-1, sum-arr[n-1]);
}
// Returns true if arr[] can be partitioned in two subsets of

// equal sum, otherwise false
bool findPartiion (int arr[], int n)
{
// Calculate sum of the elements in array
int sum = 0;
for (int i = 0; i < n; i++)
sum += arr[i];
// If sum is odd, there cannot be two subsets with equal sum

if (sum%2 != 0)
return false;
// Find if there is subset with sum equal to half of total sum

return isSubsetSum (arr, n, sum/2);
}

int main()
{
int arr[] = {3, 1, 5, 9, 12};
if (findPartiion(arr, n) == true)
printf("Can be divided into two subsets of equal sum");
else
printf("Can not be divided into two subsets of equal sum");
getchar();
return 0;
}

Output:

Can be divided into two subsets of equal sum

Time Complexity: O(2^n) In worst case, this solution tries two possibilities (whether to include or exclude)
for every element.

The problem can be solved using dynamic programming when the sum of the elements is not too big. We can
create a 2D array part[][] of size (sum/2)*(n+1). And we can construct the solution in bottom up manner
such that every filled entry has following property
part[i][j] = true if a subset of {arr[0], arr[1], ..arr[j-1]} has sum

equal to i, otherwise false

// A Dynamic Programming solution to partition problem

#include <stdio.h>
// Returns true if arr[] can be partitioned in two subsets of

// equal sum, otherwise false
bool findPartiion (int arr[], int n)
{
int sum = 0;
int i, j;

// Caculcate sun of all elements
for (i = 0; i < n; i++)
sum += arr[i];

if (sum%2 != 0)
return false;

bool part[sum/2+1][n+1];

// initialize top row as true
for (i = 0; i <= n; i++)
part[0][i] = true;

// initialize leftmost column, except part[0][0], as 0
for (i = 1; i <= sum/2; i++)
part[i][0] = false;

// Fill the partition table in botton up manner
for (i = 1; i <= sum/2; i++)
{
for (j = 1; j <= n; j++)
{
part[i][j] = part[i][j-1];
if (i >= arr[j-1])
part[i][j] = part[i][j] || part[i - arr[j-1]][j-1];
}
}

/* // uncomment this part to print table
for (i = 0; i <= sum/2; i++)
{
for (j = 0; j <= n; j++)
printf ("%4d", part[i][j]);
printf("\n");
} */

return part[sum/2][n];
}
// Driver program to test above funtion

int main()
{
int arr[] = {3, 1, 1, 2, 2, 1};
if (findPartiion(arr, n) == true)
printf("Can be divided into two subsets of equal sum");
else
printf("Can not be divided into two subsets of equal sum");
getchar();
return 0;
}

Output:

Can be divided into two subsets of equal sum

Following diagram shows the values in partition table. The diagram is taken form the wiki page of partition
problem.
Time Complexity: O(sum*n)

Auxiliary Space: O(sum*n)
Please note that this solution will not be feasible for arrays with big sum.
References:
http://en.wikipedia.org/wiki/Partition_problem
discussed above.
Construct Special Binary Tree from given Inorder traversal
Given Inorder Traversal of a Special Binary Tree in which key of every node is greater than keys in left and
right children, construct the Binary Tree and return root.
Examples:
Input: inorder[] = {5, 10, 40, 30, 28}

Output: root of following tree
40
/ \
10 30
/ \
5 28

The idea used in Construction of Tree from given Inorder and Preorder traversals can be used here. Let the
given array is {1, 5, 10, 40, 30, 15, 28, 20}. The maximum element in given array must be root. The elements
on left side of the maximum element are in left subtree and elements on right side are in right subtree.
40
/ \
{1,5,10} {30,15,28,20}

We recursively follow above step for left and right subtrees, and finally get the following tree.
40
/ \
10 30
/ \
5 28
/ / \
1 15 20

Algorithm: buildTree()
1) Find index of the maximum element in array. The maximum element must be root of Binary Tree.
2) Create a new tree node ‘root’ with the data as the maximum value found in step 1.
3) Call buildTree for elements before the maximum element and make the built tree as left subtree of ‘root’.
5) Call buildTree for elements after the maximum element and make the built tree as right subtree of ‘root’.
6) return ‘root’.
Implementation: Following is C/C++ implementation of the above algorithm.
/* program to construct tree from inorder traversal */

#include<stdio.h>
#include<stdlib.h>

struct node
{
int data;
struct node* left;
struct node* right;
};
/* Prototypes of a utility function to get the maximum

value in inorder[start..end] */
int max(int inorder[], int strt, int end);
/* A utility function to allocate memory for a node */

/* Recursive function to construct binary of size len from

Inorder traversal inorder[]. Initial values of start and end
should be 0 and len -1. */
struct node* buildTree (int inorder[], int start, int end)
{
if (start > end)
return NULL;
/* Find index of the maximum element from Binary Tree */

int i = max (inorder, start, end);
/* Pick the maximum value and make it root */

struct node *root = newNode(inorder[i]);
/* If this is the only element in inorder[start..end],

then return it */
if (start == end)
return root;
/* Using index in Inorder traversal, construct left and

right subtress */
root->left = buildTree (inorder, start, i-1);
root->right = buildTree (inorder, i+1, end);
return root;
}
/* Function to find index of the maximum value in arr[start...end] */
int max (int arr[], int strt, int end)
{
int i, max = arr[strt], maxind = strt;
for(i = strt+1; i <= end; i++)
{
if(arr[i] > max)
{
max = arr[i];
maxind = i;
}
}
return maxind;
}

{
node->data = data;
node->left = NULL;
node->right = NULL;
return node;
}
/* This funtcion is here just to test buildTree() */

{
if (node == NULL)
return;



}

int main()
{
/* Assume that inorder traversal of following tree is given
40
/ \
10 30
/ \
5 28 */
int inorder[] = {5, 10, 40, 30, 28};

int len = sizeof(inorder)/sizeof(inorder[0]);
struct node *root = buildTree(inorder, 0, len - 1);

printInorder(root);
return 0;
}

Output:
Inorder traversal of the constructed tree is

5 10 40 30 28

discussed above
Backtracking | Set 7 (Sudoku)
Given a partially filled 9×9 2D array ‘grid[9][9]’, the goal is to assign digits (from 1 to 9) to the empty cells so
that every row, column, and subgrid of size 3×3 contains exactly one instance of the digits from 1 to 9.
Naive Algorithm
The Naive Algorithm is to generate all possible configurations of numbers from 1 to 9 to fill the empty cells.
Try every configuration one by one until the correct configuration is found.
Like all other Backtracking problems, we can solve Sudoku by one by one assigning numbers to empty cells.
Before assigning a number, we check whether it is safe to assign. We basically check that the same number is
not present in current row, current column and current 3X3 subgrid. After checking for safety, we assign the
number, and recursively check whether this assignment leads to a solution or not. If the assignment doesn’t
lead to a solution, then we try next number for current empty cell. And if none of number (1 to 9) lead to
solution, we return false.
Find row, col of an unassigned cell

If there is none, return true
For digits from 1 to 9
a) If there is no conflict for digit at row,col
assign digit to row,col and recursively try fill in rest of grid
b) If recursion successful, return true
c) Else, remove digit and try another
If all digits have been tried and nothing worked, return false

Following is C++ implementation for Sudoku problem. It prints the completely filled grid as output.
// A Backtracking program in C++ to solve Sudoku problem

#include <stdio.h>
// UNASSIGNED is used for empty cells in sudoku grid

#define UNASSIGNED 0
// N is used for size of Sudoku grid. Size will be NxN

#define N 9
// This function finds an entry in grid that is still unassigned

bool FindUnassignedLocation(int grid[N][N], int &row, int &col);
// Checks whether it will be legal to assign num to the given row,col
bool isSafe(int grid[N][N], int row, int col, int num);
/* Takes a partially filled-in grid and attempts to assign values to

all unassigned locations in such a way to meet the requirements
for Sudoku solution (non-duplication across rows, columns, and boxes) */
bool SolveSudoku(int grid[N][N])
{
int row, col;
// If there is no unassigned location, we are done

if (!FindUnassignedLocation(grid, row, col))
return true; // success!
// consider digits 1 to 9
for (int num = 1; num <= 9; num++)
{
// if looks promising
if (isSafe(grid, row, col, num))
{
// make tentative assignment
grid[row][col] = num;
// return, if success, yay!

if (SolveSudoku(grid))
return true;
// failure, unmake & try again

grid[row][col] = UNASSIGNED;
}
}
return false; // this triggers backtracking
}
/* Searches the grid to find an entry that is still unassigned. If

found, the reference parameters row, col will be set the location
that is unassigned, and true is returned. If no unassigned entries
remain, false is returned. */
bool FindUnassignedLocation(int grid[N][N], int &row, int &col)
{
for (row = 0; row < N; row++)
for (col = 0; col < N; col++)
if (grid[row][col] == UNASSIGNED)
return true;
return false;
}
/* Returns a boolean which indicates whether any assigned entry

in the specified row matches the given number. */
bool UsedInRow(int grid[N][N], int row, int num)
{
for (int col = 0; col < N; col++)
if (grid[row][col] == num)
return true;
return false;
}

in the specified column matches the given number. */
bool UsedInCol(int grid[N][N], int col, int num)
{
for (int row = 0; row < N; row++)
if (grid[row][col] == num)
return true;
return true;
return false;
}

within the specified 3x3 box matches the given number. */
bool UsedInBox(int grid[N][N], int boxStartRow, int boxStartCol, int num)
{
for (int row = 0; row < 3; row++)
for (int col = 0; col < 3; col++)
if (grid[row+boxStartRow][col+boxStartCol] == num)
return true;
return false;
}
/* Returns a boolean which indicates whether it will be legal to assign

num to the given row,col location. */
bool isSafe(int grid[N][N], int row, int col, int num)
{
/* Check if 'num' is not already placed in current row,
current column and current 3x3 box */
return !UsedInRow(grid, row, num) &&
!UsedInCol(grid, col, num) &&
!UsedInBox(grid, row - row%3 , col - col%3, num);
}
/* A utility function to print grid */

void printGrid(int grid[N][N])
{
for (int row = 0; row < N; row++)
{
for (int col = 0; col < N; col++)
printf("%2d", grid[row][col]);
printf("\n");
}
}

int main()
{
// 0 means unassigned cells
int grid[N][N] = {{3, 0, 6, 5, 0, 8, 4, 0, 0},
{5, 2, 0, 0, 0, 0, 0, 0, 0},
{0, 8, 7, 0, 0, 0, 0, 3, 1},
{0, 0, 3, 0, 1, 0, 0, 8, 0},
{9, 0, 0, 8, 6, 3, 0, 0, 5},
{0, 5, 0, 0, 9, 0, 6, 0, 0},
{1, 3, 0, 0, 0, 0, 2, 5, 0},
{0, 0, 0, 0, 0, 0, 0, 7, 4},
{0, 0, 5, 2, 0, 6, 3, 0, 0}};
if (SolveSudoku(grid) == true)
printGrid(grid);
else
printf("No solution exists");
return 0;
}

Output:

3 1 6 5 7 8 4 9 2
5 2 9 1 3 4 7 6 8
4 8 7 6 2 9 5 3 1
2 6 3 4 1 5 9 8 7
9 7 4 8 6 3 1 2 5
8 5 1 7 9 2 6 4 3
1 3 8 9 4 7 2 5 6
6 9 2 3 5 1 8 7 4
7 4 5 2 8 6 3 1 9

References:
discussed above.
Question 1
#include<iostream>
#include<string.h>
class String
{
char *p;
int len;
public:
String(const char *a);
};
String::String(const char *a)

{
int length = strlen(a);
p = new char[length +1];
strcpy(p, a);
cout << "Constructor Called " << endl;
}
int main()
{
String s1("Geeks");
const char *name = "forGeeks";
s1 = name;
return 0;
}

Output:
Constructor called
Constructor called

The first line of output is printed by statement “String s1(“Geeks”);” and the second line is printed by
statement “s1 = name;”. The reason for the second call is, a single parameter constructor also works as a
conversion operator (See this and this for deatils).
Question 2

#include<iostream>
class A
{
public:
virtual void fun() {cout << "A" << endl ;}
};
class B: public A
{
public:
virtual void fun() {cout << "B" << endl;}
};
class C: public B
{
public:
virtual void fun() {cout << "C" << endl;}
};
int main()
{
A *a = new C;
A *b = new B;
a->fun();
b->fun();
return 0;
}

Output:
C
B

A base class pointer can point to objects of children classes. A base class pointer can also point to objects of
grandchildren classes. Therefor, the line “A *a = new C;” is valid. The line “a->fun();” prints “C” because the
object pointed is of class C and fun() is declared virtual in both A and B (See this for details). The second line
of output is printed by statement “b->fun();”.
Check whether a given point lies inside a triangle or not
Given three corner points of a triangle, and one more point P. Write a function to check whether P lies within
the triangle or not.
For example, consider the following program, the function should return true for P(10, 15) and false for
P'(30, 15)
B(10,30)
/ \
/ \
/ \
/ P \ P'
/ \
A(0,0) ----------- C(20,0)

Solution:
Let the coordinates of three corners be (x1, y1), (x2, y2) and (x3, y3). And coordinates of the given point P be
(x, y)
1) Calculate area of the given triangle, i.e., area of the triangle ABC in the above diagram. Area A = [ x1(y2 –
y3) + x2(y3 – y1) + x3(y1-y2)]/2
2) Calculate area of the triangle PAB. We can use the same formula for this. Let this area be A1.
3) Calculate area of the triangle PBC. Let this area be A2.
4) Calculate area of the triangle PAC. Let this area be A3.
5) If P lies inside the triangle, then A1 + A2 + A3 must be equal to A.

#include <stdio.h>
#include <stdlib.h>
/* A utility function to calculate area of triangle formed by (x1, y1),

(x2, y2) and (x3, y3) */
float area(int x1, int y1, int x2, int y2, int x3, int y3)
{
return abs((x1*(y2-y3) + x2*(y3-y1)+ x3*(y1-y2))/2.0);
}
/* A function to check whether point P(x, y) lies inside the triangle formed
by A(x1, y1), B(x2, y2) and C(x3, y3) */
bool isInside(int x1, int y1, int x2, int y2, int x3, int y3, int x, int y)
{
/* Calculate area of triangle ABC */
float A = area (x1, y1, x2, y2, x3, y3);
/* Calculate area of triangle PBC */

float A1 = area (x, y, x2, y2, x3, y3);
/* Calculate area of triangle PAC */

float A2 = area (x1, y1, x, y, x3, y3);
/* Calculate area of triangle PAB */

float A3 = area (x1, y1, x2, y2, x, y);

/* Check if sum of A1, A2 and A3 is same as A */
return (A == A1 + A2 + A3);
}

int main()
{
/* Let us check whether the point P(10, 15) lies inside the triangle
formed by A(0, 0), B(20, 0) and C(10, 30) */
if (isInside(0, 0, 20, 0, 10, 30, 10, 15))
printf ("Inside");
else
printf ("Not Inside");
return 0;
}

Ouptut:

Inside

Exercise: Given coordinates of four corners of a rectangle, and a point P. Write a function to check whether
P lies inside the given rectangle or not.
discussed above.
Count numbers that don’t contain 3
Given a number n, write a function that returns count of numbers from 1 to n that don’t contain digit 3 in
their decimal representation.
Examples:
Input: n = 10
Output: 9
Input: n = 45
Output: 31
// Numbers 3, 13, 23, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 43 contain digit 3.
Input: n = 578
Ouput: 385

Solution:
We can solve it recursively. Let count(n) be the function that counts such numbers.
'msd' --> the most significant digit in n

'd' --> number of digits in n.
count(n) = n if n 10 and msd is not 3
count(n) = count( msd * (10^(d-1)) - 1)

if n > 10 and msd is 3

Let us understand the solution with n = 578.

count(578) = 4*count(99) + 4 + count(78)
The middle term 4 is added to include numbers 100, 200, 400 and 500.
Let us take n = 35 as another example.

count(35) = count (3*10 - 1) = count(29)

#include <stdio.h>
/* returns count of numbers which are in range from 1 to n and don't contain 3
as a digit */
int count(int n)
{
// Base cases (Assuming n is not negative)
if (n < 3)
return n;
if (n >= 3 && n < 10)
return n-1;
// Calculate 10^(d-1) (10 raise to the power d-1) where d is

// number of digits in n. po will be 100 for n = 578
int po = 1;
while (n/po > 9)
po = po*10;
// find the most significant digit (msd is 5 for 578)

int msd = n/po;
if (msd != 3)
// For 578, total will be 4*count(10^2 - 1) + 4 + count(78)
return count(msd)*count(po - 1) + count(msd) + count(n%po);
else
// For 35, total will be equal to count(29)
return count(msd*po - 1);
}

int main()
{
printf ("%d ", count(578));
return 0;
}

Output:

385

discussed above
Maximum Product Subarray
Given an array that contains both positive and negative integers, find the product of the maximum product
subarray. Expected Time complexity is O(n) and only O(1) extra space can be used.
Examples:
Input: arr[] = {6, -3, -10, 0, 2}

Output: 180 // The subarray is {6, -3, -10}
Input: arr[] = {-1, -3, -10, 0, 60}

Output: 60 // The subarray is {60}
Input: arr[] = {-2, -3, 0, -2, -40}

Output: 80 // The subarray is {-2, -40}

The following solution assumes that the given input array always has a positive ouput. The solution works
for all cases mentioned above. It doesn’t work for arrays like {0, 0, -20, 0}, {0, 0, 0}.. etc. The solution can
be easily modified to handle this case.
It is similar to Largest Sum Contiguous Subarray problem. The only thing to note here is, maximum product
can also be obtained by minimum (negative) product ending with the previous element multiplied by this
element. For example, in array {12, 2, -3, -5, -6, -2}, when we are at element -2, the maximum product is
multiplication of, minimum product ending with -6 and -2.
#include <stdio.h>
// Utility functions to get minimum of two integers

int min (int x, int y) {return x < y? x : y; }
// Utility functions to get maximum of two integers

int max (int x, int y) {return x > y? x : y; }
/* Returns the product of max product subarray. Assumes that the

given array always has a subarray with product more than 1 */
int maxSubarrayProduct(int arr[], int n)
{
// max positive product ending at the current position
int max_ending_here = 1;
// min negative product ending at the current position

int min_ending_here = 1;
// Initialize overall max product

int max_so_far = 1;
/* Traverse throught the array. Following values are maintained after the ith
iteration:
max_ending_here is always 1 or some positive product ending with arr[i]
min_ending_here is always 1 or some negative product ending with arr[i] */
for (int i = 0; i < n; i++)
{
/* If this element is positive, update max_ending_here. Update
min_ending_here only if min_ending_here is negative */
if (arr[i] > 0)
{
max_ending_here = max_ending_here*arr[i];
min_ending_here = min (min_ending_here * arr[i], 1);
}
/* If this element is 0, then the maximum product cannot

end here, make both max_ending_here and min_ending_here 0
Assumption: Output is alway greater than or equal to 1. */
else if (arr[i] == 0)
{
min_ending_here = 1;
}
/* If element is negative. This is tricky

max_ending_here can either be 1 or positive. min_ending_here can either be 1
or negative.
next min_ending_here will always be prev. max_ending_here * arr[i]
next max_ending_here will be 1 if prev min_ending_here is 1, otherwise
next max_ending_here will be prev min_ending_here * arr[i] */
else
{
int temp = max_ending_here;
max_ending_here = max (min_ending_here * arr[i], 1);
min_ending_here = temp * arr[i];
}
// update max_so_far, if needed

if (max_so_far < max_ending_here)
}
return max_so_far;
}

int main()
{
int arr[] = {1, -2, -3, 0, 7, -8, -2};
printf("Maximum Sub array product is %d", maxSubarrayProduct(arr, n));
return 0;
}

Output:

Maximum Sub array product is 112


This article is compiled by Dheeraj Jain and reviewed by GeeksforGeeks team. Please write comments if
you find anything incorrect, or you want to share more information about the topic discussed above
Magic Square
A magic square of order n is an arrangement of n^2 numbers, usually distinct integers, in a square, such that
the n numbers in all rows, all columns, and both diagonals sum to the same constant. A magic square
contains the integers from 1 to n^2.
The constant sum in every row, column and diagonal is called the magic constant or magic sum, M. The
magic constant of a normal magic square depends only on n and has the following value:
M = n(n^2+1)/2
For normal magic squares of order n = 3, 4, 5, …, the magic constants are: 15, 34, 65, 111, 175, 260, …
In this post, we will discuss how programmatically we can generate a magic square of size n. Before we go
further, consider the below examples:
Magic Square of size 3

-----------------------
2 7 6
9 5 1
4 3 8
Sum in each row & each column = 3*(3^2+1)/2 = 15

----------------------
9 3 22 16 15
2 21 20 14 8
25 19 13 7 1
18 12 6 5 24
11 10 4 23 17

----------------------
20 12 4 45 37 29 28
11 3 44 36 35 27 19
2 43 42 34 26 18 10
49 41 33 25 17 9 1
40 32 24 16 8 7 48
31 23 15 14 6 47 39
22 21 13 5 46 38 30

Did you find any pattern in which the numbers are stored?
In any magic square, the first number i.e. 1 is stored at position (n/2, n-1). Let this position be (i,j). The next
number is stored at position (i-1, j+1) where we can consider each row & column as circular array i.e. they
wrap around.
Three conditions hold:
1. The position of next number is calculated by decrementing row number of previous number by 1, and
incrementing the column number of previous number by 1. At any time, if the calculated row position
becomes -1, it will wrap around to n-1. Similarly, if the calculated column position becomes n, it will wrap
around to 0.
2. If the magic square already contains a number at the calculated position, calculated column position will
be decremented by 2, and calculated row position will be incremented by 1.
3. If the calculated row position is -1 & calculated column position is n, the new position would be: (0, n-2).
Example:
----------------------
2 7 6
9 5 1
4 3 8
Steps:
1. position of number 1 = (3/2, 3-1) = (1, 2)
2. position of number 2 = (1-1, 2+1) = (0, 0)
3. position of number 3 = (0-1, 0+1) = (3-1, 1) = (2, 1)
4. position of number 4 = (2-1, 1+1) = (1, 2)
Since, at this position, 1 is there. So, apply condition 2.
new position=(1+1,2-2)=(2,0)
5. position of number 5=(2-1,0+1)=(1,1)
6. position of number 6=(1-1,1+1)=(0,2)
7. position of number 7 = (0-1, 2+1) = (-1,3) // this is tricky, see condition 3
new position = (0, 3-2) = (0,1)
8. position of number 8=(0-1,1+1)=(-1,2)=(2,2) //wrap around
9. position of number 9=(2-1,2+1)=(1,3)=(1,0) //wrap around

Based on the above approach, following is the working code:
#include<stdio.h>
#include<string.h>
// A function to generate odd sized magic squares

void generateSquare(int n)
{
int magicSquare[n][n];
// set all slots as 0

memset(magicSquare, 0, sizeof(magicSquare));
// Initialize position for 1

int i = n/2;
int j = n-1;
// One by one put all values in magic square

for (int num=1; num <= n*n; )
{
if (i==-1 && j==n) //3rd condition
{
j = n-2;
i = 0;
}
else
{
//1st condition helper if next number goes to out of square's right side
if (j == n)
j = 0;
//1st condition helper if next number is goes to out of square's upper side
if (i < 0)
i=n-1;
}
if (magicSquare[i][j]) //2nd condition
{
j -= 2;
i++;
continue;
}
else
magicSquare[i][j] = num++; //set number
j++; i--; //1st condition

}
// print magic square

printf("The Magic Square for n=%d:\nSum of each row or column %d:\n\n",
n, n*(n*n+1)/2);
for(i=0; i<n; i++)
{
for(j=0; j<n; j++)
printf("%3d ", magicSquare[i][j]);
printf("\n");
}
}

int main()
{
int n = 7; // Works only when n is odd
generateSquare (n);
return 0;
}

Output:
The Magic Square for n=7:

Sum of each row or column 175:
20 12 4 45 37 29 28
11 3 44 36 35 27 19
2 43 42 34 26 18 10
49 41 33 25 17 9 1
40 32 24 16 8 7 48
31 23 15 14 6 47 39
22 21 13 5 46 38 30

NOTE: This approach works only for odd values of n.
References:
http://en.wikipedia.org/wiki/Magic_square
This article is compiled by Aashish Barnwal and reviewed by GeeksforGeeks team. Please write comments
if you find anything incorrect, or you want to share more information about the topic discussed above
Find a pair with the given difference
Given an unsorted array and a number n, find if there exists a pair of elements in the array whose difference
is n.
Examples:
Input: arr[] = {5, 20, 3, 2, 50, 80}, n = 78
Output: Pair Found: (2, 80)
Input: arr[] = {90, 70, 20, 80, 50}, n = 45

Output: No Such Pair

Source: find pair
The simplest method is to run two loops, the outer loop picks the first element (smaller element) and the
inner loop looks for the element picked by outer loop plus n. Time complexity of this method is O(n^2).
We can use sorting and Binary Search to improve time complexity to O(nLogn). The first step is to sort the
array in ascending order. Once the array is sorted, traverse the array from left to right, and for each element
arr[i], binary search for arr[i] + n in arr[i+1..n-1]. If the element is found, return the pair.
Both first and second steps take O(nLogn). So overall complexity is O(nLogn).
The second step of the above algorithm can be improved to O(n). The first step remain same. The idea for
second step is take two index variables i and j, initialize them as 0 and 1 respectively. Now run a linear loop.
If arr[j] – arr[i] is smaller than n, we need to look for greater arr[j], so increment j. If arr[j] – arr[i] is greater
than n, we need to look for greater arr[i], so increment i. Thanks to Aashish Barnwal for suggesting this
approach.
The following code is only for the second step of the algorithm, it assumes that the array is already sorted.

#include <stdio.h>
// The function assumes that the array is sorted

bool findPair(int arr[], int size, int n)
{
// Initialize positions of two elements
int i = 0;
int j = 1;
// Search for a pair

while (i<size && j<size)
{
if (i != j && arr[j]-arr[i] == n)
{
printf("Pair Found: (%d, %d)", arr[i], arr[j]);
return true;
}
else if (arr[j]-arr[i] < n)
j++;
else
i++;
}
printf("No such pair");

return false;
}

int main()
{
int arr[] = {1, 8, 30, 40, 100};
int n = 60;
findPair(arr, size, n);
return 0;
}

Output:

Pair Found: (40, 100)

Hashing can also be used to solve this problem. Create an empty hash table HT. Traverse the array, use array
elements as hash keys and enter them in HT. Traverse the array again look for value n + arr[i] in HT.
the same problem.
Sieve of Eratosthenes
Given a number n, print all primes smaller than or equal to n. It is also given that n is a small number.
For example, if n is 10, the output should be “2, 3, 5, 7″. If n is 20, the output should be “2, 3, 5, 7, 11, 13, 17,
19″.
The sieve of Eratosthenes is one of the most efficient ways to find all primes smaller than n when n is
smaller than 10 million or so (Ref Wiki).
Following is the algorithm to find all the prime numbers less than or equal to a given integer
n by
Eratosthenes’ method:
1. Create a list of consecutive integers from 2 to n: (2, 3, 4, …, n).

2. Initially, let p equal 2, the first prime number.
3. Starting from p, count up in increments of p and mark each of these numbers greater than p itself in
the list. These numbers will be 2p, 3p, 4p, etc.; note that some of them may have already been marked.
4. Find the first number greater than p in the list that is not marked. If there was no such number, stop.
Otherwise, let p now equal this number (which is the next prime), and repeat from step 3.
When the algorithm terminates, all the numbers in the list that are not marked are prime.
Following is C++ implementation of the above algorithm. In the following implementation, a boolean array
arr[] of size n is used to mark multiples of prime numbers.

#include <stdio.h>
#include <string.h>
// marks all mutiples of 'a' ( greater than 'a' but less than equal to 'n') as 1.
void markMultiples(bool arr[], int a, int n)
{
int i = 2, num;
while ( (num = i*a) <= n )
{
arr[ num-1 ] = 1; // minus 1 because index starts from 0.
++i;
}
}
// A function to print all prime numbers smaller than n

void SieveOfEratosthenes(int n)
{
// There are no prime numbers smaller than 2
if (n >= 2)
{
// Create an array of size n and initialize all elements as 0
bool arr[n];
memset(arr, 0, sizeof(arr));
/* Following property is maintained in the below for loop

arr[i] == 0 means i + 1 is prime
arr[i] == 1 means i + 1 is not prime */
for (int i=1; i<n; ++i)
{
if ( arr[i] == 0 )
{
//(i+1) is prime, print it and mark its multiples
printf("%d ", i+1);
markMultiples(arr, i+1, n);
}
}
}
}

int main()
{
int n = 30;
printf("Following are the prime numbers below %d\n", n);
SieveOfEratosthenes(n);
return 0;
}

Output:

Following are the prime numbers below 30
2 3 5 7 11 13 17 19 23 29

References:
http://en.wikipedia.org/wiki/Sieve_of_Eratosthenes
This article is compiled by Abhinav Priyadarshi and reviewed by GeeksforGeeks team. Please write
above
Construct a special tree from given preorder traversal
Given an array ‘pre[]’ that represents Preorder traversal of a spacial binary tree where every node has either
0 or 2 children. One more array ‘preLN[]’ is given which has only two possible values ‘L’ and ‘N’. The value
‘L’ in ‘preLN[]’ indicates that the corresponding node in Binary Tree is a leaf node and value ‘N’ indicates
that the corresponding node is non-leaf node. Write a function to construct the tree from the given two
arrays.
Example:
Input: pre[] = {10, 30, 20, 5, 15}, preLN[] = {'N', 'N', 'L', 'L', 'L'}
Output: Root of following tree
10
/ \
30 15
/ \
20 5

The first element in pre[] will always be root. So we can easily figure out root. If left subtree is empty, the
right subtree must also be empty and preLN[] entry for root must be ‘L’. We can simply create a node and
return it. If left and right subtrees are not empty, then recursively call for left and right subtrees and link the
returned nodes to root.
/* A program to construct Binary Tree from preorder traversal */

#include<stdio.h>
/* A binary tree node structure */

struct node
{
int data;
struct node *left;
struct node *right;
};

{
temp->data = data;
temp->left = NULL;
temp->right = NULL;
return temp;
}
/* A recursive function to create a Binary Tree from given pre[]

preLN[] arrays. The function returns root of tree. index_ptr is used
to update index values in recursive calls. index must be initially
passed as 0 */
struct node *constructTreeUtil(int pre[], char preLN[], int *index_ptr, int n)
{
int index = *index_ptr; // store the current value of index in pre[]
// Base Case: All nodes are constructed

if (index == n)
if (index == n)
return NULL;
// Allocate memory for this node and increment index for

// subsequent recursive calls
struct node *temp = newNode ( pre[index] );
(*index_ptr)++;
// If this is an internal node, construct left and right subtrees and link the
subtrees
if (preLN[index] == 'N')
{
temp->left = constructTreeUtil(pre, preLN, index_ptr, n);
temp->right = constructTreeUtil(pre, preLN, index_ptr, n);
}
return temp;
}
// A wrapper over constructTreeUtil()

struct node *constructTree(int pre[], char preLN[], int n)
{
// Initialize index as 0. Value of index is used in recursion to maintain
// the current index in pre[] and preLN[] arrays.
int index = 0;
return constructTreeUtil (pre, preLN, &index, n);

}
/* This function is used only for testing */

{
if (node == NULL)
return;



}

int main()
{
/* Constructing tree given in the above figure

10
/ \
30 15
/ \
20 5 */
int pre[] = {10, 30, 20, 5, 15};
char preLN[] = {'N', 'N', 'L', 'L', 'L'};
int n = sizeof(pre)/sizeof(pre[0]);
// construct the above tree

root = constructTree (pre, preLN, n);
// Test the constructed tree
printf("Following is Inorder Traversal of the Constructed Binary Tree: \n");
printInorder (root);
return 0;
}

Output:

Following is Inorder Traversal of the Constructed Binary Tree:
20 30 5 10 15

discussed above
Find day of the week for a given date
Write a function that calculates the day of the week for any particular date in the past or future. A typical
application is to calculate the day of the week on which someone was born or some other special event
occurred.
Following is a simple C function suggested by Sakamoto, Lachman, Keith and Craver to calculate day. The
following function returns 0 for Sunday, 1 for Monday, etc.
/* A program to find day of a given date */

#include<stdio.h>
int dayofweek(int d, int m, int y)

{
static int t[] = { 0, 3, 2, 5, 0, 3, 5, 1, 4, 6, 2, 4 };
y -= m < 3;
return ( y + y/4 - y/100 + y/400 + t[m-1] + d) % 7;
}
/* Driver function to test above function */

int main()
{
int day = dayofweek(30, 8, 2010);
printf ("%d", day);
return 0;
}

Output: 1 (Monday)
See this for explanation of the above function.
References:
http://en.wikipedia.org/wiki/Determination_of_the_day_of_the_week
This article is compiled by Dheeraj Jain and reviewed by GeeksforGeeks team. Please write comments if
DFA based division
Deterministic Finite Automaton (DFA) can be used to check whether a number “num” is divisible by “k” or
not. If the number is not divisible, remainder can also be obtained using DFA.
We consider the binary representation of ‘num’ and build a DFA with k states. The DFA has transition
function for both 0 and 1. Once the DFA is built, we process ‘num’ over the DFA to get remainder.
Let us walk through an example. Suppose we want to check whether a given number ‘num’ is divisible by 3 or
not. Any number can be written in the form: num = 3*a + b where ‘a’ is the quotient and ‘b’ is the remainder.
For 3, there can be 3 states in DFA, each corresponding to remainder 0, 1 and 2. And each state can have two
transitions corresponding 0 and 1 (considering the binary representation of given ‘num’).
The transition function F(p, x) = q tells that on reading alphabet x, we move from state p to state q. Let us
name the states as 0, 1 and 2. The initial state will always be 0. The final state indicates the remainder. If the
final state is 0, the number is divisible.
In the above diagram, double circled state is final state.
1. When we are at state 0 and read 0, we remain at state 0.

2. When we are at state 0 and read 1, we move to state 1, why? The number so formed(1) in decimal gives
remainder 1.
remainder 2.
remainder 0.
remainder 1.
6. When we are at state 2 and read 1, we remain at state 2, why? The number so formed(101) in decimal gves
remainder 2.
The transition table looks like following:
state 0 1
_____________
0 0 1
1 2 0
2 1 2

Let us check whether 6 is divisible by 3?

Binary representation of 6 is 110
state = 0
1. state=0, we read 1, new state=1
Since the final state is 0, the number is divisible by 3.
Let us take another example number as 4
state=0
Since, the final state is not 0, the number is not divisible by 3. The remainder is 1.
Note that the final state gives the remainder.
We can extend the above solution for any value of k. For a value k, the states would be 0, 1, …. , k-1. How to
calculate the transition if the decimal equivalent of the binary bits seen so far, crosses the range k? If we are
at state p, we have read p (in decimal). Now we read 0, new read number becomes 2*p. If we read 1, new
read number becomes 2*p+1. The new state can be obtained by subtracting k from these values (2p or 2p+1)
where 0 #include <stdio.h> #include <stdlib.h> // Function to build DFA for divisor k void preprocess(int
k, int Table[][2]) { int trans0, trans1; // The following loop calculates the two transitions for each state, //
starting from state 0 for (int state=0; state<k; ++state) { // Calculate next state for bit 0 trans0 = state<<1;
Table[state][0] = (trans0 < k)? trans0: trans0-k; // Calculate next state for bit 1 trans1 = (state<<1) + 1;
Table[state][1] = (trans1 < k)? trans1: trans1-k; } } // A recursive utility function that takes a ‘num’ and DFA
(transition // table) as input and process ‘num’ bit by bit over DFA void isDivisibleUtil(int num, int* state,
int Table[][2]) { // process "num" bit by bit from MSB to LSB if (num != 0) { isDivisibleUtil(num>>1, state,
Table); *state = Table[*state][num&1]; } } // The main function that divides ‘num’ by k and returns the
remainder int isDivisible (int num, int k) { // Allocate memory for transition table. The table will have k*2
entries int (*Table)[2] = (int (*)[2])malloc(k*sizeof(*Table)); // Fill the transition table preprocess(k, Table);
// Process ‘num’ over DFA and get the remainder int state = 0; isDivisibleUtil(num, &state, Table); // Note
that the final value of state is the remainder return state; } // Driver program to test above functions int
main() { int num = 47; // Number to be divided int k = 5; // Divisor int remainder = isDivisible (num, k); if
(remainder == 0) printf("Divisible\n"); else printf("Not Divisible: Remainder is %d\n", remainder); return
0; }
Output:

Not Divisible: Remainder is 2

DFA based division can be useful if we have a binary stream as input and we want to check for divisibility of
the decimal value of stream at any time.
Find a triplet from three linked lists with sum equal to a given number
Given three linked lists, say a, b and c, find one node from each list such that the sum of the values of the
nodes is equal to a given number.
For example, if the three linked lists are 12->6->29, 23->5->8 and 90->20->59, and the given number is
101, the output should be tripel “6 5 90″.
In the following solutions, size of all three linked lists is assumed same for simplicity of analysis. The
following solutions work for linked lists of different sizes also.
A simple method to solve this problem is to run three nested loops. The outermost loop picks an element
from list a, the middle loop picks an element from b and the innermost loop picks from c. The innermost
loop also checks whether the sum of values of current nodes of a, b and c is equal to given number. The time
complexity of this method will be O(n^3).
Sorting can be used to reduce the time complexity to O(n*n). Following are the detailed steps.
1) Sort list b in ascending order, and list c in descending order.
2) After the b and c are sorted, one by one pick an element from list a and find the pair by traversing both b
and c. See isSumSorted() in the following code. The idea is similar to Quadratic algorithm of 3 sum problem.
Following code implements step 2 only. The solution can be easily modified for unsorted lists by adding the
merge sort code discussed here.
#include<stdio.h>
#include<stdlib.h>

struct node
{
int data;
struct node* next;
};

{
/* allocate node */



}
/* A function to chech if there are three elements in a, b and c whose sum

is equal to givenNumber. The function assumes that the list b is sorted
in ascending order and c is sorted in descending order. */
bool isSumSorted(struct node *headA, struct node *headB,
struct node *headC, int givenNumber)
{
struct node *a = headA;
// Traverse through all nodes of a

// Traverse through all nodes of a
while (a != NULL)
{
struct node *b = headB;
struct node *c = headC;
// For every node of list a, prick two nodes from lists b abd c
while (b != NULL && c != NULL)
{
// If this a triplet with given sum, print it and return true
int sum = a->data + b->data + c->data;
if (sum == givenNumber)
{
printf ("Triplet Found: %d %d %d ", a->data, b->data, c->data);
return true;
}
// If sum of this triplet is smaller, look for greater values in b

else if (sum < givenNumber)
b = b->next;
else // If sum is greater, look for smaller values in c
c = c->next;
}
a = a->next; // Move ahead in list a
}
printf ("No such triplet");

return false;
}

int main()
{
struct node* headA = NULL;
struct node* headB = NULL;
struct node* headC = NULL;
/*create a linked list 'a' 10->15->5->20 */

push (&headA, 20);
push (&headA, 4);
push (&headA, 15);
push (&headA, 10);
/*create a sorted linked list 'b' 2->4->9->10 */

push (&headB, 10);
push (&headB, 9);
push (&headB, 4);
push (&headB, 2);
/*create another sorted linked list 'c' 8->4->2->1 */

push (&headC, 1);
push (&headC, 2);
push (&headC, 4);
push (&headC, 8);
int givenNumber = 25;
isSumSorted (headA, headB, headC, givenNumber);
return 0;
}

Output:

Triplet Found: 15 2 8

Time complexity: The linked lists b and c can be sorted in O(nLogn) time using Merge Sort (See this). The
step 2 takes O(n*n) time. So the overall time complexity is O(nlogn) + O(nlogn) + O(n*n) = O(n*n).
In this approach, the linked lists b and c are sorted first, so their original order will be lost. If we want to
retain the original order of b and c, we can create copy of b and c.
This article is compiled by Abhinav Priyadarshi and reviewed by GeeksforGeeks team. Please write
above
Check if each internal node of a BST has exactly one child
Given Preorder traversal of a BST, check if each non-leaf node has only one child. Assume that the BST
contains unique entries.
Examples
Input: pre[] = {20, 10, 11, 13, 12}

Output: Yes
The give array represents following BST. In the following BST, every internal
node has exactly 1 child. Therefor, the output is true.
20
/
10
\
11
\
13
/
12

In Preorder traversal, descendants (or Preorder successors) of every node appear after the node. In the
above example, 20 is the first node in preorder and all descendants of 20 appear after it. All descendants of
20 are smaller than it. For 10, all descendants are greater than it. In general, we can say, if all internal nodes
have only one child in a BST, then all the descendants of every node are either smaller or larger than the
node. The reason is simple, since the tree is BST and every node has only one child, all descendants of a node
will either be on left side or right side, means all descendants will either be smaller or greater.
Approach 1 (Naive)
This approach simply follows the above idea that all values on right side are either smaller or larger. Use two
loops, the outer loop picks an element one by one, starting from the leftmost element. The inner loop checks
if all elements on the right side of the picked element are either smaller or greater. The time complexity of
this method will be O(n^2).
Approach 2
Since all the descendants of a node must either be larger or smaller than the node. We can do following for
every node in a loop.
1. Find the next preorder successor (or descendant) of the node.
2. Find the last preorder successor (last element in pre[]) of the node.
3. If both successors are less than the current node, or both successors are greater than the current node,
then continue. Else, return false.

#include <stdio.h>
bool hasOnlyOneChild(int pre[], int size)

{
int nextDiff, lastDiff;
for (int i=0; i<size-1; i++)

{
nextDiff = pre[i] - pre[i+1];
lastDiff = pre[i] - pre[size-1];
if (nextDiff*lastDiff < 0)
return false;;
}
return true;
}

int main()
{
int pre[] = {8, 3, 5, 7, 6};
int size = sizeof(pre)/sizeof(pre[0]);
if (hasOnlyOneChild(pre, size) == true )
printf("Yes");
else
printf("No");
return 0;
}

Output:

Yes

Approach 3
1. Scan the last two nodes of preorder & mark them as min & max.
2. Scan every node down the preorder array. Each node must be either smaller than the min node or larger
than the max node. Update min & max accordingly.

#include <stdio.h>
int hasOnlyOneChild(int pre[], int size)

{
// Initialize min and max using last two elements
int min, max;
if (pre[size-1] > pre[size-2])
{
max = pre[size-1];
min = pre[size-2]):
else
{
max = pre[size-2];
min = pre[size-1];
}
// Every element must be either smaller than min or

// greater than max
for (int i=size-3; i>=0; i--)
{
if (pre[i] < min)
min = pre[i];
else if (pre[i] > max)
max = pre[i];
else
return false;
}
return true;
}

int main()
{
int pre[] = {8, 3, 5, 7, 6};
int size = sizeof(pre)/sizeof(pre[0]);
if (hasOnlyOneChild(pre,size))
printf("Yes");
else
printf("No");
return 0;
}

Output:

Yes

discussed above
Generate integer from 1 to 7 with equal probability
Given a function foo() that returns integers from 1 to 5 with equal probability, write a function that returns
integers from 1 to 7 with equal probability using foo() only. Minimize the number of calls to foo() method.
Also, use of any other library function is not allowed and no floating point arithmetic allowed.
Solution:
We know foo() returns integers from 1 to 5. How we can ensure that integers from 1 to 7 occur with equal
probability?
If we somehow generate integers from 1 to a-multiple-of-7 (like 7, 14, 21, …) with equal probability, we can
use modulo division by 7 followed by adding 1 to get the numbers from 1 to 7 with equal probability.
We can generate from 1 to 21 with equal probability using the following expression.

5*foo() + foo() -5

Let us see how above expression can be used.

1. For each value of first foo(), there can be 5 possible combinations for values of second foo(). So, there are
total 25 combinations possible.
2. The range of values returned by the above equation is 1 to 25, each integer occurring exactly once.
3. If the value of the equation comes out to be less than 22, return modulo division by 7 followed by adding 1.
Else, again call the method recursively. The probability of returning each integer thus becomes 1/7.
The below program shows that the expression returns each integer from 1 to 25 exactly once.
#include <stdio.h>
int main()
{
int first, second;
for ( first=1; first<=5; ++first )
for ( second=1; second<=5; ++second )
printf ("%d \n", 5*first + second - 5);
return 0;
}

Output:

1
2
.
.
24
25

The below program depicts how we can use foo() to return 1 to 7 with equal probability.

#include <stdio.h>
int foo() // given method that returns 1 to 5 with equal probability

{
// some code here
}
int my_rand() // returns 1 to 7 with equal probability

{
int i;
i = 5*foo() + foo() - 5;
if (i < 22)
return i%7 + 1;
return my_rand();
}
int main()
{
printf ("%d ", my_rand());
return 0;
}

Question 1
#include<iostream>
class Point
{
private:
int x;
int y;
public:
Point(const Point&p) { x = p.x; y = p.y; }
void setX(int i) {x = i;}
void setY(int j) {y = j;}
int getX() {return x;}
int getY() {return y;}
void print() { cout << "x = " << getX() << ", y = " << getY(); }
};
int main()
{
Point p1;
p1.setX(10);
p1.setY(20);
Point p2 = p1;
p2.print();
return 0;
}

Output: Compiler Error in first line of main(), i.e., “Point p1;”
Since there is a user defined constructor, compiler doesn’t create the default constructor (See this GFact). If
we remove the copy constructor from class Point, the program works fine and prints the output as “x = 10, y
= 20″
Question 2
#include<iostream>
int main()
{
int *ptr = new int(5);
cout << *ptr;
return 0;
}

Output: 5
The new operator can also initialize primitive data types. In the above program, the value at address ‘ptr ‘ is
initialized as 5 using the new operator.
Question 3
#include <iostream>
class Fraction
{
private:
int den;
int num;
public:
void print() { cout << num << "/" << den; }
Fraction() { num = 1; den = 1; }
int &Den() { return den; }
int &Num() { return num; }
};
int main()
{
Fraction f1;
f1.Num() = 7;
f1.Den() = 9;
f1.print();
return 0;
}

Output: 7/9
The methods Num() and Den() return references to num and den respectively. Since references are
returned, the returned values can be uses as an lvalue, and the private members den and num are modified.
The program compiles and runs fine, but this kind of class design is strongly discouraged (See this).
Returning reference to private variable allows users of the class to change private data directly which defeats
the purpose of encapsulation.
Question 1
#include <iostream>
int fun(int a, int b = 1, int c =2)

{
return (a + b + c);
}
int main()
{
cout << fun(12, ,2);
return 0;
}

Output: Compiler Error in function call fun(12, ,2)

With default arguments, we cannot skip an argument in the middle. Once an argument is skipped, all the
following arguments must be skipped. The calls fun(12) and fun(12, 2) are valid.
Question 2
#include<iostream>
/* local variable is same as a member's name */

class Test
{
private:
int x;
public:
void setX (int x) { Test::x = x; }
void print() { cout << "x = " << x << endl; }
};
int main()
{
Test obj;
int x = 40;
obj.setX(x);
obj.print();
return 0;
}

Output:

x = 40

Scope resolution operator can always be used to access a class member when it is made hidden by local
variables. So the line “Test::x = x” is same as “this->x = x”
Question 3
#include<iostream>
class Test
{
private:
int x;
static int count;
public:
Test(int i = 0) : x(i) {}
Test(const Test& rhs) : x(rhs.x) { ++count; }
static int getCount() { return count; }
};
Test fun()
{
return Test();
}
int main()
{
Test a = fun();
cout<< Test::getCount();
return 0;
}

Output: Compiler Dependent

The line “Test a = fun()” may or may not call copy constructor. So output may be 0 or 1. If copy elision
happens in your compiler, the copy constructor will not be called. If copy elision doesn’t happen, copy
constructor will be called. The gcc compiler produced the output as 0.
Dynamic Programming | Set 19 (Word Wrap Problem)
Given a sequence of words, and a limit on the number of characters that can be put in one line (line width).
Put line breaks in the given sequence such that the lines are printed neatly. Assume that the length of each
word is smaller than the line width.
The word processors like MS Word do task of placing line breaks. The idea is to have balanced lines. In other
words, not have few lines with lots of extra spaces and some lines with small amount of extra spaces.
The extra spaces includes spaces put at the end of every line except the last one.
The problem is to minimize the following total cost.
Cost of a line = (Number of extra spaces in the line)^3
Total Cost = Sum of costs for all lines
For example, consider the following string and line width M = 15

"Geeks for Geeks presents word wrap problem"

Following is the optimized arrangement of words in 3 lines
Geeks for Geeks
presents word
wrap problem
The total extra spaces in line 1, line 2 and line 3 are 0, 2 and 3 respectively.
So optimal value of total cost is 0 + 2*2 + 3*3 = 13

Please note that the total cost function is not sum of extra spaces, but sum of cubes (or square is also used) of
extra spaces. The idea behind this cost function is to balance the spaces among lines. For example, consider
the following two arrangement of same set of words:
1) There are 3 lines. One line has 3 extra spaces and all other lines have 0 extra spaces. Total extra spaces = 3
+ 0 + 0 = 3. Total cost = 3*3*3 + 0*0*0 + 0*0*0 = 27.
2) There are 3 lines. Each of the 3 lines has one extra space. Total extra spaces = 1 + 1 + 1 = 3. Total cost =
1*1*1 + 1*1*1 + 1*1*1 = 3.
Total extra spaces are 3 in both scenarios, but second arrangement should be preferred because extra spaces
are balanced in all three lines. The cost function with cubic sum serves the purpose because the value of total
cost in second scenario is less.
Method 1 (Greedy Solution)

The greedy solution is to place as many words as possible in the first line. Then do the same thing for the
second line and so on until all words are placed. This solution gives optimal solution for many cases, but
doesn’t give optimal solution in all cases. For example, consider the following string “aaa bb cc ddddd” and
line width as 6. Greedy method will produce following output.
aaa bb
cc
ddddd

Extra spaces in the above 3 lines are 0, 4 and 1 respectively. So total cost is 0 + 64 + 1 = 65.
But the above solution is not the best solution. Following arrangement has more balanced spaces. Therefore
less value of total cost function.
aaa
bb cc
ddddd

Extra spaces in the above 3 lines are 3, 1 and 1 respectively. So total cost is 27 + 1 + 1 = 29.
Despite being sub-optimal in some cases, the greedy approach is used by many word processors like MS
Word and OpenOffice.org Writer.

The following Dynamic approach strictly follows the algorithm given in solution of Cormen book. First we
compute costs of all possible lines in a 2D table lc[][]. The value lc[i][j] indicates the cost to put words from i
to j in a single line where i and j are indexes of words in the input sequences. If a sequence of words from i to
j cannot fit in a single line, then lc[i][j] is considered infinite (to avoid it from being a part of the solution).
Once we have the lc[][] table constructed, we can calculate total cost using following recursive formula. In
the following formula, C[j] is the optimized total cost for arranging words from 1 to j.
The above recursion has overlapping subproblem property. For example, the solution of subproblem c(2) is
used by c(3), C(4) and so on. So Dynamic Programming is used to store the results of subproblems. The
array c[] can be computed from left to right, since each value depends only on earlier values.
To print the output, we keep track of what words go on what lines, we can keep a parallel p array that points
to where each c value came from. The last line starts at word p[n] and goes through word n. The previous
line starts at word p[p[n]] and goes through word p[n] – 1, etc. The function printSolution() uses p[] to print
the solution.
In the below program, input is an array l[] that represents lengths of words in a sequence. The value l[i]
indicates length of the ith word (i starts from 1) in theinput sequence.
// A Dynamic programming solution for Word Wrap Problem

#include <limits.h>
#include <stdio.h>
#define INF INT_MAX
// A utility function to print the solution

int printSolution (int p[], int n);
// l[] represents lengths of different words in input sequence. For example,

// l[] = {3, 2, 2, 5} is for a sentence like "aaa bb cc ddddd". n is size of
// l[] and M is line width (maximum no. of characters that can fit in a line)
void solveWordWrap (int l[], int n, int M)
{
// For simplicity, 1 extra space is used in all below arrays
// extras[i][j] will have number of extra spaces if words from i

// to j are put in a single line
int extras[n+1][n+1];
// lc[i][j] will have cost of a line which has words from

// lc[i][j] will have cost of a line which has words from
// i to j
int lc[n+1][n+1];

// c[i] will have total cost of optimal arrangement of words
// from 1 to i
int c[n+1];
// p[] is used to print the solution.

int p[n+1];
int i, j;
// calculate extra spaces in a single line. The value extra[i][j]

// indicates extra spaces if words from word number i to j are
// placed in a single line
for (i = 1; i <= n; i++)
{
extras[i][i] = M - l[i-1];
for (j = i+1; j <= n; j++)
extras[i][j] = extras[i][j-1] - l[j-1] - 1;
}
// Calculate line cost corresponding to the above calculated extra

// spaces. The value lc[i][j] indicates cost of putting words from
// word number i to j in a single line
for (i = 1; i <= n; i++)
{
for (j = i; j <= n; j++)
{
if (extras[i][j] < 0)
lc[i][j] = INF;
else if (j == n && extras[i][j] >= 0)
lc[i][j] = 0;
else
lc[i][j] = extras[i][j]*extras[i][j];
}
}
// Calculate minimum cost and find minimum cost arrangement.

// The value c[j] indicates optimized cost to arrange words
// from word number 1 to j.
c[0] = 0;
for (j = 1; j <= n; j++)
{
c[j] = INF;
for (i = 1; i <= j; i++)
{
if (c[i-1] != INF && lc[i][j] != INF && (c[i-1] + lc[i][j] < c[j]))
{
c[j] = c[i-1] + lc[i][j];
p[j] = i;
}
}
}
printSolution(p, n);
}
int printSolution (int p[], int n)

{
int k;
if (p[n] == 1)
k = 1;
else
k = printSolution (p, p[n]-1) + 1;
printf ("Line number %d: From word no. %d to %d \n", k, p[n], n);
return k;
}

int main()
{
int l[] = {3, 2, 2, 5};
int n = sizeof(l)/sizeof(l[0]);
int M = 6;
solveWordWrap (l, n, M);
return 0;
}

Output:

Line number 1: From word no. 1 to 1


Auxiliary Space: O(n^2) The auxiliary space used in the above program cane be optimized to O(n) (See the
reference 2 for details)
References:
http://en.wikipedia.org/wiki/Word_wrap
discussed above.
Question 1
#include <stdio.h>
int main(void)
{
int i;
int power_of_ten[5] = {
00001,
00010,
00100,
01000,
10000,
};

for (i = 0; i < 5; ++i)
printf("%d ", power_of_ten[i]);
printf("\n");

return 0;
}

In the above example, we have created an array of 5 elements, whose elements are power of ten (i.e. 1, 10,
100, 1000 and 10,000) and we are printing these element by using a simple for loop. So we are expecting
output of above program is ” 1 10 100 1000 and 10000″, but above program doesn’t show this output,
instead it shows

"1 8 64 512 10000"

Let us discuss above program in more detail. Inside array we declared elements which starts with “0”, and
this is octal representation of decimal number (See this GFact for details).
That’s why all these numbers are in octal representation. “010” is octal representation of decimal “8”, “0100”
is octal representation of decimal “64” and so on.
Last element “10000” which doesn’t start with “0”, that’s why it is in decimal format and it is printed as it is.
Question 2

#include <stdio.h>
int main(void)
{
http://geeksforgeeks.org
printf("Hello, World !!!\n");
return 0;
}

At first sight, it looks like that the above program will give compilation error, but it will work fine (but will
give compilation warning). Observe the above program carefully, in this program “http:” will be treated as
goto label and two forward slashes will act as single line comment. That’s why program will work work
correctly.
Question 3

#include <stdio.h>
#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof(arr[0]))
int main(void)
{
int i;
int arr[] = {1, 2, 3, 4, 5};
for (i = -1; i < ARRAY_SIZE(arr) - 1; ++i)

printf("%d ", arr[i + 1]);
printf("\n");
return 0;
}

In above program, “ARRAY_SIZE” macro substitutes the expression to get the total number of elements
present in array, and we are printing these element by using a for loop. But program doesn’t print anything.
Let us see what is wrong with code.
Value returned by the substituted expression is in “unsigned int” format, and inside for loop we are
comparing unsigned 5 with signed -1. In this comparison -1 is promoted to unsigned integer. -1 in unsigned
format is represented as all it’s bit are set to 1 (i.e. 0xffffffff), which is too big number
After substituting value of macro, for loop look like this.

for (i = -1; 0xffffffff
In above loop indeed 0xffffffff is not less than 5, that's why for loop condition fails,
and program exits from loop without printing anything.
This article is compiled by Narendra Kangralkar. Please write comments if you find anyth
ing incorrect, or you want to share more information about the topic discussed above.

Rotate a Linked List
Given a singly linked list, rotate the linked list counter-clockwise by k nodes. Where k is a given positive
integer. For example, if the given linked list is 10->20->30->40->50->60 and k is 4, the list should be
modified to 50->60->10->20->30->40. Assume that k is smaller than the count of nodes in linked list.
To rotate the linked list, we need to change next of kth node to NULL, next of last node to previous head
node, and finally change head to (k+1)th node. So we need to get hold of three nodes: kth node, (k+1)th node
and last node.
Traverse the list from beginning and stop at kth node. Store pointer to kth node. We can get (k+1)th node
using kthNode->next. Keep traversing till end and store pointer to last node also. Finally, change pointers as
stated above.
// Program to rotate a linked list counter clock wise

#include<stdio.h>
#include<stdlib.h>

struct node
{
int data;
struct node* next;
};
// This function rotates a linked list counter-clockwise and updates the head.
// The function assumes that k is smaller than size of linked list. It doesn't
// modify the list if k is greater than or equal to size
void rotate (struct node **head_ref, int k)
{
if (k == 0)
return;
// Let us understand the below code for example k = 4 and

// list = 10->20->30->40->50->60.
// current will either point to kth or NULL after this loop.

// current will point to node 40 in the above example
int count = 1;
while (count < k && current != NULL)
{
count++;
}
// If current is NULL, k is greater than or equal to count

// of nodes in linked list. Don't change the list in this case
if (current == NULL)
return;
// current points to kth node. Store it in a variable.

// kthNode points to node 40 in the above example
struct node *kthNode = current;
// current will point to last node after this loop

// current will point to node 60 in the above example
while (current->next != NULL)
// Change next of last node to previous head

// Change next of last node to previous head
// Next of 60 is now changed to node 10
current->next = *head_ref;
// Change head to (k+1)th node

// head is now changed to node 50
*head_ref = kthNode->next;
// change next of kth node to NULL

// next of 40 is now NULL
kthNode->next = NULL;
}
{
/* allocate node */



}

{
{
node = node->next;
}
}

int main(void)
{
// create a list 10->20->30->40->50->60

for (int i = 60; i > 0; i -= 10)
push(&head, i);
printf("Given linked list \n");

printList(head);
rotate(&head, 4);
printf("\nRotated Linked list \n");

printList(head);
return (0);
}

Output:

Given linked list
10 20 30 40 50 60
Rotated Linked list
50 60 10 20 30 40

Time Complexity: O(n) where n is the number of nodes in Linked List. The code traverses the linked list only
once.
discussed above.
Predict the output of following C program.
Question 1
#include <stdio.h>
int main()
{
char a = 30;
char b = 40;
char c = 10;
char d = (a * b) / c;
printf ("%d ", d);
return 0;
}

At first look, the expression (a*b)/c seems to cause arithmetic overflow because signed characters can have
values only from -128 to 127 (in most of the C compilers), and the value of subexpression ‘(a*b)’ is 1200. For
example, the following code snippet prints -80 on a 32 bit little endian machine.

char d = 1200;
printf ("%d ", d);

Arithmetic overflow doesn’t happen in the original program and the output of the program is 120. In C, char
and short are converted to int for arithmetic calculations. So in the expression ‘(a*b)/c’, a, b and c are
promoted to int and no overflow happens.
Question 2
#include<stdio.h>
int main()
{
int a, b = 10;
a = -b--;
printf("a = %d, b = %d", a, b);
return 0;
}

Output:
a = -10, b = 9

The statement ‘a = -b–;’ compiles fine. Unary minus and unary decrement have save precedence and right to
left associativity. Therefore ‘-b–‘ is treated as -(b–) which is valid. So -10 will be assigned to ‘a’, and ‘b’ will
become 9.
Try the following program as an exercise.
#include<stdio.h>
int main()
{
int a, b = 10;
a = b---;
printf("a = %d, b = %d", a, b);
return 0;
}

discussed above.
Predict the output of following C++ program.
#include<iostream>
class A
{
// data members of A
public:
A () { cout << "\n A's constructor"; /* Initialize data members */ }
A (const A &a) { cout << "\n A's Copy constructor"; /* copy data members */}
A& operator= (const A &a) // Assignemt Operator
{
// Handle self-assignment:
if(this == &a) return *this;
// Copy data members

cout << "\n A's Assignment Operator"; return *this;
}
};
class B
{
A a;
// Other members of B
public:
B(A &a) { this->a = a; cout << "\n B's constructor"; }
};
int main()
{
A a1;
B b(a1);
return 0;
}

Output:

A's constructor
A's constructor
A's Assignment Operator
B's constructor

The first line of output is printed by the statement “A a1;” in main().

The second line is printed when B’s member ‘a’ is initialized. This is important.
The third line is printed by the statement “this->a = a;” in B’s constructor.
The fourth line is printed by cout statement in B’s constructor.
If we take a look a closer look at the above code, the constructor of class B is not efficient as member ‘a’ is
first constructed with default constructor, and then the values from the parameter are copied using
assignment operator. It may be a concern when class A is big, which generally is the case with many
practical classes. See the following optimized code.

#include<iostream>
class A
{
// data members of A
public:
A() { cout << "\n A's constructor"; /* Initialize data members */ }
A(const A &a) { cout << "\n A's Copy constructor"; /* Copy data members */ }
A& operator= (const A &a) // Assignemt Operator
{
// Handle self-assignment:
if(this == &a) return *this;
// Copy data members

cout << "\n A's Assignment Operator"; return *this;
}
};
class B
{
A a;
// Other members of B
public:
B(A &a):a(a) { cout << "\n B's constructor"; }
};
int main()
{
A a;
B b(a);
return 0;
}

Output:

A's constructor
A's Copy constructor
B's constructor

The constructor of class B now uses initializer list to initialize its member ‘a’. When Initializer list is used,
the member ‘a’ of class B is initialized directly from the parameter. So a call to A’s constructor is reduced.
In general, it is a good idea to use Initializer List to initialize all members of a class, because it saves one
extra assignment of members. See point 6 of this post for more details.
discussed above
Replace every element with the next greatest
Given an array of integers, replace every element with the next greatest element (greatest element on the
right side) in the array. Since there is no element next to the last element, replace it with -1. For example, if
the array is {16, 17, 4, 3, 5, 2}, then it should be modified to {17, 5, 5, 5, 2, -1}.
The question is very similar to this post and solutions are also similar.
A naive method is to run two loops. The outer loop will one by one pick array elements from left to right.
The inner loop will find the greatest element present after the picked element. Finally the outer loop will
replace the picked element with the greatest element found by inner loop. The time complexity of this
method will be O(n*n).
A tricky method is to replace all elements using one traversal of the array. The idea is to start from the
rightmost element, move to the left side one by one, and keep track of the maximum element. Replace every
element with the maximum element.

#include <stdio.h>
/* Function to replace every element with the

next greatest element */
void nextGreatest(int arr[], int size)
{
// Initialize the next greatest element
int max_from_right = arr[size-1];
// The next greatest element for the rightmost element

// is always -1
arr[size-1] = -1;
// Replace all other elements with the next greatest

for(int i = size-2; i >= 0; i--)
{
// Store the current element (needed later for updating
// the next greatest element)
int temp = arr[i];
// Replace current element with the next greatest

arr[i] = max_from_right;
// Update the greatest element, if needed

if(max_from_right < temp)
max_from_right = temp;
}
}
/* A utility Function that prints an array */

{
int i;
printf("\n");
}

int main()
{
int arr[] = {16, 17, 4, 3, 5, 2};
nextGreatest (arr, size);
printf ("The modified array is: \n");
printArray (arr, size);
return (0);
}

Output:

The modified array is:
17 5 5 5 2 -1

Time Complexity: O(n) where n is the number of elements in array.

the same problem.
Dynamic Programming | Set 20 (Maximum Length Chain of Pairs)
You are given n pairs of numbers. In every pair, the first number is always smaller than the second number.
A pair (c, d) can follow another pair (a, b) if b Amazon Interview | Set 2
For example, if the given pairs are {{5, 24}, {39, 60}, {15, 28}, {27, 40}, {50, 90} }, then the longest chain
that can be formed is of length 3, and the chain is {{5, 24}, {27, 40}, {50, 90}}
This problem is a variation of standard Longest Increasing Subsequence problem. Following is a simple two
step process.
1) Sort given pairs in increasing order of first (or smaller) element.
2) Now run a modified LIS process where we compare the second element of already finalized LIS with the
first element of new LIS being constructed.
The following code is a slight modification of method 2 of this post.

#include<stdio.h>
#include<stdlib.h>
// Structure for a pair

struct pair
{
int a;
int b;
};
// This function assumes that arr[] is sorted in increasing order

// according the first (or smaller) values in pairs.
int maxChainLength( struct pair arr[], int n)
{
int i, j, max = 0;
int *mcl = (int*) malloc ( sizeof( int ) * n );
/* Initialize MCL (max chain length) values for all indexes */

for ( i = 0; i < n; i++ )
mcl[i] = 1;
/* Compute optimized chain length values in bottom up manner */

for ( i = 1; i < n; i++ )
for ( j = 0; j < i; j++ )
if ( arr[i].a > arr[j].b && mcl[i] < mcl[j] + 1)
mcl[i] = mcl[j] + 1;
// mcl[i] now stores the maximum chain length ending with pair i
/* Pick maximum of all MCL values */

for ( i = 0; i < n; i++ )
if ( max < mcl[i] )
max = mcl[i];

free( mcl );
return max;
}

int main()
{
struct pair arr[] = { {5, 24}, {15, 25},
{27, 40}, {50, 60} };
printf("Length of maximum size chain is %d\n",
maxChainLength( arr, n ));
return 0;
}

Output:

Length of maximum size chain is 3

Time Complexity: O(n^2) where n is the number of pairs.
The given problem is also a variation of Activity Selection problem and can be solved in (nLogn) time. To
solve it as a activity selection problem, consider the first element of a pair as start time in activity selection
problem, and the second element of pair as end time. Thanks to Palash for suggesting this approach.
discussed above.
Detect if two integers have opposite signs
Given two signed integers, write a function that returns true if the signs of given integers are different,
otherwise false. For example, the function should return true -1 and +100, and should return false for -100
and -200. The function should not use any of the arithmetic operators.
Let the given integers be x and y. The sign bit is 1 in negative numbers, and 0 in positive numbers. The XOR
of x and y will have the sign bit as 1 iff they have opposite sign. In other words, XOR of x and y will be
negative number number iff x and y have opposite signs. The following code use this logic.
#include<stdbool.h>
#include<stdio.h>
bool oppositeSigns(int x, int y)

{
return ((x ^ y) < 0);
}
int main()
{
int x = 100, y = -100;
if (oppositeSigns(x, y) == true)
printf ("Signs are opposite");
else
printf ("Signs are not opposite");
return 0;
}

Output:

Signs are opposite

Source: Detect if two integers have opposite signs
We can also solve this by using two comparison operators. See the following code.

{
return (x < 0)? (y >= 0): (y < 0);
}

The first method is more efficient. The first method uses a bitwise XOR and a comparison operator. The
second method uses two comparison operators and a bitwise XOR operation is more efficient compared to a
comparison operation.
We can also use following method. It doesn’t use any comparison operator. The method is suggested by
Hongliang and improved by gaurav.


{
return ((x ^ y) >> 31);
}

The function is written only for compilers where size of an integer is 32 bit. The expression basically checks
sign of (x^y) using bitwise operator ‘>>’. As mentioned above, the sign bit for negative numbers is always 1.
The sign bit is the leftmost bit in binary representation. So we need to checks whether the 32th bit (or
leftmost bit) of x^y is 1 or not. We do it by right shifting the value of x^y by 31, so that the sign bit becomes
the least significant bit. If sign bit is 1, then the value of (x^y)>>31 will be 1, otherwise 0.
the same problem.
Find four elements that sum to a given value | Set 2 ( O(n^2Logn) Solution)
Given an array of integers, find all combination of four elements in the array whose sum is equal to a given
value X.
For example, if the given array is {10, 2, 3, 4, 5, 9, 7, 8} and X = 23, then your function should print “3 5 7 8″
(3 + 5 + 7 + 8 = 23).
Sources: Find Specific Sum and Amazon Interview Question
We have discussed a O(n^3) algorithm in the previous post on this topic. The problem can be solved in
O(n^2Logn) time with the help of auxiliary space.
Thanks to itsnimish for suggesting this method. Following is the detailed process.
Let the input array be A[].
1) Create an auxiliary array aux[] and store sum of all possible pairs in aux[]. The size of aux[] will be n*(n-
1)/2 where n is the size of A[].
2) Sort the auxiliary array aux[].
3) Now the problem reduces to find two elements in aux[] with sum equal to X. We can use method 1 of this
post to find the two elements efficiently. There is following important point to note though. An element of
aux[] represents a pair from A[]. While picking two elements from aux[], we must check whether the two
elements have an element of A[] in common. For example, if first element sum of A[1] and A[2], and second
element is sum of A[2] and A[4], then these two elements of aux[] don’t represent four distinct elements of
input array A[].
Following is C implementation of this method.
#include <stdio.h>
#include <stdlib.h>
// The following structure is needed to store pair sums in aux[]

struct pairSum
{
int first; // index (int A[]) of first element in pair
int sec; // index of second element in pair
int sum; // sum of the pair
};
// Following function is needed for library function qsort()

int compare (const void *a, const void * b)
{
return ( (*(pairSum *)a).sum - (*(pairSum*)b).sum );
}
// Function to check if two given pairs have any common element or not
bool noCommon(struct pairSum a, struct pairSum b)
{
if (a.first == b.first || a.first == b.sec ||
a.sec == b.first || a.sec == b.sec)
return false;
return true;
}
// The function finds four elements with given sum X

void findFourElements (int arr[], int n, int X)
{
{
int i, j;
// Create an auxiliary array to store all pair sums

int size = (n*(n-1))/2;
struct pairSum aux[size];
/* Generate all possible pairs from A[] and store sums

of all possible pairs in aux[] */
int k = 0;
for (i = 0; i < n-1; i++)
{
for (j = i+1; j < n; j++)
{
aux[k].sum = arr[i] + arr[j];
aux[k].first = i;
aux[k].sec = j;
k++;
}
}
// Sort the aux[] array using library function for sorting

qsort (aux, size, sizeof(aux[0]), compare);
// Now start two index variables from two corners of array

// and move them toward each other.
i = 0;
j = size-1;
while (i < size && j >=0 )
{
if ((aux[i].sum + aux[j].sum == X) && noCommon(aux[i], aux[j]))
{
printf ("%d, %d, %d, %d\n", arr[aux[i].first], arr[aux[i].sec],
arr[aux[j].first], arr[aux[j].sec]);
return;
}
else if (aux[i].sum + aux[j].sum < X)
i++;
else
j--;
}
}

int main()
{
int arr[] = {10, 20, 30, 40, 1, 2};
int n = sizeof(arr) / sizeof(arr[0]);
int X = 91;
findFourElements (arr, n, X);
return 0;
}

Output:

20, 1, 30, 40

Please note that the above code prints only one quadruple. If we remove the return statement and add
statements “i++; j–;”, then it prints same quadruple five times. The code can modified to print all
quadruples only once. It has been kept this way to keep it simple.
Time complexity: The step 1 takes O(n^2) time. The second step is sorting an array of size O(n^2). Sorting
can be done in O(n^2Logn) time using merge sort or heap sort or any other O(nLogn) algorithm. The third
step takes O(n^2) time. So overall complexity is O(n^2Logn).
Auxiliary Space: O(n^2). The big size of auxiliary array can be a concern in this method.
the same problem.
Find four elements that sum to a given value | Set 1 (n^3 solution)
Given an array of integers, find all combination of four elements in the array whose sum is equal to a given
value X.
For example, if the given array is {10, 2, 3, 4, 5, 9, 7, 8} and X = 23, then your function should print “3 5 7 8″
(3 + 5 + 7 + 8 = 23).
Sources: Find Specific Sum and Amazon Interview Question
A Naive Solution is to generate all possible quadruples and compare the sum of every quadruple with X.
The following code implements this simple method using four nested loops
#include <stdio.h>
/* A naive solution to print all combination of 4 elements in A[]

with sum equal to X */
void findFourElements(int A[], int n, int X)
{
// Fix the first element and find other three
for (int i = 0; i < n-3; i++)
{
// Fix the second element and find other two
for (int j = i+1; j < n-2; j++)
{
// Fix the third element and find the fourth
for (int k = j+1; k < n-1; k++)
{
// find the fourth
for (int l = k+1; l < n; l++)
if (A[i] + A[j] + A[k] + A[l] == X)
printf("%d, %d, %d, %d", A[i], A[j], A[k], A[l]);
}
}
}
}
// Driver program to test above funtion

int main()
{
int A[] = {10, 20, 30, 40, 1, 2};
int n = sizeof(A) / sizeof(A[0]);
int X = 91;
findFourElements (A, n, X);
return 0;
}

Output:

20, 30, 40, 1

The time complexity can be improved to O(n^3) with the use of sorting as a preprocessing step, and then
using method 1 of this post to reduce a loop.
Following are the detailed steps.
2) Fix the first element as A[i] where i is from 0 to n–3. After fixing the first element of quadruple, fix the
second element as A[j] where j varies from i+1 to n-2. Find remaining two elements in O(n) time, using the
method 1 of this post
Following is C implementation of O(n^3) solution.

# include <stdio.h>
/* Following function is needed for library function qsort(). Refer

http://www.cplusplus.com/reference/clibrary/cstdlib/qsort/ */
{ return ( *(int *)a - *(int *)b ); }
/* A sorting based solution to print all combination of 4 elements in A[]

with sum equal to X */
void find4Numbers(int A[], int n, int X)
{
int l, r;
// Sort the array in increasing order, using library

// function for quick sort
qsort (A, n, sizeof(A[0]), compare);
/* Now fix the first 2 elements one by one and find

the other two elements */
for (int i = 0; i < n - 3; i++)
{
for (int j = i+1; j < n - 2; j++)
{
// Initialize two variables as indexes of the first and last
// elements in the remaining elements
l = j + 1;
r = n-1;
// To find the remaining two elements, move the index

// variables (l & r) toward each other.
while (l < r)
{
if( A[i] + A[j] + A[l] + A[r] == X)
{
printf("%d, %d, %d, %d", A[i], A[j],
A[l], A[r]);
l++; r--;
}
else if (A[i] + A[j] + A[l] + A[r] < X)
l++;
else // A[i] + A[j] + A[l] + A[r] > X
r--;
} // end of while
} // end of inner for loop
} // end of outer for loop
}

int main()
{
int A[] = {1, 4, 45, 6, 10, 12};
int X = 21;
int n = sizeof(A)/sizeof(A[0]);
find4Numbers(A, n, X);
return 0;
}

Output:

1, 4, 6, 10

This problem can also be solved in O(n^2Logn) complexity. We will soon be publishing the O(n^2Logn)
solution as a separate post.
the same problem.
Check whether a given Binary Tree is Complete or not | Set 1 (Iterative
Solution)
Given a Binary Tree, write a function to check whether the given Binary Tree is Complete Binary Tree or not.
A complete binary tree is a binary tree in which every level, except possibly the last, is completely filled, and
all nodes are as far left as possible. See following examples.
The following trees are examples of Complete Binary Trees

1
/ \
2 3

1
/ \
2 3
/
4
1
/ \
2 3
/ \ /
4 5 6

The following trees are examples of Non-Complete Binary Trees

1
\
3

1
/ \
2 3
\ / \
4 5 6
1
/ \
2 3
/ \
4 5

Source: Write an algorithm to check if a tree is complete binary tree or not
The method 2 of level order traversal post can be easily modified to check whether a tree is Complete or not.
To understand the approach, let us first define a term ‘Full Node’. A node is ‘Full Node’ if both left and right
children are not empty (or not NULL).
The approach is to do a level order traversal starting from root. In the traversal, once a node is found which
is NOT a Full Node, all the following nodes must be leaf nodes.
Also, one more thing needs to be checked to handle the below case: If a node has empty left child, then the
right child must be empty.

1
/ \
2 3
\
4

Thanks to Guddu Sharma for suggesting this simple and efficient approach.
// A program to check if a given binary tree is complete or not

#include <stdio.h>
#include <stdlib.h>
#define MAX_Q_SIZE 500

struct node
{
int data;
struct node* left;
struct node* right;
};
/* frunction prototypes for functions needed for Queue data

structure. A queue is needed for level order tarversal */
struct node** createQueue(int *, int *);
void enQueue(struct node **, int *, struct node *);
struct node *deQueue(struct node **, int *);
bool isQueueEmpty(int *front, int *rear);
/* Given a binary tree, return true if the tree is complete

else false */
bool isCompleteBT(struct node* root)
{
// Base Case: An empty tree is complete Binary Tree
if (root == NULL)
return true;
// Create an empty queue

int rear, front;
struct node **queue = createQueue(&front, &rear);
// Create a flag variable which will be set true

// when a non full node is seen
bool flag = false;
// Do level order traversal using queue.

enQueue(queue, &rear, root);
while(!isQueueEmpty(&front, &rear))
{
struct node *temp_node = deQueue(queue, &front);
/* Ceck if left child is present*/

if(temp_node->left)
{
// If we have seen a non full node, and we see a node
// with non-empty left child, then the given tree is not
// a complete Binary Tree
if (flag == true)
return false;
enQueue(queue, &rear, temp_node->left); // Enqueue Left Child

}
else // If this a non-full node, set the flag as true
flag = true;
/* Ceck if right child is present*/

if(temp_node->right)
{
// If we have seen a non full node, and we see a node
// a complete Binary Tree
if(flag == true)
return false;
enQueue(queue, &rear, temp_node->right); // Enqueue Right Child

}
else // If this a non-full node, set the flag as true
flag = true;
}
// If we reach here, then the tree is complete Bianry Tree

return true;
}
struct node** createQueue(int *front, int *rear)
{
struct node **queue =
(struct node **)malloc(sizeof(struct node*)*MAX_Q_SIZE);
*front = *rear = 0;
return queue;
}
void enQueue(struct node **queue, int *rear, struct node *new_node)

{
queue[*rear] = new_node;
(*rear)++;
}
struct node *deQueue(struct node **queue, int *front)

{
(*front)++;
return queue[*front - 1];
}
bool isQueueEmpty(int *front, int *rear)

{
return (*rear == *front);
}

{
node->data = data;
node->left = NULL;
node->left = NULL;
node->right = NULL;
return(node);
}

int main()
{
/* Let us construct the following Binary Tree which
is not a complete Binary Tree
1
/ \
2 3
/ \ \
4 5 6
*/

if ( isCompleteBT(root) == true )
printf ("Complete Binary Tree");
else
printf ("NOT Complete Binary Tree");
return 0;
}

Output:

NOT Complete Binary Tree

Time Complexity: O(n) where n is the number of nodes in given Binary Tree
Auxiliary Space: O(n) for queue.
the same problem.
Sort a nearly sorted (or K sorted) array
Given an array of n elements, where each element is at most k away from its target position, devise an
algorithm that sorts in O(n log k) time.
For example, let us consider k is 2, an element at index 7 in the sorted array, can be at indexes 5, 6, 7, 8, 9 in
the given array.
Source: Nearly sorted algorithm
We can use Insertion Sort to sort the elements efficiently. Following is the C code for standard Insertion
Sort.
/* Function to sort an array using insertion sort*/

void insertionSort(int A[], int size)
{
int i, key, j;
for (i = 1; i < size; i++)
{
key = A[i];
j = i-1;
/* Move elements of A[0..i-1], that are greater than key, to one

position ahead of their current position.
This loop will run at most k times */
while (j >= 0 && A[j] > key)
{
A[j+1] = A[j];
j = j-1;
}
A[j+1] = key;
}
}

The inner loop will run at most k times. To move every element to its correct place, at most k elements need
to be moved. So overall complexity will be O(nk)
We can sort such arrays more efficiently with the help of Heap data structure . Following is the
detailed process that uses Heap.
1) Create a Min Heap of size k+1 with first k+1 elements. This will take O(k) time (See this GFact)
2) One by one remove min element from heap, put it in result array, and add a new element to heap from
remaining elements.
Removing an element and adding a new element to min heap will take Logk time. So overall complexity will
be O(k) + O((n-k)*logK)
#include<iostream>
// Prototype of a utility function to swap two integers

void swap(int *x, int *y);
// A class for Min Heap

class MinHeap
{
int *harr; // pointer to array of elements in heap
int heap_size; // size of min heap
public:
// Constructor
MinHeap(int a[], int size);
// to heapify a subtree with root at given index

void MinHeapify(int );
// to get index of left child of node at index i

int left(int i) { return (2*i + 1); }
// to get index of right child of node at index i

int right(int i) { return (2*i + 2); }
// to remove min (or root), add a new value x, and return old root
int replaceMin(int x);
// to extract the root which is the minimum element

int extractMin();
};
// Given an array of size n, where every element is k away from its target
// position, sorts the array in O(nLogk) time.
int sortK(int arr[], int n, int k)
{
// Create a Min Heap of first (k+1) elements from
// input array
int *harr = new int[k+1];
for (int i = 0; i<=k && i<n; i++) // i < n condition is needed when k > n
harr[i] = arr[i];
MinHeap hp(harr, k+1);
// i is index for remaining elements in arr[] and ti

// is target index of for cuurent minimum element in
// Min Heapm 'hp'.
for(int i = k+1, ti = 0; ti < n; i++, ti++)
{
// If there are remaining elements, then place
// root of heap at target index and add arr[i]
// to Min Heap
if (i < n)
arr[ti] = hp.replaceMin(arr[i]);
// Otherwise place root at its target index and

// reduce heap size
else
arr[ti] = hp.extractMin();
}
}
// FOLLOWING ARE IMPLEMENTATIONS OF STANDARD MIN HEAP METHODS FROM CORMEN BOOK
// Constructor: Builds a heap from a given array a[] of given size
MinHeap::MinHeap(int a[], int size)
{
heap_size = size;
harr = a; // store address of array
int i = (heap_size - 1)/2;
while (i >= 0)
{
MinHeapify(i);
i--;
}
}
// Method to remove minimum element (or root) from min heap
int MinHeap::extractMin()
{
int root = harr[0];
if (heap_size > 1)
{
harr[0] = harr[heap_size-1];
heap_size--;
MinHeapify(0);
}
return root;
}
// Method to change root with given value x, and return the old root
int MinHeap::replaceMin(int x)
{
int root = harr[0];
harr[0] = x;
if (root < x)
MinHeapify(0);
return root;
}
// A recursive method to heapify a subtree with root at given index

// This method assumes that the subtrees are already heapified
void MinHeap::MinHeapify(int i)
{
int l = left(i);
int r = right(i);
int smallest = i;
if (l < heap_size && harr[l] < harr[i])
smallest = l;
if (r < heap_size && harr[r] < harr[smallest])
smallest = r;
if (smallest != i)
{
swap(&harr[i], &harr[smallest]);
MinHeapify(smallest);
}
}
// A utility function to swap two elements

void swap(int *x, int *y)
{
int temp = *x;
*x = *y;
*y = temp;
}
// A utility function to print array elements

{
for (int i=0; i < size; i++)
cout << arr[i] << " ";
cout << endl;
}

int main()
{
int k = 3;
int arr[] = {2, 6, 3, 12, 56, 8};
sortK(arr, n, k);
sortK(arr, n, k);
cout << "Following is sorted array\n";

printArray (arr, n);
return 0;
}

Output:

Following is sorted array
2 3 6 8 12 56

The Min Heap based method takes O(nLogk) time and uses O(k) auxiliary space.
We can also use a Balanced Binary Search Tree instead of Heap to store K+1 elements. The insert and
delete operations on Balanced BST also take O(Logk) time. So Balanced BST based method will also take
O(nLogk) time, but the Heap bassed method seems to be more efficient as the minimum element will always
be at root. Also, Heap doesn’t need extra space for left and right pointers.
the same problem.
Predict the output of following C++ program.
Question 1
#include <iostream>
class A
{
int id;
public:
A (int i) { id = i; }
void print () { cout << id << endl; }
};
int main()
{
A a[2];
a[0].print();
a[1].print();
return 0;
}

There is a compilation error in line “A a[2]”. There is no default constructor in class A. When we write our
own parameterzied constructor or copy constructor, compiler doesn’t create the default constructor (See this
Gfact). We can fix the error, either by creating a default constructor in class A, or by using the following
syntax to initialize array member using parameterzied constructor.

// Initialize a[0] with value 10 and a[1] with 20
A a[2] = { A(10), A(20) }

Question 2

#include <iostream>
class A
{
int id;
static int count;
public:
A()
{
count++;
id = count;
cout << "constructor called " << id << endl;
}
~A()
{
cout << "destructor called " << id << endl;
}
};
int A::count = 0;
int main()
{
A a[2];
return 0;
}

Output:

constructor called 1
constructor called 2
destructor called 2
destructor called 1

In the above program, object a[0] is created first, but the object a[1] is destroyed first. Objects are always
destroyed in reverse order of their creation. The reason for reverse order is, an object created later may use
the previously created object. For example, consider the following code snippet.
A a;
B b(a);

In the above code, the object ‘b’ (which is created after ‘a’), may use some members of ‘a’ internally. So
destruction of ‘a’ before ‘b’ may create problems. Therefore, object ‘b’ must be destroyed before ‘a’.
Question 3

#include <iostream>
class A
{
int aid;
public:
A(int x)
{ aid = x; }
void print()
{ cout << "A::aid = " <<aid; }
};
class B
{
int bid;
public:
static A a;
B (int i) { bid = i; }
};
int main()
{
B b(10);
b.a.print();
return 0;
}

Compiler Error: undefined reference to `B::a’

The class B has a static member ‘a’. Since member ‘a’ is static, it must be defined outside the class. Class A
doesn’t have Default constructor, so we must pass a value in definition also. Adding a line “A B::a(10);” will
make the program work.
The following program works fine and produces the output as “A::aid = 10″

#include <iostream>
class A
{
int aid;
public:
A(int x)
{ aid = x; }
void print()
{ cout << "A::aid = " <<aid; }
};
class B
{
int bid;
public:
static A a;
B (int i) { bid = i; }
};
A B::a(10);
int main()
{
B b(10);
b.a.print();
return 0;
}

discussed above
Given a number, find the next smallest palindrome
Given a number, find the next smallest palindrome larger than this number. For example, if the input
number is “2 3 5 4 5″, the output should be “2 3 6 3 2″. And if the input number is “9 9 9″, the output should
be “1 0 0 1″.
The input is assumed to be an array. Every entry in array represents a digit in input number. Let the array
be ‘num[]’ and size of array be ‘n’
There can be three different types of inputs that need to be handled separately.
1) The input number is palindrome and has all 9s. For example “9 9 9″. Output should be “1 0 0 1″
2) The input number is not palindrome. For example “1 2 3 4″. Output should be “1 3 3 1″
3) The input number is palindrome and doesn’t have all 9s. For example “1 2 2 1″. Output should be “1 3 3
1″.
Solution for input type 1 is easy. The output contains n + 1 digits where the corner digits are 1, and all digits
between corner digits are 0.
Now let us first talk about input type 2 and 3. How to convert a given number to a greater palindrome? To
understand the solution, let us first define the following two terms:
Left Side: The left half of given number. Left side of “1 2 3 4 5 6″ is “1 2 3″ and left side of “1 2 3 4 5″ is “1 2″
Right Side: The right half of given number. Right side of “1 2 3 4 5 6″ is “4 5 6″ and right side of “1 2 3 4 5″ is
“4 5″
To convert to palindrome, we can either take the mirror of its left side or take mirror of its right side.
However, if we take the mirror of the right side, then the palindrome so formed is not guaranteed to be next
larger palindrome. So, we must take the mirror of left side and copy it to right side. But there are some cases
that must be handled in different ways. See the following steps.
We will start with two indices i and j. i pointing to the two middle elements (or pointing to two elements
around the middle element in case of n being odd). We one by one move i and j away from each other.
Step 1. Initially, ignore the part of left side which is same as the corresponding part of right side. For
example, if the number is “8 3 4 2 2 4 6 9″, we ignore the middle four elements. i now points to element 3
and j now points to element 6.
Step 2. After step 1, following cases arise:
Case 1: Indices i & j cross the boundary.

This case occurs when the input number is palindrome. In this case, we just add 1 to the middle digit (or
digits in case n is even) propagate the carry towards MSB digit of left side and simultaneously copy mirror of
the left side to the right side.
For example, if the given number is “1 2 9 2 1″, we increment 9 to 10 and propagate the carry. So the number
becomes “1 3 0 3 1″
Case 2: There are digits left between left side and right side which are not same. So, we just mirror the left
side to the right side & try to minimize the number formed to guarantee the next smallest palindrome.
In this case, there can be two sub-cases.
2.1) Copying the left side to the right side is sufficient, we don’t need to increment any digits and the result
is just mirror of left side. Following are some examples of this sub-case.
Next palindrome for “7 8 3 3 2 2″ is “7 8 3 3 8 7″
Next palindrome for “1 4 5 8 7 6 7 8 3 2 2″ is “1 4 5 8 7 6 7 8 5 4 1″
How do we check for this sub-case? All we need to check is the digit just after the ignored part in step 1. This
digit is highlighted in above examples. If this digit is greater than the corresponding digit in right side digit,
then copying the left side to the right side is sufficient and we don’t need to do anything else.
2.2) Copying the left side to the right side is NOT sufficient. This happens when the above defined digit of
left side is smaller. Following are some examples of this case.
Next palindrome for “1 2 3 4 6 2 8″ is “1 2 3 5 3 2 1″
Next palindrome for “9 4 1 8 7 9 7 8 3 2 2″ is “9 4 1 8 8 0 8 8 1 4 9″
We handle this subcase like Case 1. We just add 1 to the middle digit (or digits in ase n is even) propagate the
carry towards MSB digit of left side and simultaneously copy mirror of the left side to the right side.
#include <stdio.h>
// A utility function to print an array

void printArray (int arr[], int n);
// A utility function to check if num has all 9s

int AreAll9s (int num[], int n );
// Returns next palindrome of a given number num[].

// This function is for input type 2 and 3
void generateNextPalindromeUtil (int num[], int n )
{
// find the index of mid digit
int mid = n/2;
// A bool variable to check if copy of left side to right is sufficient or not

bool leftsmaller = false;
// end of left side is always 'mid -1'

int i = mid - 1;
// Begining of right side depends if n is odd or even

int j = (n % 2)? mid + 1 : mid;
// Initially, ignore the middle same digits

while (i >= 0 && num[i] == num[j])
i--,j++;
// Find if the middle digit(s) need to be incremented or not (or copying left
// side is not sufficient)
if ( i < 0 || num[i] < num[j])
leftsmaller = true;
// Copy the mirror of left to tight

while (i >= 0)
{
num[j] = num[i];
j++;
i--;
}
// Handle the case where middle digit(s) must be incremented.

// This part of code is for CASE 1 and CASE 2.2
if (leftsmaller == true)
{
int carry = 1;
i = mid - 1;
// If there are odd digits, then increment

// the middle digit and store the carry
if (n%2 == 1)
{
{
num[mid] += carry;
carry = num[mid] / 10;
num[mid] %= 10;
j = mid + 1;
}
else
j = mid;
// Add 1 to the rightmost digit of the left side, propagate the carry
// towards MSB digit and simultaneously copying mirror of the left side
// to the right side.
while (i >= 0)
{
num[i] += carry;
carry = num[i] / 10;
num[i] %= 10;
num[j++] = num[i--]; // copy mirror to right
}
}
}
// The function that prints next palindrome of a given number num[]

// with n digits.
void generateNextPalindrome( int num[], int n )
{
int i;
printf("\nNext palindrome is:\n");
// Input type 1: All the digits are 9, simply o/p 1

// followed by n-1 0's followed by 1.
if( AreAll9s( num, n ) )
{
printf( "1 ");
for( i = 1; i < n; i++ )
printf( "0 " );
printf( "1" );
}
// Input type 2 and 3

else
{
generateNextPalindromeUtil ( num, n );
// print the result

printArray (num, n);
}
}
// A utility function to check if num has all 9s

int AreAll9s( int* num, int n )
{
int i;
for( i = 0; i < n; ++i )
if( num[i] != 9 )
return 0;
return 1;
}

void printArray(int arr[], int n)
{
int i;
for (i=0; i < n; i++)
for (i=0; i < n; i++)
printf("\n");
}

int main()
{
int num[] = {9, 4, 1, 8, 7, 9, 7, 8, 3, 2, 2};
int n = sizeof (num)/ sizeof(num[0]);
generateNextPalindrome( num, n );
return 0;
}

Output:
Next palindrome is:

9 4 1 8 8 0 8 8 1 4 9

discussed above.
Boundary Traversal of binary tree
Given a binary tree, print boundary nodes of the binary tree Anti-Clockwise starting from the root. For
example, boundary traversal of the following tree is “20 8 4 10 14 25 22″
We break the problem in 3 parts:

1. Print the left boundary in top-down manner.
2. Print all leaf nodes from left to right, which can again be sub-divided into two sub-parts:
…..2.1 Print all leaf nodes of left sub-tree from left to right.
…..2.2 Print all leaf nodes of right subtree from left to right.
3. Print the right boundary in bottom-up manner.
We need to take care of one thing that nodes are not printed again. e.g. The left most node is also the leaf
node of the tree.
Based on the above cases, below is the implementation:
/* program for boundary traversal of a binary tree */

#include <stdio.h>
#include <stdlib.h>

struct node
{
int data;
};
// A simple function to print leaf nodes of a binary tree

void printLeaves(struct node* root)
{
if ( root )
{
printLeaves(root->left);
// Print it if it is a leaf node

if ( !(root->left) && !(root->right) )
printLeaves(root->right);
}
}
// A function to print all left boundry nodes, except a leaf node.

// Print the nodes in TOP DOWN manner
void printBoundaryLeft(struct node* root)
void printBoundaryLeft(struct node* root)
{
if (root)
{
if (root->left)
{
// to ensure top down order, print the node
// before calling itself for left subtree
printBoundaryLeft(root->left);
}
else if( root->right )
{
printBoundaryLeft(root->right);
}
// do nothing if it is a leaf node, this way we avoid
// duplicates in output
}
}
// A function to print all right boundry nodes, except a leaf node

// Print the nodes in BOTTOM UP manner
void printBoundaryRight(struct node* root)
{
if (root)
{
if ( root->right )
{
// to ensure bottom up order, first call for right
// subtree, then print this node
printBoundaryRight(root->right);
}
else if ( root->left )
{
printBoundaryRight(root->left);
}
// do nothing if it is a leaf node, this way we avoid
// duplicates in output
}
}
// A function to do boundary traversal of a given binary tree

void printBoundary (struct node* root)
{
if (root)
{
printf("%d ",root->data);
// Print the left boundary in top-down manner.

printBoundaryLeft(root->left);
// Print all leaf nodes

printLeaves(root->left);
printLeaves(root->right);
// Print the right boundary in bottom-up manner

printBoundaryRight(root->right);
}
}
// A utility function to create a node

struct node* newNode( int data )
{
struct node* temp = (struct node *) malloc( sizeof(struct node) );
temp->data = data;
temp->left = temp->right = NULL;
return temp;
}

int main()
{
// Let us construct the tree given in the above diagram
root->left->right->left = newNode(10);
root->left->right->right = newNode(14);
printBoundary( root );
return 0;
}

Output:

20 8 4 10 14 25 22

Time Complexity: O(n) where n is the number of nodes in binary tree.
discussed above
Question 1
#include <iostream>
class A
{
public:
void print() { cout << "A::print()"; }
};
class B : private A
{
public:
void print() { cout << "B::print()"; }
};
class C : public B
{
public:
void print() { A::print(); }
};
int main()
{
C b;
b.print();
}

Output: Compiler Error: ‘A’ is not an accessible base of ‘C’

There is multilevel inheritance in the above code. Note the access specifier in “class B : private A”. Since
private access specifier is used, all members of ‘A’ become private in ‘B’. Class ‘C’ is a inherited class of ‘B’.
An inherited class can not access private data members of the parent class, but print() of ‘C’ tries to access
private member, that is why we get the error.
Question 2

#include<iostream>
class base
{
public:
virtual void show() { cout<<" In Base \n"; }
};
class derived: public base

{
int x;
public:
void show() { cout<<"In derived \n"; }
derived() { x = 10; }
int getX() const { return x;}
};
int main()
{
derived d;
base *bp = &d;
bp->show();
cout << bp->getX();
return 0;
}

Output: Compiler Error: ‘class base’ has no member named ‘getX’

In the above program, there is pointer ‘bp’ of type ‘base’ which points to an object of type derived. The call of
show() through ‘bp’ is fine because ‘show()’ is present in base class. In fact, it calls the derived class ‘show()’
because ‘show()’ is virtual in base class. But the call to ‘getX()’ is invalid, because getX() is not present in
base class. When a base class pointer points to a derived class object, it can access only those methods of
derived class which are present in base class and are virtual.
Question 3

#include<iostream>
class Test
{
int value;
public:
Test(int v = 0) { value = v; }
int getValue() { return value; }
};
int main()
{
const Test t;
return 0;
}


In the above program, object ‘t’ is declared as a const object. A const object can only call const functions. To
fix the error, we must make getValue() a const function.
discussed above
Two nodes of a BST are swapped, correct the BST
Two of the nodes of a Binary Search Tree (BST) are swapped. Fix (or correct) the BST.
Input Tree:
10
/ \
5 8
/ \
2 20
In the above tree, nodes 20 and 8 must be swapped to fix the tree.
Following is the output tree
10
/ \
5 20
/ \
2 8

The inorder traversal of a BST produces a sorted array. So a simple method is to store inorder traversal of
the input tree in an auxiliary array. Sort the auxiliary array. Finally, insert the auxiilary array elements back
to the BST, keeping the structure of the BST same. Time complexity of this method is O(nLogn) and auxiliary
space needed is O(n).
We can solve this in O(n) time and with a single traversal of the given BST . Since inorder
traversal of BST is always a sorted array, the problem can be reduced to a problem where two elements of a
sorted array are swapped. There are two cases that we need to handle:
1. The swapped nodes are not adjacent in the inorder traversal of the BST.
For example, Nodes 5 and 25 are swapped in {3 5 7 8 10 15 20 25}.

The inorder traversal of the given tree is 3 25 7 8 10 15 20 5

If we observe carefully, during inorder traversal, we find node 7 is smaller than the previous visited node 25.
Here save the context of node 25 (previous node). Again, we find that node 5 is smaller than the previous
node 20. This time, we save the context of node 5 ( current node ). Finally swap the two node’s values.
2. The swapped nodes are adjacent in the inorder traversal of BST.
For example, Nodes 7 and 8 are swapped in {3 5 7 8 10 15 20 25}.

The inorder traversal of the given tree is 3 5 8 7 10 15 20 25

Unlike case #1, here only one point exists where a node value is smaller than previous node value. e.g. node 7
is smaller than node 8.
How to Solve? We will maintain three pointers, first, middle and last. When we find the first point where
current node value is smaller than previous node value, we update the first with the previous node &
middle with the current node. When we find the second point where current node value is smaller than
previous node value, we update the last with the current node. In case #2, we will never find the second
point. So, last pointer will not be updated. After processing, if the last node value is null, then two swapped
nodes of BST are adjacent.
Following is C implementation of the given code.
// Two nodes in the BST's swapped, correct the BST.

#include <stdio.h>
#include <stdlib.h>

struct node
{
int data;
};
// A utility function to swap two integers

void swap( int* a, int* b )
{
int t = *a;
*a = *b;
*b = t;
}

{
struct node* node = (struct node *)malloc(sizeof(struct node));
node->data = data;
node->left = NULL;
node->right = NULL;
return(node);
}
// This function does inorder traversal to find out the two swapped nodes.
// It sets three pointers, first, middle and last. If the swapped nodes are
// adjacent to each other, then first and middle contain the resultant nodes
// Else, first and last contain the resultant nodes
void correctBSTUtil( struct node* root, struct node** first,
struct node** middle, struct node** last,
struct node** prev )
{
if( root )
{
// Recur for the left subtree
correctBSTUtil( root->left, first, middle, last, prev );
// If this node is smaller than the previous node, it's violating

// the BST rule.
if (*prev && root->data < (*prev)->data)
{
// If this is first violation, mark these two nodes as
// 'first' and 'middle'
if ( !*first )
{
*first = *prev;
*middle = root;
}
}
// If this is second violation, mark this node as last

else
*last = root;
}
// Mark this node as previous

*prev = root;
// Recur for the right subtree

correctBSTUtil( root->right, first, middle, last, prev );
}
}
// A function to fix a given BST where two nodes are swapped. This
// function uses correctBSTUtil() to find out two nodes and swaps the
// nodes to fix the BST
void correctBST( struct node* root )
{
// Initialize pointers needed for correctBSTUtil()
struct node *first, *middle, *last, *prev;
first = middle = last = prev = NULL;
// Set the poiters to find out two nodes

correctBSTUtil( root, &first, &middle, &last, &prev );
// Fix (or correct) the tree

if( first && last )
swap( &(first->data), &(last->data) );
else if( first && middle ) // Adjacent nodes swapped
swap( &(first->data), &(middle->data) );
// else nodes have not been swapped, passed tree is really BST.
}
/* A utility function to print Inoder traversal */

{
if (node == NULL)
return;
}

int main()
{
/* 6
/ \
10 2
/ \ / \
1 3 7 12
10 and 2 are swapped
*/

printf("Inorder Traversal of the original tree \n");
printInorder(root);
correctBST(root);
printf("\nInorder Traversal of the fixed tree \n");

printInorder(root);
return 0;
}

Output:

Inorder Traversal of the original tree
1 10 3 6 7 2 12
Inorder Traversal of the fixed tree
1 2 3 6 7 10 12

See this for different test cases of the above code.
discussed above
Dynamic Programming | Set 21 (Variations of LIS)
We have discussed Dynamic Programming solution for Longest Increasing Subsequence problem in this post
and a O(nLogn) solution in this post. Following are commonly asked variations of the standard LIS problem.
1. Building Bridges: Consider a 2-D map with a horizontal river passing through its center. There are n
cities on the southern bank with x-coordinates a(1) … a(n) and n cities on the northern bank with x-
coordinates b(1) … b(n). You want to connect as many north-south pairs of cities as possible with bridges
such that no two bridges cross. When connecting cities, you can only connect city i on the northern bank to
city i on the southern bank.
8 1 4 3 5 2 6 7
--------------------------------------------

--------------------------------------------
1 2 3 4 5 6 7 8
Source: Dynamic Programming Practice Problems. The link also has well explained solution for the problem.
2. Maximum Sum Increasing Subsequence: Given an array of n positive integers. Write a program to
find the maximum sum subsequence of the given array such that the intgers in the subsequence are sorted in
increasing order. For example, if input is {1, 101, 2, 3, 100, 4, 5}, then output should be {1, 2, 3, 100}. The
solution to this problem has been published here.
3. The Longest Chain You are given pairs of numbers. In a pair, the first number is smaller with respect to
the second number. Suppose you have two sets (a, b) and (c, d), the second set can follow the first set if b
here.
4. Box Stacking You are given a set of n types of rectangular 3-D boxes, where the i^th box has height h(i),
width w(i) and depth d(i) (all real numbers). You want to create a stack of boxes which is as tall as possible,
but you can only stack a box on top of another box if the dimensions of the 2-D base of the lower box are
each strictly larger than those of the 2-D base of the higher box. Of course, you can rotate a box so that any
side functions as its base. It is also allowable to use multiple instances of the same type of box.
Source: Dynamic Programming Practice Problems. The link also has well explained solution for the problem.
discussed above.
Maximum circular subarray sum
Given n numbers (both +ve and -ve), arranged in a circle, fnd the maximum sum of consecutive number.
Examples:
Input: a[] = {8, -8, 9, -9, 10, -11, 12}

Output: 22 (12 + 8 - 8 + 9 - 9 + 10)
Input: a[] = {10, -3, -4, 7, 6, 5, -4, -1}

Output: 23 (7 + 6 + 5 - 4 -1 + 10)
Input: a[] = {-1, 40, -14, 7, 6, 5, -4, -1}

Output: 52 (7 + 6 + 5 - 4 - 1 - 1 + 40)

There can be two cases for the maximum sum:
Case 1: The elements that contribute to the maximum sum are arranged such that no wrapping is there.
Examples: {-10, 2, -1, 5}, {-2, 4, -1, 4, -1}. In this case, Kadane’s algorithm will produce the result.
Case 2: The elements which contribute to the maximum sum are arranged such that wrapping is there.
Examples: {10, -12, 11}, {12, -5, 4, -8, 11}. In this case, we change wrapping to non-wrapping. Let us see how.
Wrapping of contributing elements implies non wrapping of non contributing elements, so find out the sum
of non contributing elements and subtract this sum from the total sum. To find out the sum of non
contributing, invert sign of each element and then run Kadane’s algorithm.
Our array is like a ring and we have to eliminate the maximum continuous negative that implies maximum
continuous positive in the inverted arrays.
Finally we compare the sum obtained by both cases, and return the maximum of the two sums.
Thanks to ashishdey0 for suggesting this solution. Following is C implementation of the above method.

// Program for maximum contiguous circular sum problem

#include<stdio.h>
// Standard Kadane's algorithm to find maximum subarray sum

int kadane (int a[], int n);
// The function returns maximum circular contiguous sum in a[]

int maxCircularSum (int a[], int n)
{
// Case 1: get the maximum sum using standard kadane's algorithm
int max_kadane = kadane(a, n);
// Case 2: Now find the maximum sum that includes corner elements.
int max_wrap = 0, i;
for(i=0; i<n; i++)
{
max_wrap += a[i]; // Calculate array-sum
a[i] = -a[i]; // invert the array (change sign)
}
// max sum with corner elements will be:

// array-sum - (-max subarray sum of inverted array)
max_wrap = max_wrap + kadane(a, n);
// The maximum circular sum will be maximum of two sums

return (max_wrap > max_kadane)? max_wrap: max_kadane;
}
// Standard Kadane's algorithm to find maximum subarray sum

// See http://www.geeksforgeeks.org/archives/576 for details
int kadane (int a[], int n)
{
int i;
for(i = 0; i < n; i++)
{
if(max_so_far < max_ending_here)
}
return max_so_far;
}
/* Driver program to test maxCircularSum() */

int main()
{
int a[] = {11, 10, -20, 5, -3, -5, 8, -13, 10};
printf("Maximum circular sum is %d\n", maxCircularSum(a, n));
return 0;
}

Output:

Maximum circular sum is 31

Time Complexity: O(n) where n is the number of elements in input array.
Note that the above algorithm doesn’t work if all numbers are negative e.g., {-1, -2, -3}. It returns 0 in this
case. This case can be handled by adding a pre-check to see if all the numbers are negative before running
the above algorithm.
the same problem.
Question 1
#include<iostream>
class Base
{
public:
int fun() { cout << "Base::fun() called"; }
int fun(int i) { cout << "Base::fun(int i) called"; }
};
class Derived: public Base

{
public:
int fun(char x) { cout << "Derived::fun(char ) called"; }
};
int main()
{
Derived d;
d.fun();
return 0;
}

Output: Compiler Error.

In the above program, fun() of base class is not accessible in the derived class. If a derived class creates a
member method with name same as one of the methods in base class, then all the base class methods with
this name become hidden in derived class (See this for more details)
Question 2

#include<iostream>
class Base
{
protected:
int x;
public:
Base (int i){ x = i;}
};
class Derived : public Base

{
public:
Derived (int i):x(i) { }
void print() { cout << x ; }
};
int main()
{
Derived d(10);
d.print();
}


In the above program, x is protected, so it is accessible in derived class. Derived class constructor tries to use
initializer list to directly initialize x, which is not allowed even if x is accessible. The members of base class
can only be initialized through a constructor call of base class. Following is the corrected program.
#include<iostream>
class Base {
protected:
int x;
public:
Base (int i){ x = i;}
};
class Derived : public Base {

public:
Derived (int i):Base(i) { }
void print() { cout << x; }
};
int main()
{
Derived d(10);
d.print();
}

Output:

10

discussed above
Make a fair coin from a biased coin
You are given a function foo() that represents a biased coin. When foo() is called, it returns 0 with 60%
probability, and 1 with 40% probability. Write a new function that returns 0 and 1 with 50% probability each.
Your function should use only foo(), no other library method.
Solution:
We know foo() returns 0 with 60% probability. How can we ensure that 0 and 1 are returned with 50%
probability?
The solution is similar to this post. If we can somehow get two cases with equal probability, then we are
done. We call foo() two times. Both calls will return 0 with 60% probability. So the two pairs (0, 1) and (1, 0)
will be generated with equal probability from two calls of foo(). Let us see how.
(0, 1): The probability to get 0 followed by 1 from two calls of foo() = 0.6 * 0.4 = 0.24
(1, 0): The probability to get 1 followed by 0 from two calls of foo() = 0.4 * 0.6 = 0.24
So the two cases appear with equal probability. The idea is to return consider only the above two cases,
return 0 in one case, return 1 in other case. For other cases [(0, 0) and (1, 1)], recur until you end up in any
of the above two cases.
The below program depicts how we can use foo() to return 0 and 1 with equal probability.
#include <stdio.h>

int foo() // given method that returns 0 with 60% probability and 1 with 40%
{
// some code here
}
// returns both 0 and 1 with 50% probability

int my_fun()
{
int val1 = foo();
int val2 = foo();
if (val1 == 0 && val2 == 1)
return 0; // Will reach here with 0.24 probability
if (val1 == 1 && val2 == 0)
return 1; // // Will reach here with 0.24 probability
return my_fun(); // will reach here with (1 - 0.24 - 0.24) probability
}

int main()
{
printf ("%d ", my_fun());
return 0;
}

References:
http://en.wikipedia.org/wiki/Fair_coin#Fair_results_from_a_biased_coin
This article is compiled by Shashank Sinha and reviewed by GeeksforGeeks team. Please write comments
if you find anything incorrect, or you want to share more information about the topic discussed above.
If you like GeeksforGeeks and would like to contribute, you can also write an article and mail your article to
contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other
Geeks.
Find the row with maximum number of 1s
Given a boolean 2D array, where each row is sorted. Find the row with the maximum number of 1s.
Example
Input matrix
0 1 1 1
0 0 1 1
1 1 1 1 // this row has maximum 1s
0 0 0 0
Output: 2

A simple method is to do a row wise traversal of the matrix, count the number of 1s in each row and
compare the count with max. Finally, return the index of row with maximum 1s. The time complexity of this
method is O(m*n) where m is number of rows and n is number of columns in matrix.
We can do better. Since each row is sorted, we can use Binary Search to count of 1s in each row. We find
the index of first instance of 1 in each row. The count of 1s will be equal to total number of columns minus
the index of first 1.
See the following code for implementation of the above approach.
#include <stdio.h>
#define R 4
#define C 4
/* A function to find the index of first index of 1 in a boolean array arr[] */

int first(bool arr[], int low, int high)
{
if(high >= low)
{
// get the middle index
int mid = low + (high - low)/2;
// check if the element at middle index is first 1

if ( ( mid == 0 || arr[mid-1] == 0) && arr[mid] == 1)
return mid;
// if the element is 0, recur for right side

else if (arr[mid] == 0)
return first(arr, (mid + 1), high);
else // If element is not first 1, recur for left side

return first(arr, low, (mid -1));
}
return -1;
}
// The main function that returns index of row with maximum number of 1s.
int rowWithMax1s(bool mat[R][C])
{
int max_row_index = 0, max = -1; // Initialize max values
// Traverse for each row and count number of 1s by finding the index
// of first 1
int i, index;
for (i = 0; i < R; i++)
{
index = first (mat[i], 0, C-1);
if (index != -1 && C-index > max)
{
max = C - index;
max_row_index = i;
}
}
return max_row_index;
}

int main()
{
bool mat[R][C] = { {0, 0, 0, 1},
{0, 1, 1, 1},
{1, 1, 1, 1},
{0, 0, 0, 0}
};
printf("Index of row with maximum 1s is %d \n", rowWithMax1s(mat));
return 0;
}

Output:

Index of row with maximum 1s is 2

Time Complexity: O(mLogn) where m is number of rows and n is number of columns in matrix.
The above solution can be optimized further. Instead of doing binary search in every row, we first check
whether the row has more 1s than max so far. If the row has more 1s, then only count 1s in the row. Also, to
count 1s in a row, we don’t do binary search in complete row, we do search in before the index of last max.
Following is an optimized version of the above solution.

{
int i, index;
// Initialize max using values from first row.

int max_row_index = 0;
int max = C - first(mat[0], 0, C-1);
// Traverse for each row and count number of 1s by finding the index
// of first 1
for (i = 1; i < R; i++)
{
// Count 1s in this row only if this row has more 1s than
// max so far
if (mat[i][C-max-1] == 1)
{
// Note the optimization here also
index = first (mat[i], 0, C-max);
if (index != -1 && C-index > max)

{
max = C - index;
max_row_index = i;
}
}
}
}

The worst case time complexity of the above optimized version is also O(mLogn), the will solution work
better on average. Thanks to Naveen Kumar Singh for suggesting the above solution.
Sources: this and this
The worst case of the above solution occurs for a matrix like following.
0 0 0 … 0 1
0 0 0 ..0 1 1
0 … 0 1 1 1
….0 1 1 1 1
Following method works in O(m+n) time complexity in worst case .
Step1: Get the index of first (or leftmost) 1 in the first row.
Step2: Do following for every row after the first row

…IF the element on left of previous leftmost 1 is 0, ignore this row.
…ELSE Move left until a 0 is found. Update the leftmost index to this index and max_row_index to be the
current row.
The time complexity is O(m+n) because we can possibly go as far left as we came ahead in the first step.

{
// Initialize first row as row with max 1s
int max_row_index = 0;
// The function first() returns index of first 1 in row 0.

// Use this index to initialize the index of leftmost 1 seen so far
int j = first(mat[0], 0, C-1) - 1;
if (j == -1) // if 1 is not present in first row
j = C - 1;
for (int i = 1; i < R; i++)

{
// Move left until a 0 is found
while (j >= 0 && mat[i][j] == 1)
{
j = j-1; // Update the index of leftmost 1 seen so far
max_row_index = i; // Update max_row_index
}
}
}

Thanks to Tylor, Ankan and Palash for their inputs.
discussed above.
Dynamic Programming | Set 22 (Box Stacking Problem)
You are given a set of n types of rectangular 3-D boxes, where the i^th box has height h(i), width w(i) and
depth d(i) (all real numbers). You want to create a stack of boxes which is as tall as possible, but you can only
stack a box on top of another box if the dimensions of the 2-D base of the lower box are each strictly larger
than those of the 2-D base of the higher box. Of course, you can rotate a box so that any side functions as its
base. It is also allowable to use multiple instances of the same type of box.
Source: http://people.csail.mit.edu/bdean/6.046/dp/. The link also has video for explanation of solution.
The Box Stacking problem is a variation of LIS problem. We need to build a maximum height stack.
Following are the key points to note in the problem statement:

1) A box can be placed on top of another box only if both width and depth of the upper placed box are
smaller than width and depth of the lower box respectively.
2) We can rotate boxes. For example, if there is a box with dimensions {1x2x3} where 1 is height, 2×3 is base,
then there can be three possibilities, {1x2x3}, {2x1x3} and {3x1x2}.
3) We can use multiple instances of boxes. What it means is, we can have two different rotations of a box as
part of our maximum height stack.
Following is the solution based on DP solution of LIS problem.
1) Generate all 3 rotations of all boxes. The size of rotation array becomes 3 times the size of original array.
For simplicity, we consider depth as always smaller than or equal to width.
2) Sort the above generated 3n boxes in decreasing order of base area.
3) After sorting the boxes, the problem is same as LIS with following optimal substructure property.
MSH(i) = Maximum possible Stack Height with box i at top of stack
MSH(i) = { Max ( MSH(j) ) + height(i) } where j width(i) and depth(j) > depth(i).
If there is no such j then MSH(i) = height(i)
4) To get overall maximum height, we return max(MSH(i)) where 0 /* Dynamic Programming

implementation of Box Stacking problem */ #include<stdio.h> #include<stdlib.h> /* Representation of a
box */ struct Box { // h –> height, w –> width, d –> depth int h, w, d; // for simplicity of solution, always
keep w <= d }; // A utility function to get minimum of two intgers int min (int x, int y) { return (x < y)? x : y;
} // A utility function to get maximum of two intgers int max (int x, int y) { return (x > y)? x : y; } /*
Following function is needed for library function qsort(). We use qsort() to sort boxes in decreasing order of
base area. Refer following link for help of qsort() and compare()
http://www.cplusplus.com/reference/clibrary/cstdlib/qsort/ */ int compare (const void *a, const void * b) {
return ( (*(Box *)b).d * (*(Box *)b).w ) – ( (*(Box *)a).d * (*(Box *)a).w ); } /* Returns the height of the
tallest stack that can be formed with give type of boxes */ int maxStackHeight( Box arr[], int n ) { /* Create
an array of all rotations of given boxes For example, for a box {1, 2, 3}, we consider three instances{{1, 2, 3},
{2, 1, 3}, {3, 1, 2}} */ Box rot[3*n]; int index = 0; for (int i = 0; i < n; i++) { // Copy the original box
rot[index] = arr[i]; index++; // First rotation of box rot[index].h = arr[i].w; rot[index].d = max(arr[i].h,
arr[i].d); rot[index].w = min(arr[i].h, arr[i].d); index++; // Second rotation of box rot[index].h = arr[i].d;
rot[index].d = max(arr[i].h, arr[i].w); rot[index].w = min(arr[i].h, arr[i].w); index++; } // Now the number
of boxes is 3n n = 3*n; /* Sort the array ‘rot[]’ in decreasing order, using library function for quick sort */
qsort (rot, n, sizeof(rot[0]), compare); // Uncomment following two lines to print all rotations // for (int i =
0; i < n; i++ ) // printf("%d x %d x %d\n", rot[i].h, rot[i].w, rot[i].d); /* Initialize msh values for all indexes
msh[i] –> Maximum possible Stack Height with box i on top */ int msh[n]; for (int i = 0; i < n; i++ ) msh[i] =
rot[i].h; /* Compute optimized msh values in bottom up manner */ for (int i = 1; i < n; i++ ) for (int j = 0; j <
i; j++ ) if ( rot[i].w < rot[j].w && rot[i].d < rot[j].d && msh[i] < msh[j] + rot[i].h ) { msh[i] = msh[j] + rot[i].h;
} /* Pick maximum of all msh values */ int max = -1; for ( int i = 0; i < n; i++ ) if ( max < msh[i] ) max =
msh[i]; return max; } /* Driver program to test above function */ int main() { Box arr[] = { {4, 6, 7}, {1, 2, 3},
{4, 5, 6}, {10, 12, 32} }; int n = sizeof(arr)/sizeof(arr[0]); printf("The maximum possible height of stack is
%d\n", maxStackHeight (arr, n) ); return 0; }
Output:

The maximum possible height of stack is 60

In the above program, given input boxes are {4, 6, 7}, {1, 2, 3}, {4, 5, 6}, {10, 12, 32}. Following are all
rotations of the boxes in decreasing order of base area.
10 x 12 x 32
12 x 10 x 32
32 x 10 x 12
4 x 6 x 7
4 x 5 x 6
6 x 4 x 7
5 x 4 x 6
7 x 4 x 6
6 x 4 x 5
1 x 2 x 3
2 x 1 x 3
3 x 1 x 2

The height 60 is obtained by boxes { {3, 1, 2}, {1, 2, 3}, {6, 4, 5}, {4, 5, 6}, {4, 6, 7}, {32, 10, 12}, {10, 12,
32}}

discussed above.
Find the k most frequent words from a file
Given a book of words. Assume you have enough main memory to accommodate all words. design a data
structure to find top K maximum occurring words. The data structure should be dynamic so that new words
can be added.
A simple solution is to use Hashing. Hash all words one by one in a hash table. If a word is already
present, then increment its count. Finally, traverse through the hash table and return the k words with
maximum counts.
We can use Trie and Min Heap to get the k most frequent words efficiently. The idea is to use Trie for
searching existing words adding new words efficiently. Trie also stores count of occurrences of words. A Min
Heap of size k is used to keep track of k most frequent words at any point of time(Use of Min Heap is same as
we used it to find k largest elements in this post).
Trie and Min Heap are linked with each other by storing an additional field in Trie ‘indexMinHeap’ and a
pointer ‘trNode’ in Min Heap. The value of ‘indexMinHeap’ is maintained as -1 for the words which are
currently not in Min Heap (or currently not among the top k frequent words). For the words which are
present in Min Heap, ‘indexMinHeap’ contains, index of the word in Min Heap. The pointer ‘trNode’ in Min
Heap points to the leaf node corresponding to the word in Trie.
Following is the complete process to print k most frequent words from a file.
Read all words one by one. For every word, insert it into Trie. Increase the counter of the word, if already
exists. Now, we need to insert this word in min heap also. For insertion in min heap, 3 cases arise:
1. The word is already present. We just increase the corresponding frequency value in min heap and call
minHeapify() for the index obtained by “indexMinHeap” field in Trie. When the min heap nodes are being
swapped, we change the corresponding minHeapIndex in the Trie. Remember each node of the min heap is
also having pointer to Trie leaf node.
2. The minHeap is not full. we will insert the new word into min heap & update the root node in the min
heap node & min heap index in Trie leaf node. Now, call buildMinHeap().
3. The min heap is full. Two sub-cases arise.

….3.1 The frequency of the new word inserted is less than the frequency of the word stored in the head of
min heap. Do nothing.
….3.2 The frequency of the new word inserted is greater than the frequency of the word stored in the head of
min heap. Replace & update the fields. Make sure to update the corresponding min heap index of the “word
to be replaced” in Trie with -1 as the word is no longer in min heap.
4. Finally, Min Heap will have the k most frequent words of all words present in given file. So we just need to
print all words present in Min Heap.
// A program to find k most frequent words in a file

#include <stdio.h>
#include <string.h>
#include <ctype.h>
# define MAX_CHARS 26
# define MAX_WORD_SIZE 30
// A Trie node
struct TrieNode
{
bool isEnd; // indicates end of word
unsigned frequency; // the number of occurrences of a word
unsigned frequency; // the number of occurrences of a word
int indexMinHeap; // the index of the word in minHeap
TrieNode* child[MAX_CHARS]; // represents 26 slots each for 'a' to 'z'.
};
// A Min Heap node

struct MinHeapNode
{
TrieNode* root; // indicates the leaf node of TRIE
unsigned frequency; // number of occurrences
char* word; // the actual word stored
};
// A Min Heap
struct MinHeap
{
unsigned capacity; // the total size a min heap
int count; // indicates the number of slots filled.
MinHeapNode* array; // represents the collection of minHeapNodes
};
// A utility function to create a new Trie node

TrieNode* newTrieNode()
{
// Allocate memory for Trie Node
TrieNode* trieNode = new TrieNode;
// Initialize values for new node

trieNode->isEnd = 0;
trieNode->frequency = 0;
trieNode->indexMinHeap = -1;
for( int i = 0; i < MAX_CHARS; ++i )
trieNode->child[i] = NULL;
return trieNode;
}
// A utility function to create a Min Heap of given capacity

MinHeap* createMinHeap( int capacity )
{
MinHeap* minHeap = new MinHeap;
minHeap->capacity = capacity;
minHeap->count = 0;
// Allocate memory for array of min heap nodes

minHeap->array = new MinHeapNode [ minHeap->capacity ];
return minHeap;
}
// A utility function to swap two min heap nodes. This function

// is needed in minHeapify
void swapMinHeapNodes ( MinHeapNode* a, MinHeapNode* b )
{
MinHeapNode temp = *a;
*a = *b;
*b = temp;
}
// This is the standard minHeapify function. It does one thing extra.

// It updates the minHapIndex in Trie when two nodes are swapped in
// in min heap
void minHeapify( MinHeap* minHeap, int idx )
{
{
int left, right, smallest;
left = 2 * idx + 1;
right = 2 * idx + 2;
smallest = idx;
if ( left < minHeap->count &&
minHeap->array[ left ]. frequency <
minHeap->array[ smallest ]. frequency
)
smallest = left;
if ( right < minHeap->count &&

minHeap->array[ right ]. frequency <
minHeap->array[ smallest ]. frequency
)
smallest = right;
if( smallest != idx )

{
// Update the corresponding index in Trie node.
minHeap->array[ smallest ]. root->indexMinHeap = idx;
minHeap->array[ idx ]. root->indexMinHeap = smallest;
// Swap nodes in min heap

swapMinHeapNodes (&minHeap->array[ smallest ], &minHeap->array[ idx ]);
minHeapify( minHeap, smallest );

}
}
// A standard function to build a heap

void buildMinHeap( MinHeap* minHeap )
{
int n, i;
n = minHeap->count - 1;
for( i = ( n - 1 ) / 2; i >= 0; --i )

minHeapify( minHeap, i );
}
// Inserts a word to heap, the function handles the 3 cases explained above
void insertInMinHeap( MinHeap* minHeap, TrieNode** root, const char* word )
{
// Case 1: the word is already present in minHeap
if( (*root)->indexMinHeap != -1 )
{
++( minHeap->array[ (*root)->indexMinHeap ]. frequency );
// percolate down
minHeapify( minHeap, (*root)->indexMinHeap );
}
// Case 2: Word is not present and heap is not full

else if( minHeap->count < minHeap->capacity )
{
int count = minHeap->count;
minHeap->array[ count ]. frequency = (*root)->frequency;
minHeap->array[ count ]. word = new char [strlen( word ) + 1];
strcpy( minHeap->array[ count ]. word, word );
minHeap->array[ count ]. root = *root;

(*root)->indexMinHeap = minHeap->count;
++( minHeap->count );
++( minHeap->count );
buildMinHeap( minHeap );
}
// Case 3: Word is not present and heap is full. And frequency of word
// is more than root. The root is the least frequent word in heap,
// replace root with new word
else if ( (*root)->frequency > minHeap->array[0]. frequency )
{
minHeap->array[ 0 ]. root->indexMinHeap = -1;

minHeap->array[ 0 ]. root = *root;
minHeap->array[ 0 ]. root->indexMinHeap = 0;
minHeap->array[ 0 ]. frequency = (*root)->frequency;
// delete previously allocated memoory and

delete [] minHeap->array[ 0 ]. word;
minHeap->array[ 0 ]. word = new char [strlen( word ) + 1];
strcpy( minHeap->array[ 0 ]. word, word );
minHeapify ( minHeap, 0 );
}
}
// Inserts a new word to both Trie and Heap

void insertUtil ( TrieNode** root, MinHeap* minHeap,
const char* word, const char* dupWord )
{
// Base Case
if ( *root == NULL )
*root = newTrieNode();
// There are still more characters in word

if ( *word != '\0' )
insertUtil ( &((*root)->child[ tolower( *word ) - 97 ]),
minHeap, word + 1, dupWord );
else // The complete word is processed
{
// word is already present, increase the frequency
if ( (*root)->isEnd )
++( (*root)->frequency );
else
{
(*root)->isEnd = 1;
(*root)->frequency = 1;
}
// Insert in min heap also

insertInMinHeap( minHeap, root, dupWord );
}
}
// add a word to Trie & min heap. A wrapper over the insertUtil
void insertTrieAndHeap(const char *word, TrieNode** root, MinHeap* minHeap)
{
insertUtil( root, minHeap, word, word );
}
// A utility function to show results, The min heap

// contains k most frequent words so far, at any time
void displayMinHeap( MinHeap* minHeap )
{
int i;
// print top K word with frequency
for( i = 0; i < minHeap->count; ++i )
{
printf( "%s : %d\n", minHeap->array[i].word,
minHeap->array[i].frequency );
}
}
// The main funtion that takes a file as input, add words to heap
// and Trie, finally shows result from heap
void printKMostFreq( FILE* fp, int k )
{
// Create a Min Heap of Size k
MinHeap* minHeap = createMinHeap( k );

// Create an empty Trie
TrieNode* root = NULL;
// A buffer to store one word at a time

char buffer[MAX_WORD_SIZE];
// Read words one by one from file. Insert the word in Trie and Min Heap
while( fscanf( fp, "%s", buffer ) != EOF )
insertTrieAndHeap(buffer, &root, minHeap);
// The Min Heap will have the k most frequent words, so print Min Heap nodes
displayMinHeap( minHeap );
}

int main()
{
int k = 5;
FILE *fp = fopen ("file.txt", "r");
if (fp == NULL)
printf ("File doesn't exist ");
else
printKMostFreq (fp, k);
return 0;
}

Output:

your : 3
well : 3
and : 4
to : 4
Geeks : 6

The above output is for a file with following content.

Welcome to the world of Geeks
This portal has been created to provide well written well thought and well explained
solutions for selected questions If you like Geeks for Geeks and would like to
contribute
here is your chance You can write article and mail your article to contribute at
geeksforgeeks org See your article appearing on the Geeks for Geeks main page and help
thousands of other Geeks

discussed above.
Sort numbers stored on different machines
Given N machines. Each machine contains some numbers in sorted form. But the amount of numbers, each
machine has is not fixed. Output the numbers from all the machine in sorted non-decreasing form.
Example:
Machine M1 contains 3 numbers: {30, 40, 50}
Machine M2 contains 2 numbers: {35, 45}
Machine M3 contains 5 numbers: {10, 60, 70, 80, 100}

Output: {10, 30, 35, 40, 45, 50, 60, 70, 80, 100}

Representation of stream of numbers on each machine is considered as linked list. A Min Heap can be used
to print all numbers in sorted order.
Following is the detailed process
1. Store the head pointers of the linked lists in a minHeap of size N where N is number of machines.
2. Extract the minimum item from the minHeap. Update the minHeap by replacing the head of the minHeap
with the next number from the linked list or by replacing the head of the minHeap with the last number in
the minHeap followed by decreasing the size of heap by 1.
3. Repeat the above step 2 until heap is not empty.
Below is C++ implementation of the above approach.
// A program to take numbers from different machines and print them in sorted order
#include <stdio.h>
// A Linked List node

struct ListNode
{
int data;
struct ListNode* next;
};
// A Min Heap Node

struct MinHeapNode
{
ListNode* head;
};
// A Min Heao (Collection of Min Heap nodes)

struct MinHeap
{
int count;
int capacity;
MinHeapNode* array;
};
// A function to create a Min Heap of given capacity

MinHeap* createMinHeap( int capacity )
{
MinHeap* minHeap = new MinHeap;
minHeap->count = 0;
minHeap->count = 0;
minHeap->array = new MinHeapNode [minHeap->capacity];
return minHeap;
}
/* A utility function to insert a new node at the begining

of linked list */
void push (ListNode** head_ref, int new_data)
{
/* allocate node */
ListNode* new_node = new ListNode;



}
// A utility function to swap two min heap nodes. This function

// is needed in minHeapify
void swap( MinHeapNode* a, MinHeapNode* b )
{
MinHeapNode temp = *a;
*a = *b;
*b = temp;
}
// The standard minHeapify function.

void minHeapify( MinHeap* minHeap, int idx )
{
int left, right, smallest;
left = 2 * idx + 1;
smallest = idx;
if ( left < minHeap->count &&

minHeap->array[left].head->data <
minHeap->array[smallest].head->data
)
smallest = left;
if ( right < minHeap->count &&

minHeap->array[right].head->data <
minHeap->array[smallest].head->data
)
smallest = right;
if( smallest != idx )

{
swap( &minHeap->array[smallest], &minHeap->array[idx] );
minHeapify( minHeap, smallest );
}
}
// A utility function to check whether a Min Heap is empty or not

int isEmpty( MinHeap* minHeap )
{
return (minHeap->count == 0);
}

void buildMinHeap( MinHeap* minHeap )
{
int i, n;
n = minHeap->count - 1;
for( i = (n - 1) / 2; i >= 0; --i )
minHeapify( minHeap, i );
}
// This function inserts array elements to heap and then calls

// buildHeap for heap property among nodes
void populateMinHeap( MinHeap* minHeap, ListNode* *array, int n )
{
for( int i = 0; i < n; ++i )
minHeap->array[ minHeap->count++ ].head = array[i];
buildMinHeap( minHeap );
}
// Return minimum element from all linked lists

ListNode* extractMin( MinHeap* minHeap )
{
if( isEmpty( minHeap ) )
return NULL;
// The root of heap will have minimum value

MinHeapNode temp = minHeap->array[0];
// Replace root either with next node of the same list.

if( temp.head->next )
minHeap->array[0].head = temp.head->next;
else // If list empty, then reduce heap size
{
minHeap->array[0] = minHeap->array[ minHeap->count - 1 ];
--minHeap->count;
}
minHeapify( minHeap, 0 );
return temp.head;
}
// The main function that takes an array of lists from N machines

// and generates the sorted output
void externalSort( ListNode *array[], int N )
{
// Create a min heap of size equal to number of machines
MinHeap* minHeap = createMinHeap( N );
// populate first item from all machines

populateMinHeap( minHeap, array, N );
while ( !isEmpty( minHeap ) )

{
ListNode* temp = extractMin( minHeap );
printf( "%d ",temp->data );
}
}

int main()
{
int N = 3; // Number of machines
// an array of pointers storing the head nodes of the linked lists

ListNode *array[N];
// Create a Linked List 30->40->50 for first machine

array[0] = NULL;
push (&array[0], 50);
// Create a Linked List 35->45 for second machine

array[1] = NULL;
// Create Linked List 10->60->70->80 for third machine

array[2] = NULL;
// Sort all elements

externalSort( array, N );
return 0;
}

Output:

10 30 35 40 45 50 60 70 80 100

discussed above.
Implement LRU Cache
How to implement LRU caching scheme? What data structures should be used?
We are given total possible page numbers that can be referred. We are also given cache (or memory) size
(Number of page frames that cache can hold at a time). The LRU caching scheme is to remove the least
recently used frame when the cache is full and a new page is referenced which is not there in cache. Please
see the Galvin book for more details (see the LRU page replacement slide here).
We use two data structures to implement an LRU Cache.
1. A Queue which is implemented using a doubly linked list. The maximum size of the queue will be equal to
the total number of frames available (cache size).
The most recently used pages will be near front end and least recently pages will be near rear end.
2. A Hash with page number as key and address of the corresponding queue node as value.
When a page is referenced, the required page may be in the memory. If it is in the memory, we need to
detach the node of the list and bring it to the front of the queue.
If the required page is not in the memory, we bring that in memory. In simple words, we add a new node to
the front of the queue and update the corresponding node address in the hash. If the queue is full, i.e. all the
frames are full, we remove a node from the rear of queue, and add the new node to the front of queue.
Note: Initially no page is in the memory.
Below is C implementation:
// A C program to show implementation of LRU cache

#include <stdio.h>
#include <stdlib.h>
// A Queue Node (Queue is implemented using Doubly Linked List)

typedef struct QNode
{
struct QNode *prev, *next;
unsigned pageNumber; // the page number stored in this QNode
} QNode;
// A Queue (A FIFO collection of Queue Nodes)

typedef struct Queue
{
unsigned count; // Number of filled frames
unsigned numberOfFrames; // total number of frames
QNode *front, *rear;
} Queue;
// A hash (Collection of pointers to Queue Nodes)

typedef struct Hash
{
int capacity; // how many pages can be there
QNode* *array; // an array of queue nodes
} Hash;
// A utility function to create a new Queue Node. The queue Node

// will store the given 'pageNumber'
QNode* newQNode( unsigned pageNumber )
{
// Allocate memory and assign 'pageNumber'
QNode* temp = (QNode *)malloc( sizeof( QNode ) );
temp->pageNumber = pageNumber;
temp->pageNumber = pageNumber;
// Initialize prev and next as NULL

temp->prev = temp->next = NULL;
return temp;
}
// A utility function to create an empty Queue.

// The queue can have at most 'numberOfFrames' nodes
Queue* createQueue( int numberOfFrames )
{
Queue* queue = (Queue *)malloc( sizeof( Queue ) );
// The queue is empty

queue->count = 0;
queue->front = queue->rear = NULL;
// Number of frames that can be stored in memory

queue->numberOfFrames = numberOfFrames;
return queue;
}
// A utility function to create an empty Hash of given capacity

Hash* createHash( int capacity )
{
// Allocate memory for hash
Hash* hash = (Hash *) malloc( sizeof( Hash ) );
hash->capacity = capacity;
// Create an array of pointers for refering queue nodes

hash->array = (QNode **) malloc( hash->capacity * sizeof( QNode* ) );
// Initialize all hash entries as empty

int i;
for( i = 0; i < hash->capacity; ++i )
hash->array[i] = NULL;
return hash;
}
// A function to check if there is slot available in memory

int AreAllFramesFull( Queue* queue )
{
return queue->count == queue->numberOfFrames;
}
// A utility function to check if queue is empty

int isQueueEmpty( Queue* queue )
{
return queue->rear == NULL;
}
// A utility function to delete a frame from queue

void deQueue( Queue* queue )
{
if( isQueueEmpty( queue ) )
return;
// If this is the only node in list, then change front

if (queue->front == queue->rear)
queue->front = NULL;
// Change rear and remove the previous rear

// Change rear and remove the previous rear
QNode* temp = queue->rear;
queue->rear = queue->rear->prev;
if (queue->rear)
queue->rear->next = NULL;
free( temp );
// decrement the number of full frames by 1

queue->count--;
}
// A function to add a page with given 'pageNumber' to both queue

// and hash
void Enqueue( Queue* queue, Hash* hash, unsigned pageNumber )
{
// If all frames are full, remove the page at the rear
if ( AreAllFramesFull ( queue ) )
{
// remove page from hash
hash->array[ queue->rear->pageNumber ] = NULL;
deQueue( queue );
}
// Create a new node with given page number,

// And add the new node to the front of queue
QNode* temp = newQNode( pageNumber );
temp->next = queue->front;
// If queue is empty, change both front and rear pointers

if ( isQueueEmpty( queue ) )
queue->rear = queue->front = temp;
else // Else change the front
{
queue->front->prev = temp;
queue->front = temp;
}
// Add page entry to hash also

hash->array[ pageNumber ] = temp;
// increment number of full frames

queue->count++;
}
// This function is called when a page with given 'pageNumber' is referenced

// from cache (or memory). There are two cases:
// 1. Frame is not there in memory, we bring it in memory and add to the front
// of queue
// 2. Frame is there in memory, we move the frame to front of queue
void ReferencePage( Queue* queue, Hash* hash, unsigned pageNumber )
{
QNode* reqPage = hash->array[ pageNumber ];
// the page is not in cache, bring it

if ( reqPage == NULL )
Enqueue( queue, hash, pageNumber );
// page is there and not at front, change pointer

else if (reqPage != queue->front)
{
// Unlink rquested page from its current location
// in queue.
reqPage->prev->next = reqPage->next;
reqPage->prev->next = reqPage->next;
if (reqPage->next)
reqPage->next->prev = reqPage->prev;
// If the requested page is rear, then change rear

// as this node will be moved to front
if (reqPage == queue->rear)
{
queue->rear = reqPage->prev;
queue->rear->next = NULL;
}
// Put the requested page before current front

reqPage->next = queue->front;
reqPage->prev = NULL;
// Change prev of current front

reqPage->next->prev = reqPage;
// Change front to the requested page

queue->front = reqPage;
}
}

int main()
{
// Let cache can hold 4 pages
Queue* q = createQueue( 4 );
// Let 10 different pages can be requested (pages to be

// referenced are numbered from 0 to 9
Hash* hash = createHash( 10 );
// Let us refer pages 1, 2, 3, 1, 4, 5

ReferencePage( q, hash, 1);
// Let us print cache frames after the above referenced pages

printf ("%d ", q->front->pageNumber);
printf ("%d ", q->front->next->pageNumber);
printf ("%d ", q->front->next->next->pageNumber);
printf ("%d ", q->front->next->next->next->pageNumber);
return 0;
}

Output:

5 4 1 3

This article is compiled by Aashish Barnwal and reviewed by GeeksforGeeks team. Please write comments if
you find anything incorrect, or you want to share more information about the topic discussed above.
Print unique rows in a given boolean matrix
Given a binary matrix, print all unique rows of the given matrix.
Input:
{0, 1, 0, 0, 1}
{1, 0, 1, 1, 0}
{0, 1, 0, 0, 1}
{1, 1, 1, 0, 0}
Output:
0 1 0 0 1
1 0 1 1 0
1 1 1 0 0

Method 1 (Simple)
A simple approach is to check each row with all processed rows. Print the first row. Now, starting from the
second row, for each row, compare the row with already processed rows. If the row matches with any of the
processed rows, don’t print it. If the current row doesn’t match with any row, print it.
Time complexity: O( ROW^2 x COL )

Auxiliary Space: O( 1 )
Method 2 (Use Binary Search Tree)

Find the decimal equivalent of each row and insert it into BST. Each node of the BST will contain two fields,
one field for the decimal value, other for row number. Do not insert a node if it is duplicated. Finally,
traverse the BST and print the corresponding rows.
Time complexity: O( ROW x COL + ROW x log( ROW ) )

Auxiliary Space: O( ROW )
This method will lead to Integer Overflow if number of columns is large.
Method 3 (Use Trie data structure)

Since the matrix is boolean, a variant of Trie data structure can be used where each node will be having two
children one for 0 and other for 1. Insert each row in the Trie. If the row is already there, don’t print the row.
If row is not there in Trie, insert it in Trie and print it.
Below is C implementation of method 3.
//Given a binary matrix of M X N of integers, you need to return only unique rows of bin
ary array
#include <stdio.h>
#include <stdlib.h>
#define ROW 4
#define COL 5
// A Trie node
typedef struct Node
{
bool isEndOfCol;
struct Node *child[2]; // Only two children needed for 0 and 1
} Node;
// A utility function to allocate memory for a new Trie node
Node* newNode()
{
Node* temp = (Node *)malloc( sizeof( Node ) );
temp->isEndOfCol = 0;
temp->child[0] = temp->child[1] = NULL;
return temp;
}
// Inserts a new matrix row to Trie. If row is already

// present, then returns 0, otherwise insets the row and
// return 1
bool insert( Node** root, int (*M)[COL], int row, int col )
{
// base case
if ( *root == NULL )
*root = newNode();
// Recur if there are more entries in this row

if ( col < COL )
return insert ( &( (*root)->child[ M[row][col] ] ), M, row, col+1 );
else // If all entries of this row are processed

{
// unique row found, return 1
if ( !( (*root)->isEndOfCol ) )
return (*root)->isEndOfCol = 1;
// duplicate row found, return 0

return 0;
}
}
// A utility function to print a row

void printRow( int (*M)[COL], int row )
{
int i;
for( i = 0; i < COL; ++i )
printf( "%d ", M[row][i] );
printf("\n");
}
// The main function that prints all unique rows in a

// given matrix.
void findUniqueRows( int (*M)[COL] )
{
Node* root = NULL; // create an empty Trie
int i;
// Iterate through all rows

for ( i = 0; i < ROW; ++i )
// insert row to TRIE
if ( insert(&root, M, i, 0) )
// unique row found, print it
printRow( M, i );
}

int main()
{
int M[ROW][COL] = {{0, 1, 0, 0, 1},
{1, 0, 1, 1, 0},
{0, 1, 0, 0, 1},
{0, 1, 0, 0, 1},
{1, 0, 1, 0, 0}
};
findUniqueRows( M );
return 0;
}

Time complexity: O( ROW x COL )

Auxiliary Space: O( ROW x COL )
This method has better time complexity. Also, relative order of rows is maintained while printing.
discussed above.
Median of two sorted arrays of different sizes
This is an extension of median of two sorted arrays of equal size problem. Here we handle arrays of unequal
size also.
The approach discussed in this post is similar to method 2 of equal size post. The basic idea is same, we find
the median of two arrays and compare the medians to discard almost half of the elements in both arrays.
Since the number of elements may differ here, there are many base cases that need to be handled separately.
Before we proceed to complete solution, let us first talk about all base cases.
Let the two arrays be A[N] and B[M]. In the following explanation, it is assumed that N is smaller than or
equal to M.
Base cases:
The smaller array has only one element
Case 1: N = 1, M = 1.
Case 2: N = 1, M is odd
Case 3: N = 1, M is even
The smaller array has only two elements
Case 4: N = 2, M = 2
Case 1: There is only one element in both arrays, so output the average of A[0] and B[0].
Let B[5] = {5, 10, 12, 15, 20}
First find the middle element of B[], which is 12 for above array. There are following 4 sub-cases.
…2.1 If A[0] is smaller than 10, the median is average of 10 and 12.
…2.2 If A[0] lies between 10 and 12, the median is average of A[0] and 12.
…2.3 If A[0] lies between 12 and 15, the median is average of 12 and A[0].
…2.4 If A[0] is greater than 15, the median is average of 12 and 15.
In all the sub-cases, we find that 12 is fixed. So, we need to find the median of B[ M / 2 – 1 ], B[ M / 2 + 1], A[
0 ] and take its average with B[ M / 2 ].
Let B[4] = {5, 10, 12, 15}
First find the middle items in B[], which are 10 and 12 in above example. There are following 3 sub-cases.
…3.1 If A[0] is smaller than 10, the median is 10.
…3.2 If A[0] lies between 10 and 12, the median is A[0].
…3.3 If A[0] is greater than 10, the median is 12.
So, in this case, find the median of three elements B[ M / 2 – 1 ], B[ M / 2] and A[ 0 ].
Case 4: N = 2, M = 2
There are four elements in total. So we find the median of 4 elements.
Let B[5] = {5, 10, 12, 15, 20}
The median is given by median of following three elements: B[M/2], max(A[0], B[M/2 – 1]), min(A[1],
B[M/2 + 1]).
Let B[4] = {5, 10, 12, 15}
The median is given by median of following four elements: B[M/2], B[M/2 – 1], max(A[0], B[M/2 – 2]),
min(A[1], B[M/2 + 1])
Remaining Cases:
Once we have handled the above base cases, following is the remaining process.
1) Find the middle item of A[] and middle item of B[].
…..1.1) If the middle item of A[] is greater than middle item of B[], ignore the last half of A[], let length of
ignored part is idx. Also, cut down B[] by idx from the start.
…..1.2) else, ignore the first half of A[], let length of ignored part is idx. Also, cut down B[] by idx from the
last.
// A C program to find median of two sorted arrays of unequal size

#include <stdio.h>
#include <stdlib.h>
// A utility function to find maximum of two integers

int max( int a, int b )
{ return a > b ? a : b; }
// A utility function to find minimum of two integers

int min( int a, int b )
{ return a < b ? a : b; }
// A utility function to find median of two integers

float MO2( int a, int b )
{ return ( a + b ) / 2.0; }
// A utility function to find median of three integers

float MO3( int a, int b, int c )
{
return a + b + c - max( a, max( b, c ) )
- min( a, min( b, c ) );
}
// A utility function to find median of four integers

float MO4( int a, int b, int c, int d )
{
int Max = max( a, max( b, max( c, d ) ) );
int Min = min( a, min( b, min( c, d ) ) );
return ( a + b + c + d - Max - Min ) / 2.0;
}
// This function assumes that N is smaller than or equal to M

float findMedianUtil( int A[], int N, int B[], int M )
{
// If the smaller array has only one element
if( N == 1 )
{
// Case 1: If the larger array also has one element, simply call MO2()
if( M == 1 )
return MO2( A[0], B[0] );
// Case 2: If the larger array has odd number of elements, then consider
// the middle 3 elements of larger array and the only element of
// smaller array. Take few examples like following
// A = {9}, B[] = {5, 8, 10, 20, 30} and
// A[] = {1}, B[] = {5, 8, 10, 20, 30}
if( M & 1 )
return MO2( B[M/2], MO3(A[0], B[M/2 - 1], B[M/2 + 1]) );
// Case 3: If the larger array has even number of element, then median
// Case 3: If the larger array has even number of element, then median
// will be one of the following 3 elements
// ... The middle two elements of larger array
// ... The only element of smaller array
return MO3( B[M/2], B[M/2 - 1], A[0] );
}
// If the smaller array has two elements

else if( N == 2 )
{
// Case 4: If the larger array also has two elements, simply call MO4()
if( M == 2 )
return MO4( A[0], A[1], B[0], B[1] );
// Case 5: If the larger array has odd number of elements, then median
// will be one of the following 3 elements
// 1. Middle element of larger array
// 2. Max of first element of smaller array and element just
// before the middle in bigger array
// 3. Min of second element of smaller array and element just
// after the middle in bigger array
if( M & 1 )
return MO3 ( B[M/2],
max( A[0], B[M/2 - 1] ),
min( A[1], B[M/2 + 1] )
);
// Case 6: If the larger array has even number of elements, then

// median will be one of the following 4 elements
// 1) & 2) The middle two elements of larger array
// 3) Max of first element of smaller array and element
// just before the first middle element in bigger array
// 4. Min of second element of smaller array and element
// just after the second middle in bigger array
return MO4 ( B[M/2],
B[M/2 - 1],
max( A[0], B[M/2 - 2] ),
min( A[1], B[M/2 + 1] )
);
}
int idxA = ( N - 1 ) / 2;
int idxB = ( M - 1 ) / 2;
/* if A[idxA] <= B[idxB], then median must exist in

A[idxA....] and B[....idxB] */
if( A[idxA] <= B[idxB] )
return findMedianUtil( A + idxA, N / 2 + 1, B, M - idxA );
/* if A[idxA] > B[idxB], then median must exist in

A[...idxA] and B[idxB....] */
return findMedianUtil( A, N / 2 + 1, B + idxA, M - idxA );
}
// A wrapper function around findMedianUtil(). This function makes

// sure that smaller array is passed as first argument to findMedianUtil
float findMedian( int A[], int N, int B[], int M )
{
if ( N > M )
return findMedianUtil( B, M, A, N );
return findMedianUtil( A, N, B, M );
}

int main()
{
int A[] = {900};
int B[] = {5, 8, 10, 20};
int N = sizeof(A) / sizeof(A[0]);

int M = sizeof(B) / sizeof(B[0]);
printf( "%f", findMedian( A, N, B, M ) );

return 0;
}

Output:

10

Time Complexity: O(LogM + LogN)
discussed above.
Flattening a Linked List
Given a linked list where every node represents a linked list and contains two pointers of its type:
(i) Pointer to next node in the main list (we call it ‘right’ pointer in below code)
(ii) Pointer to a linked list where this node is head (we call it ‘down’ pointer in below code).
All linked lists are sorted. See the following example
5 -> 10 -> 19 -> 28

| | | |
V V V V
7 20 22 35
| | |
V V V
8 50 40
| |
V V
30 45

Write a function flatten() to flatten the lists into a single linked list. The flattened linked list should also be
sorted. For example, for the above input list, output list should be 5->7->8->10->19->20->22->28->30-
>35->40->45->50.
The idea is to use Merge() process of merge sort for linked lists. We use merge() to merge lists one by one.
We recursively merge() the current list with already flattened list.
The down pointer is used to link nodes of the flattened list.
Following is C implementation.
#include <stdio.h>
#include <stdlib.h>
// A Linked List Node

typedef struct Node
{
int data;
struct Node *right;
struct Node *down;
} Node;
/* A utility function to insert a new node at the begining

of linked list */
void push (Node** head_ref, int new_data)
{
/* allocate node */
Node* new_node = (Node *) malloc(sizeof(Node));


new_node->down = (*head_ref);

}
}
/* Function to print nodes in the flattened linked list */

void printList(Node *node)
{
while(node != NULL)
{
node = node->down;
}
}
// A utility function to merge two sorted linked lists

Node* merge( Node* a, Node* b )
{
// If first list is empty, the second list is result
if (a == NULL)
return b;
// If second list is empty, the second list is result

if (b == NULL)
return a;
// Compare the data members of head nodes of both lists

// and put the smaller one in result
Node* result;
if( a->data < b->data )
{
result = a;
result->down = merge( a->down, b );
}
else
{
result = b;
result->down = merge( a, b->down );
}
return result;
}
// The main function that flattens a given linked list

Node* flatten (Node* root)
{
// Base cases
if ( root == NULL || root->right == NULL )
return root;
// Merge this list with the list on right side

return merge( root, flatten(root->right) );
}

int main()
{
Node* root = NULL;
/* Let us create the following linked list

5 -> 10 -> 19 -> 28
| | | |
V V V V
7 20 22 35
| | |
V V V
8 50 40
| |
V V
30 45
*/
push( &root, 30 );
push( &root, 8 );
push( &root, 7 );
push( &root, 5 );
push( &( root->right ), 20 );

push( &( root->right ), 10 );
push( &( root->right->right ), 50 );

push( &( root->right->right->right ), 45 );

// Let us flatten the list

root = flatten(root);
// Let us print the flatened linked list

printList(root);
return 0;
}

Output:

5 7 8 10 19 20 20 22 30 35 40 45 50

discussed above.
Check divisibility by 7
Given a number, check if it is divisible by 7. You are not allowed to use modulo operator, floating point
arithmetic is also not allowed.
A simple method is repeated subtraction. Following is another interesting method.
Divisibility by 7 can be checked by a recursive method. A number of the form 10a + b is divisible by 7 if and
only if a – 2b is divisible by 7. In other words, subtract twice the last digit from the number formed by the
remaining digits. Continue to do this until a small number.
Example: the number 371: 37 – (2×1) = 37 – 2 = 35; 3 – (2 × 5) = 3 – 10 = -7; thus, since -7 is divisible by 7,
371 is divisible by 7.
Following is C implementation of the above method
// A Program to check whether a number is divisible by 7

#include <stdio.h>
int isDivisibleBy7( int num )

{
// If number is negative, make it positive
if( num < 0 )
return isDivisibleBy7( -num );
// Base cases
if( num == 0 || num == 7 )
return 1;
if( num < 10 )
return 0;
// Recur for ( num / 10 - 2 * num % 10 )

return isDivisibleBy7( num / 10 - 2 * ( num - num / 10 * 10 ) );
}

int main()
{
int num = 616;
if( isDivisibleBy7(num ) )
printf( "Divisible" );
else
printf( "Not Divisible" );
return 0;
}

Output:

Divisible

How does this work? Let ‘b’ be the last digit of a number ‘n’ and let ‘a’ be the number we get when we split
off ‘b’.
The representation of the number may also be multiplied by any number relatively prime to the divisor
without changing its divisibility. After observing that 7 divides 21, we can perform the following:

10.a + b

after multiplying by 2, this becomes

20.a + 2.b

and then

21.a - a + 2.b

Eliminating the multiple of 21 gives

-a + 2b

and multiplying by -1 gives

a - 2b

There are other interesting methods to check divisibility by 7 and other numbers. See following Wiki page for
details.
References:
http://en.wikipedia.org/wiki/Divisibility_rule
discussed above.
Find the largest multiple of 3
Given an array of non-negative integers. Find the largest multiple of 3 that can be formed from array
elements.
For example, if the input array is {8, 1, 9}, the output should be “9 8 1″, and if the input array is {8, 1, 7, 6,
0}, output should be “8 7 6 0″.
Method 1 (Brute Force)

The simple & straight forward approach is to generate all the combinations of the elements and keep track of
the largest number formed which is divisible by 3.
Time Complexity: O(n x 2^n). There will be 2^n combinations of array elements. To compare each
combination with the largest number so far may take O(n) time.
Auxiliary Space: O(n) // to avoid integer overflow, the largest number is assumed to be stored in the form of
array.
Method 2 (Tricky)
This problem can be solved efficiently with the help of O(n) extra space. This method is based on the
following facts about numbers which are multiple of 3.
1) A number is multiple of 3 if and only if the sum of digits of number is multiple of 3. For example, let us
consider 8760, it is a multiple of 3 because sum of digits is 8 + 7+ 6+ 0 = 21, which is a multiple of 3.
2) If a number is multiple of 3, then all permutations of it are also multiple of 3. For example, since 6078 is a
multiple of 3, the numbers 8760, 7608, 7068, ….. are also multiples of 3.
3) We get the same remainder when we divide the number and sum of digits of the number. For example, if
divide number 151 and sum of it digits 7, by 3, we get the same remainder 1.
What is the idea behind above facts?

The value of 10%3 and 100%3 is 1. The same is true for all the higher powers of 10, because 3 divides 9, 99,
999, … etc.
Let us consider a 3 digit number n to prove above facts. Let the first, second and third digits of n be ‘a’, ‘b’
and ‘c’ respectively. n can be written as
n = 100.a + 10.b + c

Since (10^x)%3 is 1 for any x, the above expression gives the same remainder as following expression
1.a + 1.b + c

So the remainder obtained by sum of digits and ‘n’ is same.
Following is a solution based on the above observation.
1. Sort the array in non-decreasing order.
2. Take three queues. One for storing elements which on dividing by 3 gives remainder as 0.The second
queue stores digits which on dividing by 3 gives remainder as 1. The third queue stores digits which on
dividing by 3 gives remainder as 2. Call them as queue0, queue1 and queue2
3. Find the sum of all the digits.
4. Three cases arise:

……4.1 The sum of digits is divisible by 3. Dequeue all the digits from the three queues. Sort them in non-
increasing order. Output the array.
……4.2 The sum of digits produces remainder 1 when divided by 3.

Remove one item from queue1. If queue1 is empty, remove two items from queue2. If queue2 contains less
than two items, the number is not possible.
……4.3 The sum of digits produces remainder 2 when divided by 3.

Remove one item from queue2. If queue2 is empty, remove two items from queue1. If queue1 contains less
than two items, the number is not possible.
5. Finally empty all the queues into an auxiliary array. Sort the auxiliary array in non-increasing order.
Output the auxiliary array.
Based on the above, below is the implementation:
/* A program to find the largest multiple of 3 from an array of elements */

#include <stdio.h>
#include <stdlib.h>
// A queue node
typedef struct Queue
{
int front;
int rear;
int capacity;
int* array;
} Queue;
// A utility function to create a queue with given capacity

Queue* createQueue( int capacity )
{
Queue* queue = (Queue *) malloc (sizeof(Queue));
queue->capacity = capacity;
queue->front = queue->rear = -1;
queue->array = (int *) malloc (queue->capacity * sizeof(int));
return queue;
}
// A utility function to check if queue is empty

int isEmpty (Queue* queue)
{
return queue->front == -1;
}
// A function to add an item to queue

void Enqueue (Queue* queue, int item)
{
queue->array[ ++queue->rear ] = item;
if ( isEmpty(queue) )
++queue->front;
}
// A function to remove an item from queue

int Dequeue (Queue* queue)
{
int item = queue->array[ queue->front ];
if( queue->front == queue->rear )
else
queue->front++;
return item;
}
// A utility function to print array contents

void printArr (int* arr, int size)
{
int i;
for (i = 0; i< size; ++i)
printf ("%d ", arr[i]);
}
/* Following two functions are needed for library function qsort().

Refer following link for help of qsort()
int compareAsc( const void* a, const void* b )
{
return *(int*)a > *(int*)b;
}
int compareDesc( const void* a, const void* b )
{
return *(int*)a < *(int*)b;
}
// This function puts all elements of 3 queues in the auxiliary array

void populateAux (int* aux, Queue* queue0, Queue* queue1,
Queue* queue2, int* top )
{
// Put all items of first queue in aux[]
while ( !isEmpty(queue0) )
aux[ (*top)++ ] = Dequeue( queue0 );
// Put all items of second queue in aux[]

// Put all items of third queue in aux[]

}
// The main function that finds the largest possible multiple of

// 3 that can be formed by arr[] elements
int findMaxMultupleOf3( int* arr, int size )
{
// Step 1: sort the array in non-decreasing order
qsort( arr, size, sizeof( int ), compareAsc );
// Create 3 queues to store numbers with remainder 0, 1

// and 2 respectively
Queue* queue0 = createQueue( size );
// Step 2 and 3 get the sum of numbers and place them in

// corresponding queues
int i, sum;
for ( i = 0, sum = 0; i < size; ++i )
{
sum += arr[i];
if ( (arr[i] % 3) == 0 )
Enqueue( queue0, arr[i] );
else if ( (arr[i] % 3) == 1 )
else
}
// Step 4.2: The sum produces remainder 1

if ( (sum % 3) == 1 )
{
// either remove one item from queue1
if ( !isEmpty( queue1 ) )
Dequeue( queue1 );
// or remove two items from queue2

else
{
Dequeue( queue2 );
else
return 0;
Dequeue( queue2 );
else
return 0;
}
}
// Step 4.3: The sum produces remainder 2

else if ((sum % 3) == 2)
{
// either remove one item from queue2
Dequeue( queue2 );
// or remove two items from queue1

else
{
Dequeue( queue1 );
else
return 0;
Dequeue( queue1 );
else
return 0;
}
}
int aux[size], top = 0;
// Empty all the queues into an auxiliary array.

populateAux (aux, queue0, queue1, queue2, &top);
// sort the array in non-increasing order

qsort (aux, top, sizeof( int ), compareDesc);
// print the result

printArr (aux, top);
return top;
return top;
}

int main()
{
int arr[] = {8, 1, 7, 6, 0};
if (findMaxMultupleOf3( arr, size ) == 0)

printf( "Not Possible" );
return 0;
}

The above method can be optimized in following ways.

1) We can use Heap Sort or Merge Sort to make the time complexity O(nLogn).
2) We can avoid extra space for queues. We know at most two items will be removed from the input array. So
we can keep track of two items in two variables.
3) At the end, instead of sorting the array again in descending order, we can print the ascending sorted array
in reverse order. While printing in reverse order, we can skip the two elements to be removed.
The above code works only if the input arrays has numbers from 0 to 9. It can be easily extended for any
positive integer array. We just have to modify the part where we sort the array in decreasing order, at the end
of code.
Time Complexity: O(nLogn), assuming a O(nLogn) algorithm is used for sorting.
discussed above.
Find the element that appears once
Given an array where every element occurs three times, except one element which occurs only once. Find the
element that occurs once. Expected time complexity is O(n) and O(1) extra space.
Examples:
Input: arr[] = {12, 1, 12, 3, 12, 1, 1, 2, 3, 3}

Output: 2

We can use sorting to do it in O(nLogn) time. We can also use hashing, but the worst case time complexity of
hashing may be more than O(n) and hashing requires extra space.
The idea is to use bitwise operators for a solution that is O(n) time and uses O(1) extra space. The solution is
not easy like other XOR based solutions, because all elements appear odd number of times here. The idea is
taken from here.
Run a loop for all elements in array. At the end of every iteration, maintain following two values.
ones: The bits that have appeared 1st time or 4th time or 7th time .. etc.
twos: The bits that have appeared 2nd time or 5th time or 8th time .. etc.
Finally, we return the value of ‘ones’
How to maintain the values of ‘ones’ and ‘twos’?

‘ones’ and ‘twos’ are initialized as 0. For every new element in array, find out the common set bits in the new
element and previous value of ‘ones’. These common set bits are actually the bits that should be added to
‘twos’. So do bitwise OR of the common set bits with ‘twos’. ‘twos’ also gets some extra bits that appear third
time. These extra bits are removed later.
Update ‘ones’ by doing XOR of new element with previous value of ‘ones’. There may be some bits which
appear 3rd time. These extra bits are also removed later.
Both ‘ones’ and ‘twos’ contain those extra bits which appear 3rd time. Remove these extra bits by finding out
common set bits in ‘ones’ and ‘twos’.
#include <stdio.h>
int getSingle(int arr[], int n)

{
int ones = 0, twos = 0 ;
int common_bit_mask;
// Let us take the example of {3, 3, 2, 3} to understand this

for( int i=0; i< n; i++ )
{
/* The expression "one & arr[i]" gives the bits that are
there in both 'ones' and new element from arr[]. We
add these bits to 'twos' using bitwise OR
Value of 'twos' will be set as 0, 3, 3 and 1 after 1st,

2nd, 3rd and 4th iterations respectively */
twos = twos | (ones & arr[i]);
/* XOR the new bits with previous 'ones' to get all bits
appearing odd number of times
Value of 'ones' will be set as 3, 0, 2 and 3 after 1st,

ones = ones ^ arr[i];
/* The common bits are those bits which appear third time
So these bits should not be there in both 'ones' and 'twos'.
common_bit_mask contains all these bits as 0, so that the bits can
be removed from 'ones' and 'twos'
Value of 'common_bit_mask' will be set as 00, 00, 01 and 10

after 1st, 2nd, 3rd and 4th iterations respectively */
common_bit_mask = ~(ones & twos);
/* Remove common bits (the bits that appear third time) from 'ones'

Value of 'ones' will be set as 3, 0, 0 and 2 after 1st,
ones &= common_bit_mask;
/* Remove common bits (the bits that appear third time) from 'twos'
Value of 'twos' will be set as 0, 3, 1 and 0 after 1st,

2nd, 3rd and 4th itearations respectively */
twos &= common_bit_mask;
// uncomment this code to see intermediate values

//printf (" %d %d \n", ones, twos);
}
return ones;
}
int main()
{
int arr[] = {3, 3, 2, 3};
printf("The element with single occurrence is %d ",
getSingle(arr, n));
return 0;
}

Output:

Following is another O(n) time complexity and O(1) extra space method suggested by aj. We can sum the
bits in same positions for all the numbers and take modulo with 3. The bits for which sum is not multiple of
3, are the bits of number with single occurrence.
Let us consider the example array {5, 5, 5, 8}. The 101, 101, 101, 1000
Sum of first bits%3 = (1 + 1 + 1 + 0)%3 = 0;
Sum of second bits%3 = (0 + 0 + 0 + 0)%0 = 0;
Sum of third bits%3 = (1 + 1 + 1 + 0)%3 = 0;
Sum of fourth bits%3 = (1)%3 = 1;
Hence number which appears once is 1000
#include <stdio.h>
#define INT_SIZE 32
int getSingle(int arr[], int n)

{
// Initialize result
int result = 0;
int x, sum;
// Iterate through every bit

for (int i = 0; i < INT_SIZE; i++)
{
// Find sum of set bits at ith position in all
// array elements
sum = 0;
x = (1 << i);
for (int j=0; j< n; j++ )
{
if (arr[j] & x)
sum++;
}
// The bits with sum not multiple of 3, are the

// bits of element with single occurrence.
if (sum % 3)
result |= x;
}
return result;
}

int main()
{
int arr[] = {12, 1, 12, 3, 12, 1, 1, 2, 3, 2, 2, 3, 7};
printf("The element with single occurrence is %d ",
getSingle(arr, n));
return 0;
}

This article is compiled by Sumit Jain and reviewed by GeeksforGeeks team. Please write comments if you
find anything incorrect, or you want to share more information about the topic discussed above.
Construct Full Binary Tree from given preorder and postorder traversals
Given two arrays that represent preorder and postorder traversals of a full binary tree, construct the binary
tree.
A Full Binary Tree is a binary tree where every node has either 0 or 2 children
Following are examples of Full Trees.
1
/ \
2 3
/ \ / \
4 5 6 7
1
/ \
2 3
/ \
4 5
/ \
6 7

1
/ \
2 3
/ \ / \
4 5 6 7
/ \
8 9
It is not possible to construct a general Binary Tree from preorder and postorder traversals (See
this). But if
know that the Binary Tree is Full, we can construct the tree without ambiguity. Let us understand this with
the help of following example.
Let us consider the two given arrays as pre[] = {1, 2, 4, 8, 9, 5, 3, 6, 7} and post[] = {8, 9, 4, 5, 2, 6, 7, 3, 1};
In pre[], the leftmost element is root of tree. Since the tree is full and array size is more than 1. The value
next to 1 in pre[], must be left child of root. So we know 1 is root and 2 is left child. How to find the all nodes
in left subtree? We know 2 is root of all nodes in left subtree. All nodes before 2 in post[] must be in left
subtree. Now we know 1 is root, elements {8, 9, 4, 5, 2} are in left subtree, and the elements {6, 7, 3} are in
right subtree.
1
/ \
/ \
{8, 9, 4, 5, 2} {6, 7, 3}

We recursively follow the above approach and get the following tree.

1
/ \
2 3
/ \ / \
4 5 6 7
/ \
8 9
/* program for construction of full binary tree */

#include <stdio.h>
#include <stdlib.h>

struct node
{
int data;
struct node *left;
struct node *right;
};

{
temp->data = data;
return temp;
}
// A recursive function to construct Full from pre[] and post[].

// preIndex is used to keep track of index in pre[].
// l is low index and h is high index for the current subarray in post[]
struct node* constructTreeUtil (int pre[], int post[], int* preIndex,
int l, int h, int size)
{
// Base case
if (*preIndex >= size || l > h)
return NULL;
// The first node in preorder traversal is root. So take the node at

// preIndex from preorder and make it root, and increment preIndex
struct node* root = newNode ( pre[*preIndex] );
++*preIndex;
// If the current subarry has only one element, no need to recur

if (l == h)
return root;
// Search the next element of pre[] in post[]

int i;
for (i = l; i <= h; ++i)
if (pre[*preIndex] == post[i])
break;
break;
// Use the index of element found in postorder to divide postorder array in

// two parts. Left subtree and right subtree
if (i <= h)
{
root->left = constructTreeUtil (pre, post, preIndex, l, i, size);
root->right = constructTreeUtil (pre, post, preIndex, i + 1, h, size);
}
return root;
}
// The main function to construct Full Binary Tree from given preorder and
// postorder traversals. This function mainly uses constructTreeUtil()
struct node *constructTree (int pre[], int post[], int size)
{
int preIndex = 0;
return constructTreeUtil (pre, post, &preIndex, 0, size - 1, size);
}

{
if (node == NULL)
return;
}

int main ()
{
int pre[] = {1, 2, 4, 8, 9, 5, 3, 6, 7};
int post[] = {8, 9, 4, 5, 2, 6, 7, 3, 1};
int size = sizeof( pre ) / sizeof( pre[0] );
struct node *root = constructTree(pre, post, size);
printf("Inorder traversal of the constructed tree: \n");

printInorder(root);
return 0;
}

Output:

Inorder traversal of the constructed tree:
8 4 9 2 5 1 6 3 7

discussed above.
Lexicographic rank of a string
Given a string, find its rank among all its permutations sorted lexicographically. For example, rank of “abc” is
1, rank of “acb” is 2, and rank of “cba” is 6.
For simplicity, let us assume that the string does not contain any duplicated characters.
One simple solution is to initialize rank as 1, generate all permutations in lexicographic order. After
generating a permutation, check if the generated permutation is same as given string, if same, then return
rank, if not, then increment the rank by 1. The time complexity of this solution will be exponential in worst
case. Following is an efficient solution.
Let the given string be “STRING”. In the input string, ‘S’ is the first character. There are total 6 characters
and 4 of them are smaller than ‘S’. So there can be 4 * 5! smaller strings where first character is smaller than
‘S’, like following
R X X X X X
I X X X X X
N X X X X X
G X X X X X
Now let us Fix S’ and find the smaller strings staring with ‘S’.
Repeat the same process for T, rank is 4*5! + 4*4! +…
Now fix T and repeat the same process for R, rank is 4*5! + 4*4! + 3*3! +…
Now fix R and repeat the same process for I, rank is 4*5! + 4*4! + 3*3! + 1*2! +…
Now fix I and repeat the same process for N, rank is 4*5! + 4*4! + 3*3! + 1*2! + 1*1! +…
Now fix N and repeat the same process for G, rank is 4*5! + 4*4 + 3*3! + 1*2! + 1*1! + 0*0!
Rank = 4*5! + 4*4! + 3*3! + 1*2! + 1*1! + 0*0! = 597
Since the value of rank starts from 1, the final rank = 1 + 597 = 598

#include <stdio.h>
#include <string.h>
// A utility function to find factorial of n

int fact(int n)
{
return (n <= 1)? 1 :n * fact(n-1);
}
// A utility function to count smaller characters on right

// of arr[low]
int findSmallerInRight(char* str, int low, int high)
{
int countRight = 0, i;
for (i = low+1; i <= high; ++i)

if (str[i] < str[low])
++countRight;
return countRight;
}
// A function to find rank of a string in all permutations

// of characters
int findRank (char* str)
{
int mul = fact(len);
int rank = 1;
int countRight;
int i;
for (i = 0; i < len; ++i)
{
mul /= len - i;
// count number of chars smaller than str[i]

// fron str[i+1] to str[len-1]
countRight = findSmallerInRight(str, i, len-1);
rank += countRight * mul ;

}
return rank;
}

int main()
{
char str[] = "string";
printf ("%d", findRank(str));
return 0;
}

Output

598

The time complexity of the above solution is O(n^2). We can reduce the time complexity to O(n) by creating
an auxiliary array of size 256. See following code.
// A O(n) solution for finding rank of string

#include <stdio.h>
#include <string.h>
#define MAX_CHAR 256
// A utility function to find factorial of n

int fact(int n)
{
return (n <= 1)? 1 :n * fact(n-1);
}
// Construct a count array where value at every index

// contains count of smaller characters in whole string
void populateAndIncreaseCount (int* count, char* str)
{
int i;
for( i = 0; str[i]; ++i )

++count[ str[i] ];
for( i = 1; i < 256; ++i )

count[i] += count[i-1];
}
// Removes a character ch from count[] array

// constructed by populateAndIncreaseCount()
void updatecount (int* count, char ch)
{
int i;
for( i = ch; i < MAX_CHAR; ++i )
--count[i];
}
// A function to find rank of a string in all permutations

// of characters
int findRank (char* str)
{
int mul = fact(len);
int rank = 1, i;
int count[MAX_CHAR] = {0}; // all elements of count[] are initialized with 0
// Populate the count array such that count[i] contains count of

// characters which are present in str and are smaller than i
populateAndIncreaseCount( count, str );
for (i = 0; i < len; ++i)

{
mul /= len - i;
// count number of chars smaller than str[i]

// fron str[i+1] to str[len-1]
rank += count[ str[i] - 1] * mul;
rank += count[ str[i] - 1] * mul;
// Reduce count of characters greater than str[i]

updatecount (count, str[i]);
}
return rank;
}

int main()
{
char str[] = "string";
printf ("%d", findRank(str));
return 0;
}

The above programs don’t work for duplicate characters. To make them work for duplicate characters, find
all the characters that are smaller (include equal this time also), do the same as above but, this time divide
the rank so formed by p! where p is the count of occurrences of the repeating character.
discussed above.
Print all permutations in sorted (lexicographic) order
Given a string, print all permutations of it in sorted order. For example, if the input string is “ABC”, then
output should be “ABC, ACB, BAC, BCA, CAB, CBA”.
We have discussed a program to print all permutations in this post, but here we must print the permutations
in increasing order.
Following are the steps to print the permutations lexicographic-ally
1. Sort the given string in non-decreasing order and print it. The first permutation is always the string sorted
in non-decreasing order.
2. Start generating next higher permutation. Do it until next higher permutation is not possible. If we reach a
permutation where all characters are sorted in non-increasing order, then that permutation is the last
permutation.
Steps to generate the next higher permutation:

1. Take the previously printed permutation and find the rightmost character in it, which is smaller than its
next character. Let us call this character as ‘first character’.
2. Now find the ceiling of the ‘first character’. Ceiling is the smallest character on right of ‘first character’,
which is greater than ‘first character’. Let us call the ceil character as ‘second character’.
3. Swap the two characters found in above 2 steps.
4. Sort the substring (in non-decreasing order) after the original index of ‘first character’.
Let us consider the string “ABCDEF”. Let previously printed permutation be “DCFEBA”. The next
permutation in sorted order should be “DEABCF”. Let us understand above steps to find next permutation.
The ‘first character’ will be ‘C’. The ‘second character’ will be ‘E’. After swapping these two, we get
“DEFCBA”. The final step is to sort the substring after the character original index of ‘first character’. Finally,
we get “DEABCF”.
Following is C++ implementation of the algorithm.
// Program to print all permutations of a string in sorted order.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

{ return ( *(char *)a - *(char *)b ); }
// A utility function two swap two characters a and b

void swap (char* a, char* b)
{
char t = *a;
*a = *b;
*b = t;
}
// This function finds the index of the smallest character

// which is greater than 'first' and is present in str[l..h]
int findCeil (char str[], char first, int l, int h)
{
// initialize index of ceiling element
int ceilIndex = l;
int ceilIndex = l;
// Now iterate through rest of the elements and find

// the smallest character greater than 'first'
for (int i = l+1; i <= h; i++)
if (str[i] > first && str[i] < str[ceilIndex])
ceilIndex = i;
return ceilIndex;
}
// Print all permutations of str in sorted order

void sortedPermutations ( char str[] )
{
// Get size of string
int size = strlen(str);
// Sort the string in increasing order

qsort( str, size, sizeof( str[0] ), compare );
// Print permutations one by one

bool isFinished = false;
while ( ! isFinished )
{
// print this permutation
printf ("%s \n", str);
// Find the rightmost character which is smaller than its next

// character. Let us call it 'first char'
int i;
for ( i = size - 2; i >= 0; --i )
if (str[i] < str[i+1])
break;
// If there is no such chracter, all are sorted in decreasing order,

// means we just printed the last permutation and we are done.
if ( i == -1 )
isFinished = true;
else
{
// Find the ceil of 'first char' in right of first character.
// Ceil of a character is the smallest character greater than it
int ceilIndex = findCeil( str, str[i], i + 1, size - 1 );
// Swap first and second characters

swap( &str[i], &str[ceilIndex] );
// Sort the string on right of 'first char'

qsort( str + i + 1, size - i - 1, sizeof(str[0]), compare );
}
}
}

int main()
{
char str[] = "ABCD";
sortedPermutations( str );
return 0;
}

Output:

ABCD
ABDC
....
....
DCAB
DCBA

The upper bound on time complexity of the above program is O(n^2 x n!). We can optimize step 4 of the
above algorithm for finding next permutation. Instead of sorting the subarray after the ‘first character’, we
can reverse the subarray, because the subarray we get after swapping is always sorted in non-increasing
order. This optimization makes the time complexity as O(n x n!). See following optimized code.

// An optimized version that uses reverse instead of sort for

// finding the next permutation
// A utility function to reverse a string str[l..h]

void reverse(char str[], int l, int h)
{
while (l < h)
{
swap(&str[l], &str[h]);
l++;
h--;
}
}

void sortedPermutations ( char str[] )
{

qsort( str, size, sizeof( str[0] ), compare );

while ( ! isFinished )
{
printf ("%s \n", str);

int i;
for ( i = size - 2; i >= 0; --i )
break;

if ( i == -1 )
isFinished = true;
else
{
int ceilIndex = findCeil( str, str[i], i + 1, size - 1 );

swap( &str[i], &str[ceilIndex] );
// reverse the string on right of 'first char'

reverse( str, i + 1, size - 1 );
}
}
}

The above programs print duplicate permutation when characters are repeated. We can avoid it by keeping
track of the previous permutation. While printing, if the current permutation is same as previous
permutation, we won’t print it.
Shuffle a given array
Given an array, write a program to generate a random permutation of array elements. This question is also
asked as “shuffle a deck of cards” or “randomize a given array”.
Let the given array be arr[]. A simple solution is to create an auxiliary array temp[] which is initially a copy
of arr[]. Randomly select an element from temp[], copy the randomly selected element to arr[0] and remove
the selected element from temp[]. Repeat the same process n times and keep copying elements to arr[1],
arr[2], … . The time complexity of this solution will be O(n^2).
Fisher–Yates shuffle Algorithm works in O(n) time complexity. The assumption here is, we are given a
function rand() that generates random number in O(1) time.
The idea is to start from the last element, swap it with a randomly selected element from the whole array
(including last). Now consider the array from 0 to n-2 (size reduced by 1), and repeat the process till we hit
the first element.
Following is the detailed algorithm
To shuffle an array a of n elements (indices 0..n-1):

for i from n - 1 downto 1 do
j = random integer with 0
Following is C++ implementation of this algorithm.

// C Program to shuffle a given array
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
// A utility function to swap to integers

void swap (int *a, int *b)
{
int temp = *a;
*a = *b;
*b = temp;
}

void printArray (int arr[], int n)
{
for (int i = 0; i < n; i++)
printf("\n");
}
// A function to generate a random permutation of arr[]

void randomize ( int arr[], int n )
{
// Use a different seed value so that we don't get same
// result each time we run this program
srand ( time(NULL) );
// Start from the last element and swap one by one. We don't
// need to run for the first element that's why i > 0
for (int i = n-1; i > 0; i--)
{
// Pick a random index from 0 to i
int j = rand() % (i+1);
// Swap arr[i] with the element at random index

}
}
// Driver program to test above function.

int main()
{
int arr[] = {1, 2, 3, 4, 5, 6, 7, 8};
int n = sizeof(arr)/ sizeof(arr[0]);
randomize (arr, n);
printArray(arr, n);
return 0;
}

Output:
7 8 4 6 3 1 2 5
The above function assumes that rand() generates a random number.
Time Complexity: O(n), assuming that the function rand() takes O(1) time.
How does this work?
The probability that ith element (including the last one) goes to last position is 1/n, b
ecause we randomly pick an element in first iteration.
The probability that ith element goes to second last position can be proved to be 1/n by
dividing it in two cases.
Case 1: i = n-1 (index of last element):
The probability of last element going to second last position is = (probability that las
t element doesn't stay at its original position) x (probability that the index picked in
previous step is picked again so that the last element is swapped)
So the probability = ((n-1)/n) x (1/(n-1)) = 1/n
Case 2: 0 :
The probability of ith element going to second position = (probability that ith element
is not picked in previous iteration) x (probability that ith element is picked in this i
teration)
So the probability = ((n-1)/n) x (1/(n-1)) = 1/n

We can easily generalize above proof for any other position.

Count the number of possible triangles
Given an unsorted array of positive integers. Find the number of triangles that can be formed with three
different array elements as three sides of triangles. For a triangle to be possible from 3 values, the sum of any
two values (or sides) must be greater than the third value (or third side).
For example, if the input array is {4, 6, 3, 7}, the output should be 3. There are three triangles possible {3, 4,
6}, {4, 6, 7} and {3, 6, 7}. Note that {3, 4, 7} is not a possible triangle.
As another example, consider the array {10, 21, 22, 100, 101, 200, 300}. There can be 6 possible triangles:
{10, 21, 22}, {21, 100, 101}, {22, 100, 101}, {10, 100, 101}, {100, 101, 200} and {101, 200, 300}
Method 1 (Brute force)

The brute force method is to run three loops and keep track of the number of triangles possible so far. The
three loops select three different values from array, the innermost loop checks for the triangle property ( the
sum of any two sides must be greater than the value of third side).
Time Complexity: O(N^3) where N is the size of input array.

Let a, b and c be three sides. The below condition must hold for a triangle (Sum of two sides is greater than
the third side)
i) a + b > c
ii) b + c > a
iii) a + c > b
Following are steps to count triangle.
1. Sort the array in non-decreasing order.
2. Initialize two pointers ‘i’ and ‘j’ to first and second elements respectively, and initialize count of triangles
as 0.
3. Fix ‘i’ and ‘j’ and find the rightmost index ‘k’ (or largest ‘arr[k]’) such that ‘arr[i] + arr[j] > arr[k]’. The
number of triangles that can be formed with ‘arr[i]’ and ‘arr[j]’ as two sides is ‘k – j’. Add ‘k – j’ to count of
triangles.
Let us consider ‘arr[i]’ as ‘a’, ‘arr[j]’ as b and all elements between ‘arr[j+1]’ and ‘arr[k]’ as ‘c’. The above
mentioned conditions (ii) and (iii) are satisfied because ‘arr[i] 4. Increment ‘j’ to fix the second element
again.
Note that in step 3, we can use the previous value of ‘k’. The reason is simple, if we know that the value of
‘arr[i] + arr[j-1]’ is greater than ‘arr[k]’, then we can say ‘arr[i] + arr[j]’ will also be greater than ‘arr[k]’,
because the array is sorted in increasing order.
5. If ‘j’ has reached end, then increment ‘i’. Initialize ‘j’ as ‘i + 1′, ‘k’ as ‘i+2′ and repeat the steps 3 and 4.
Following is implementation of the above approach.
// Program to count number of triangles that can be formed from given array
#include <stdio.h>
#include <stdlib.h>

int comp(const void* a, const void* b)
{ return *(int*)a > *(int*)b ; }
// Function to count all possible triangles with arr[] elements

int findNumberOfTriangles(int arr[], int n)
int findNumberOfTriangles(int arr[], int n)
{
// Sort the array elements in non-decreasing order
qsort(arr, n, sizeof( arr[0] ), comp);
// Initialize count of triangles

int count = 0;
// Fix the first element. We need to run till n-3 as the other two elements are
// selected from arr[i+1...n-1]
for (int i = 0; i < n-2; ++i)
{
// Initialize index of the rightmost third element
int k = i+2;
// Fix the second element

for (int j = i+1; j < n; ++j)
{
// Find the rightmost element which is smaller than the sum
// of two fixed elements
// The important thing to note here is, we use the previous
// value of k. If value of arr[i] + arr[j-1] was greater than arr[k],
// then arr[i] + arr[j] must be greater than k, because the
// array is sorted.
while (k < n && arr[i] + arr[j] > arr[k])
++k;
// Total number of possible triangles that can be formed

// with the two fixed elements is k - j - 1. The two fixed
// elements are arr[i] and arr[j]. All elements between arr[j+1]
// to arr[k-1] can form a triangle with arr[i] and arr[j].
// One is subtracted from k because k is incremented one extra
// in above while loop.
// k will always be greater than j. If j becomes equal to k, then
// above loop will increment k, because arr[k] + arr[i] is always
// greater than arr[k]
count += k - j - 1;
}
}
return count;
}
// Driver program to test above functionarr[j+1]

int main()
{
int arr[] = {10, 21, 22, 100, 101, 200, 300};
int size = sizeof( arr ) / sizeof( arr[0] );
printf("Total number of triangles possible is %d ",

findNumberOfTriangles( arr, size ) );
return 0;
}

Output:

Total number of triangles possible is 6

Time Complexity: O(n^2). The time complexity looks more because of 3 nested loops. If we take a closer look
at the algorithm, we observe that k is initialized only once in the outermost loop. The innermost loop
executes at most O(n) time for every iteration of outer most loop, because k starts from i+2 and goes upto n
for all values of j. Therefore, the time complexity is O(n^2).
Source: http://stackoverflow.com/questions/8110538/total-number-of-possible-triangles-from-n-numbers
discussed above.
Construct BST from given preorder traversal | Set 1
Given preorder traversal of a binary search tree, construct the BST.
For example, if the given traversal is {10, 5, 1, 7, 40, 50}, then the output should be root of following tree.
10
/ \
5 40
/ \ \
1 7 50

Method 1 ( O(n^2) time complexity )

The first element of preorder traversal is always root. We first construct the root. Then we find the index of
first element which is greater than root. Let the index be ‘i’. The values between root and ‘i’ will be part of left
subtree, and the values between ‘i+1′ and ‘n-1′ will be part of right subtree. Divide given pre[] at index “i”
and recur for left and right sub-trees.
For example in {10, 5, 1, 7, 40, 50}, 10 is the first element, so we make it root. Now we look for the first
element greater than 10, we find 40. So we know the structure of BST is as following.
10
/ \
/ \
{5, 1, 7} {40, 50}

We recursively follow above steps for subarrays {5, 1, 7} and {40, 50}, and get the complete tree.
/* A O(n^2) program for construction of BST from preorder traversal */

#include <stdio.h>
#include <stdlib.h>

struct node
{
int data;
struct node *left;
struct node *right;
};

{
temp->data = data;
return temp;
}
// A recursive function to construct Full from pre[]. preIndex is used
// to keep track of index in pre[].
struct node* constructTreeUtil (int pre[], int* preIndex,
int low, int high, int size)
{
// Base case
if (*preIndex >= size || low > high)
return NULL;
// The first node in preorder traversal is root. So take the node at

// preIndex from pre[] and make it root, and increment preIndex
struct node* root = newNode ( pre[*preIndex] );
*preIndex = *preIndex + 1;
// If the current subarry has only one element, no need to recur

if (low == high)
return root;
// Search for the first element greater than root

int i;
for ( i = low; i <= high; ++i )
if ( pre[ i ] > root->data )
break;
// Use the index of element found in postorder to divide postorder array in

// two parts. Left subtree and right subtree
root->left = constructTreeUtil ( pre, preIndex, *preIndex, i - 1, size );
root->right = constructTreeUtil ( pre, preIndex, i, high, size );
return root;
}
// The main function to construct BST from given preorder traversal.

// This function mainly uses constructTreeUtil()
struct node *constructTree (int pre[], int size)
{
int preIndex = 0;
return constructTreeUtil (pre, &preIndex, 0, size - 1, size);
}

{
if (node == NULL)
return;
}

int main ()
{
int pre[] = {10, 5, 1, 7, 40, 50};
struct node *root = constructTree(pre, size);

printInorder(root);
return 0;
}

Output:

1 5 7 10 40 50

Method 2 ( O(n) time complexity )

The idea used here is inspired from method 3 of this post. The trick is to set a range {min .. max} for every
node. Initialize the range as {INT_MIN .. INT_MAX}. The first node will definitely be in range, so create
root node. To construct the left subtree, set the range as {INT_MIN …root->data}. If a values is in the range
{INT_MIN .. root->data}, the values is part part of left subtree. To construct the right subtree, set the range
as {root->data..max .. INT_MAX}.
/* A O(n) program for construction of BST from preorder traversal */

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

struct node
{
int data;
struct node *left;
struct node *right;
};

{
temp->data = data;
return temp;
}
// A recursive function to construct BST from pre[]. preIndex is used

// to keep track of index in pre[].
struct node* constructTreeUtil( int pre[], int* preIndex, int key,
int min, int max, int size )
{
// Base case
if( *preIndex >= size )
return NULL;


// If current element of pre[] is in range, then
// only it is part of current subtree
if( key > min && key < max )
{
// Allocate memory for root of this subtree and increment *preIndex
// Allocate memory for root of this subtree and increment *preIndex
root = newNode ( key );
*preIndex = *preIndex + 1;

if (*preIndex < size)
{
// Contruct the subtree under root
// All nodes which are in range {min .. key} will go in left
// subtree, and first such node will be root of left subtree.
root->left = constructTreeUtil( pre, preIndex, pre[*preIndex],
min, key, size );

// All nodes which are in range {key..max} will go in right
// subtree, and first such node will be root of right subtree.
root->right = constructTreeUtil( pre, preIndex, pre[*preIndex],
key, max, size );
}
}

return root;
}
// The main function to construct BST from given preorder traversal.

// This function mainly uses constructTreeUtil()
struct node *constructTree (int pre[], int size)
{
int preIndex = 0;
return constructTreeUtil ( pre, &preIndex, pre[0], INT_MIN, INT_MAX, size );
}

{
if (node == NULL)
return;
}

int main ()
{
int pre[] = {10, 5, 1, 7, 40, 50};
struct node *root = constructTree(pre, size);

printInorder(root);
return 0;
}

Output:

1 5 7 10 40 50


We will soon publish a O(n) iterative solution as a separate post.
discussed above.
Construct BST from given preorder traversal | Set 2
Given preorder traversal of a binary search tree, construct the BST.
For example, if the given traversal is {10, 5, 1, 7, 40, 50}, then the output should be root of following tree.
10
/ \
5 40
/ \ \
1 7 50

We have discussed O(n^2) and O(n) recursive solutions in the previous post. Following is a stack based
iterative solution that works in O(n) time.
1. Create an empty stack.
2. Make the first value as root. Push it to the stack.
3. Keep on popping while the stack is not empty and the next value is greater than stack’s top value. Make
this value as the right child of the last popped node. Push the new node to the stack.
4. If the next value is less than the stack’s top value, make this value as the left child of the stack’s top node.
Push the new node to the stack.
5. Repeat steps 2 and 3 until there are items remaining in pre[].
/* A O(n) iterative program for construction of BST from preorder traversal */

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

typedef struct Node
{
int data;
struct Node *left, *right;
} Node;
// A Stack has array of Nodes, capacity, and top

typedef struct Stack
{
int top;
int capacity;
Node* *array;
} Stack;
// A utility function to create a new tree node

Node* newNode( int data )
{
Node* temp = (Node *)malloc( sizeof( Node ) );
temp->data = data;
return temp;
}
// A utility function to create a stack of given capacity
Stack* createStack( int capacity )
{
Stack* stack = (Stack *)malloc( sizeof( Stack ) );
stack->top = -1;
stack->capacity = capacity;
stack->array = (Node **)malloc( stack->capacity * sizeof( Node* ) );
return stack;
}
// A utility function to check if stack is full

int isFull( Stack* stack )
{
return stack->top == stack->capacity - 1;
}
// A utility function to check if stack is empty

int isEmpty( Stack* stack )
{
return stack->top == -1;
}
// A utility function to push an item to stack

void push( Stack* stack, Node* item )
{
if( isFull( stack ) )
return;
stack->array[ ++stack->top ] = item;
}
// A utility function to remove an item from stack

Node* pop( Stack* stack )
{
if( isEmpty( stack ) )
return NULL;
return stack->array[ stack->top-- ];
}
// A utility function to get top node of stack

Node* peek( Stack* stack )
{
return stack->array[ stack->top ];
}
// The main function that constructs BST from pre[]

Node* constructTree ( int pre[], int size )
{
// Create a stack of capacity equal to size
Stack* stack = createStack( size );
// The first element of pre[] is always root

Node* root = newNode( pre[0] );
// Push root
push( stack, root );
int i;
Node* temp;
// Iterate through rest of the size-1 items of given preorder array

for ( i = 1; i < size; ++i )
{
temp = NULL;
/* Keep on popping while the next value is greater than
stack's top value. */
while ( !isEmpty( stack ) && pre[i] > peek( stack )->data )
temp = pop( stack );
// Make this greater value as the right child and push it to the stack
if ( temp != NULL)
{
temp->right = newNode( pre[i] );
push( stack, temp->right );
}
// If the next value is less than the stack's top value, make this value
// as the left child of the stack's top node. Push the new node to stack
else
{
peek( stack )->left = newNode( pre[i] );
push( stack, peek( stack )->left );
}
}
return root;
}

void printInorder (Node* node)
{
if (node == NULL)
return;
}

int main ()
{
int pre[] = {10, 5, 1, 7, 40, 50};
Node *root = constructTree(pre, size);

printInorder(root);
return 0;
}

Output:

1 5 7 10 40 50

Time Complexity: O(n). The complexity looks more from first look. If we take a closer look, we can observe
that every item is pushed and popped only once. So at most 2n push/pop operations are performed in the
main loops of constructTree(). Therefore, time complexity is O(n).
discussed above.
Question 1
#include <iostream>
class A
{
public:
A& operator=(const A&a)
{
cout << "A's assignment operator called" << endl;
return *this;
}
};
class B
{
A a[2];
};
int main()
{
B b1, b2;
b1 = b2;
return 0;
}

Output:

A's assignment operator called
A's assignment operator called

The class B doesn’t have user defined assignment operator. If we don’t write our own assignment operator,
compiler creates a default assignment operator. The default assignment operator one by one copies all
members of right side object to left side object. The class B has 2 members of class A. They both are copied
in statement “b1 = b2″, that is why there are two assignment operator calls.
Question 2

#include<stdlib.h>
#include<iostream>
class Test {
public:
void* operator new(size_t size);
void operator delete(void*);
Test() { cout<<"\n Constructor called"; }
~Test() { cout<<"\n Destructor called"; }
};
void* Test::operator new(size_t size)

{
cout<<"\n new called";
void *storage = malloc(size);
return storage;
}
void Test::operator delete(void *p )

{
cout<<"\n delete called";
free(p);
}
int main()
{
Test *m = new Test();
delete m;
return 0;
}

new called
Constructor called
Destructor called
delete called

Let us see what happens when below statement is executed.
Test *x = new Test;

When we use new keyword to dynamically allocate memory, two things happen: memory allocation and
constructor call. The memory allocation happens with the help of operator new. In the above program, there
is a user defined operator new, so first user defined operator new is called, then constructor is called.
The process of destruction is opposite. First, destructor is called, then memory is deallocated.
discussed above
Iterative Quick Sort
Following is a typical recursive implementation of Quick Sort that uses last element as pivot.
/* A typical recursive implementation of quick sort */
/* This function takes last element as pivot, places the pivot element at its
correct position in sorted array, and places all smaller (smaller than pivot)
to left of pivot and all greater elements to right of pivot */
int partition (int arr[], int l, int h)
{
int x = arr[h];
int i = (l - 1);
for (int j = l; j <= h- 1; j++)

{
if (arr[j] <= x)
{
i++;
swap (&arr[i], &arr[j]);
}
}
swap (&arr[i + 1], &arr[h]);
return (i + 1);
}
/* A[] --> Array to be sorted, l --> Starting index, h --> Ending index */
void quickSort(int A[], int l, int h)
{
if (l < h)
{
int p = partition(A, l, h); /* Partitioning index */
quickSort(A, l, p - 1);
quickSort(A, p + 1, h);
}
}

The above implementation can be optimized in many ways
1) The above implementation uses last index as pivot. This causes worst-case behavior on already sorted
arrays, which is a commonly occurring case. The problem can be solved by choosing either a random index
for the pivot, or choosing the middle index of the partition or choosing the median of the first, middle and
last element of the partition for the pivot. (See this for details)
2) To reduce the recursion depth, recur first for the smaller half of the array, and use a tail call to recurse
into the other.
3) Insertion sort works better for small subarrays. Insertion sort can be used for invocations on such small
arrays (i.e. where the length is less than a threshold t determined experimentally). For example, this library
implementation of qsort uses insertion sort below size 7.
Despite above optimizations, the function remains recursive and uses function call stack to store
intermediate values of l and h. The function call stack stores other bookkeeping information together with
parameters. Also, function calls involve overheads like storing activation record of the caller function and
then resuming execution.
The above function can be easily converted to iterative version with the help of an auxiliary stack. Following
is an iterative implementation of the above recursive code.
// An iterative implementation of quick sort

#include <stdio.h>

void swap ( int* a, int* b )
{
int t = *a;
*a = *b;
*b = t;
}
/* This function is same in both iterative and recursive*/

{
int x = arr[h];
int i = (l - 1);
for (int j = l; j <= h- 1; j++)

{
if (arr[j] <= x)
{
i++;
}
}
return (i + 1);
}
void quickSortIterative (int arr[], int l, int h)
{
// Create an auxiliary stack
int stack[ h - l + 1 ];
// initialize top of stack

int top = -1;
// push initial values of l and h to stack

stack[ ++top ] = l;
stack[ ++top ] = h;
// Keep popping from stack while is not empty

while ( top >= 0 )
{
// Pop h and l
h = stack[ top-- ];
l = stack[ top-- ];
// Set pivot element at its correct position in sorted array

int p = partition( arr, l, h );
// If there are elements on left side of pivot, then push left

// side to stack
if ( p-1 > l )
{
stack[ ++top ] = l;
stack[ ++top ] = p - 1;
}
// If there are elements on right side of pivot, then push right
// side to stack
if ( p+1 < h )
{
stack[ ++top ] = p + 1;
stack[ ++top ] = h;
}
}
}
// A utility function to print contents of arr

void printArr( int arr[], int n )
{
int i;
for ( i = 0; i < n; ++i )
printf( "%d ", arr[i] );
}

int main()
{
int arr[] = {4, 3, 5, 2, 1, 3, 2, 3};
int n = sizeof( arr ) / sizeof( *arr );
quickSortIterative( arr, 0, n - 1 );
printArr( arr, n );
return 0;
}

Output:

1 2 2 3 3 3 4 5

The above mentioned optimizations for recursive quick sort can also be applied to iterative version.
1) Partition process is same in both recursive and iterative. The same techniques to choose optimal pivot can
also be applied to iterative version.
2) To reduce the stack size, first push the indexes of smaller half.
3) Use insertion sort when the size reduces below a experimentally calculated threshold.
References:
http://en.wikipedia.org/wiki/Quicksort
Longest Palindromic Substring | Set 1
Given a string, find the longest substring which is palindrome. For example, if the given string is
“forgeeksskeegfor”, the output should be “geeksskeeg”.
Method 1 ( Brute Force )

The simple approach is to check each substring whether the substring is a palindrome or not. We can run
three loops, the outer two loops pick all substrings one by one by fixing the corner characters, the inner loop
checks whether the picked substring is palindrome or not.
Time complexity: O ( n^3 )

Auxiliary complexity: O ( 1 )
Method 2 ( Dynamic Programming )

The time complexity can be reduced by storing results of subproblems. The idea is similar to this post. We
maintain a boolean table[n][n] that is filled in bottom up manner. The value of table[i][j] is true, if the
substring is palindrome, otherwise false. To calculate table[i][j], we first check the value of table[i+1][j-1], if
the value is true and str[i] is same as str[j], then we make table[i][j] true. Otherwise, the value of table[i][j] is
made false.
// A dynamic programming solution for longest palindr.

// This code is adopted from following link
// http://www.leetcode.com/2011/11/longest-palindromic-substring-part-i.html
#include <stdio.h>
#include <string.h>
// A utility function to print a substring str[low..high]

void printSubStr( char* str, int low, int high )
{
for( int i = low; i <= high; ++i )
}
// This function prints the longest palindrome substring

// of str[].
// It also returns the length of the longest palindrome
int longestPalSubstr( char *str )
{
int n = strlen( str ); // get length of input string
// table[i][j] will be false if substring str[i..j]

// is not palindrome.
// Else table[i][j] will be true
bool table[n][n];
// All substrings of length 1 are palindromes

int maxLength = 1;
for (int i = 0; i < n; ++i)
table[i][i] = true;
// check for sub-string of length 2.

int start = 0;
for (int i = 0; i < n-1; ++i)
{
if (str[i] == str[i+1])
{
table[i][i+1] = true;
start = i;
maxLength = 2;
}
}
// Check for lengths greater than 2. k is length

// of substring
for (int k = 3; k <= n; ++k)
{
// Fix the starting index
for (int i = 0; i < n-k+1 ; ++i)
{
// Get the ending index of substring from
// starting index i and length k
int j = i + k - 1;
// checking for sub-string from ith index to

// jth index iff str[i+1] to str[j-1] is a
// palindrome
if (table[i+1][j-1] && str[i] == str[j])
{
table[i][j] = true;
if (k > maxLength)
{
start = i;
maxLength = k;
}
}
}
}
printf("Longest palindrome substring is: ");

printSubStr( str, start, start + maxLength - 1 );
return maxLength; // return length of LPS

}

int main()
{
char str[] = "forgeeksskeegfor";
printf("\nLength is: %d\n", longestPalSubstr( str ) );
return 0;
}

Output:

Longest palindrome substring is: geeksskeeg
Length is: 10

Time complexity: O ( n^2 )

Auxiliary Space: O ( n^2 )
We will soon be adding more optimized methods as separate posts.
discussed above.
Space and time efficient Binomial Coefficient
Write a function that takes two parameters n and k and returns the value of Binomial Coefficient C(n, k). For
example, your function should return 6 for n = 4 and k = 2, and it should return 10 for n = 5 and k = 2.
We have discussed a O(n*k) time and O(k) extra space algorithm in

this post. The value of C(n, k) can be
calculated in O(k) time and O(1) extra space.
C(n, k) = n! / (n-k)! * k!
= [n * (n-1) *....* 1] / [ ( (n-k) * (n-k-1) * .... * 1) *
( k * (k-1) * .... * 1 ) ]
After simplifying, we get
C(n, k) = [n * (n-1) * .... * (n-k+1)] / [k * (k-1) * .... * 1]
Also, C(n, k) = C(n, n-k) // we can change r to n-r if r > n-r

Following implementation uses above formula to calculate C(n, k)
// Program to calculate C(n ,k)

#include <stdio.h>

{
int res = 1;
// Since C(n, k) = C(n, n-k)

if ( k > n - k )
k = n - k;
// Calculate value of [n * (n-1) *---* (n-k+1)] / [k * (k-1) *----* 1]

for (int i = 0; i < k; ++i)
{
res *= (n - i);
res /= (i + 1);
}
return res;
}

int main()
{
int n = 8, k = 2;
printf ("Value of C(%d, %d) is %d ", n, k, binomialCoeff(n, k) );
return 0;
}

Value of C(8, 2) is 28

Time Complexity: O(k)

An in-place algorithm for String Transformation
Given a string, move all even positioned elements to end of string. While moving elements, keep the relative
order of all even positioned and odd positioned elements same. For example, if the given string is
“a1b2c3d4e5f6g7h8i9j1k2l3m4″, convert it to “abcdefghijklm1234567891234″ in-place and in O(n) time
complexity.
Below are the steps:
1. Cut out the largest prefix sub-string of size of the form 3^k + 1. In this step, we find the largest non-
negative integer k such that 3^k+1 is smaller than or equal to n (length of string)
2. Apply cycle leader iteration algorithm ( it has been discussed below ), starting with index 1, 3, 9…… to this
sub-string. Cycle leader iteration algorithm moves all the items of this sub-string to their correct positions,
i.e. all the alphabets are shifted to the left half of the sub-string and all the digits are shifted to the right half
of this sub-string.
3. Process the remaining sub-string recursively using steps#1 and #2.
4. Now, we only need to join the processed sub-strings together. Start from any end ( say from left ), pick
two sub-strings and apply the below steps:
….4.1 Reverse the second half of first sub-string.

….4.2 Reverse the first half of second sub-string.
….4.3 Reverse the second half of first sub-string and first half of second sub-string together.
5. Repeat step#4 until all sub-strings are joined. It is similar to k-way merging where first sub-string is
joined with second. The resultant is merged with third and so on.
Let us understand it with an example:
Please note that we have used values like 10, 11 12 in the below example. Consider these values as single
characters only. These values are used for better readability.
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
a 1 b 2 c 3 d 4 e 5 f 6 g 7 h 8 i 9 j 10 k 11 l 12 m 13

After breaking into size of the form 3^k + 1, two sub-strings are formed of size 10 each. The third sub-string
is formed of size 4 and the fourth sub-string is formed of size 2.
0 1 2 3 4 5 6 7 8 9
a 1 b 2 c 3 d 4 e 5
10 11 12 13 14 15 16 17 18 19
f 6 g 7 h 8 i 9 j 10
20 21 22 23
k 11 l 12
24 25
m 13

After applying cycle leader iteration algorithm to first sub-string:
0 1 2 3 4 5 6 7 8 9
a b c d e 1 2 3 4 5
10 11 12 13 14 15 16 17 18 19
f 6 g 7 h 8 i 9 j 10
20 21 22 23
k 11 l 12
24 25
m 13

After applying cycle leader iteration algorithm to second sub-string:
0 1 2 3 4 5 6 7 8 9
a b c d e 1 2 3 4 5
10 11 12 13 14 15 16 17 18 19
f g h i j 6 7 8 9 10
20 21 22 23
k 11 l 12
24 25
m 13

After applying cycle leader iteration algorithm to third sub-string:
0 1 2 3 4 5 6 7 8 9
a b c d e 1 2 3 4 5
10 11 12 13 14 15 16 17 18 19
f g h i j 6 7 8 9 10
20 21 22 23
k l 11 12
24 25
m 13

After applying cycle leader iteration algorithm to fourth sub-string:

0 1 2 3 4 5 6 7 8 9
a b c d e 1 2 3 4 5
10 11 12 13 14 15 16 17 18 19
f g h i j 6 7 8 9 10
20 21 22 23
k l 11 12
24 25
m 13

Joining first sub-string and second sub-string:

1. Second half of first sub-string and first half of second sub-string reversed.
0 1 2 3 4 5 6 7 8 9
a b c d e 5 4 3 2 1 <--------- First Sub-string
10 11 12 13 14 15 16 17 18 19
j i h g f 6 7 8 9 10 <--------- Second Sub-string
20 21 22 23
k l 11 12
24 25
m 13

2. Second half of first sub-string and first half of second sub-string reversed together( They are merged, i.e.
there are only three sub-strings now ).
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
a b c d e f g h i j 1 2 3 4 5 6 7 8 9 10
20 21 22 23
k l 11 12
24 25
m 13



0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
a b c d e f g h i j 10 9 8 7 6 5 4 3 2 1 <--------- First Sub-string
20 21 22 23
l k 11 12 <--------- Second Sub-string
24 25
m 13

there are only two sub-strings now ).
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
a b c d e f g h i j k l 1 2 3 4 5 6 7 8 9 10 11 12
24 25
m 13


0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
a b c d e f g h i j k l 12 11 10 9 8 7 6 5 4 3 2 1 <----- First Sub-string
24 25
m 13 <----- Second Sub-string

there is only one sub-string now ).
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
a b c d e f g h i j k l m 1 2 3 4 5 6 7 8 9 10 11 12 13

Since all sub-strings have been joined together, we are done.
How does cycle leader iteration algorithm work?

Input:
0 1 2 3 4 5 6 7 8 9
a 1 b 2 c 3 d 4 e 5
Output:
0 1 2 3 4 5 6 7 8 9
a b c d e 1 2 3 4 5
Old index New index

0 0
1 5
2 1
3 6
4 2
5 7
6 3
7 8
8 4
9 9

Let len be the length of the string. If we observe carefully, we find that the new index is given by below
formula:
if( oldIndex is odd )

newIndex = len / 2 + oldIndex / 2;
else
newIndex = oldIndex / 2;

So, the problem reduces to shifting the elements to new indexes based on the above formula.
Cycle leader iteration algorithm will be applied starting from the indices of the form 3^k, starting with k = 0.
Below are the steps:
1. Find new position for item at position i. Before putting this item at new position, keep the back-up of
element at new position. Now, put the item at new position.
2. Repeat step#1 for new position until a cycle is completed, i.e. until the procedure comes back to the
starting position.
3. Apply cycle leader iteration algorithm to the next index of the form 3^k. Repeat this step until 3^k < len.
Consider input array of size 28:
The first cycle leader iteration, starting with index 1:
1->14->7->17->22->11->19->23->25->26->13->20->10->5->16->8->4->2->1
The second cycle leader iteration, starting with index 3:
3->15->21->24->12->6->3
The third cycle leader iteration, starting with index 9:
9->18->9
Based on the above algorithm, below is the code:
#include <stdio.h>
#include <string.h>
#include <math.h>
// A utility function to swap characters

void swap ( char* a, char* b )
{
char t = *a;
*a = *b;
*b = t;
}
// A utility function to reverse string str[low..high]

void reverse ( char* str, int low, int high )
{
while ( low < high )
{
swap( &str[low], &str[high] );
++low;
--high;
}
}
// Cycle leader algorithm to move all even positioned elements

// at the end.
void cycleLeader ( char* str, int shift, int len )
{
int j;
char item;
for (int i = 1; i < len; i *= 3 )

{
j = i;
item = str[j + shift];

do
{
// odd index
if ( j & 1 )
j = len / 2 + j / 2;
// even index
else
j /= 2;
// keep the back-up of element at new position

swap (&str[j + shift], &item);
}
while ( j != i );
}
}
// The main function to transform a string. This function mainly uses

// cycleLeader() to transform
void moveNumberToSecondHalf( char* str )
{
int k, lenFirst;
int lenRemaining = strlen( str );

int shift = 0;
while ( lenRemaining )
{
k = 0;
// Step 1: Find the largest prefix subarray of the form 3^k + 1

while ( pow( 3, k ) + 1 <= lenRemaining )
k++;
lenFirst = pow( 3, k - 1 ) + 1;
lenRemaining -= lenFirst;
// Step 2: Apply cycle leader algorithm for the largest subarrau

cycleLeader ( str, shift, lenFirst );
// Step 4.1: Reverse the second half of first subarray

reverse ( str, shift / 2, shift - 1 );
// Step 4.2: Reverse the first half of second sub-string.

reverse ( str, shift, shift + lenFirst / 2 - 1 );
// Step 4.3 Reverse the second half of first sub-string and first
// half of second sub-string together
reverse ( str, shift / 2, shift + lenFirst / 2 - 1 );
// Increase the length of first subarray

shift += lenFirst;
}
}

int main()
{
char str[] = "a1b2c3d4e5f6g7";
moveNumberToSecondHalf( str );
printf( "%s", str );
return 0;
}

Click here to see various test cases.
Notes:
1. If the array size is already in the form 3^k + 1, We can directly apply cycle leader iteration algorithm.
There is no need of joining.
2. Cycle leader iteration algorithm is only applicable to arrays of size of the form 3^k + 1.
How is the time complexity O(n) ?

Each item in a cycle is shifted at most once. Thus time complexity of the cycle leader algorithm is O(n). The
time complexity of the reverse operation is O(n). We will soon update the mathematical proof of the time
complexity of the algorithm.
Exercise:
Given string in the form “abcdefg1234567″, convert it to “a1b2c3d4e5f6g7″ in-place and in O(n) time
complexity.
References:
A Simple In-Place Algorithm for In-Shu?e.
__Aashish Barnwal.Please write comments if you find anything incorrect, or you want to share more
Inplace M x N size matrix transpose | Updated
About four months of gap (missing GFG), a new post. Given an M x N matrix, transpose the matrix without
auxiliary memory.It is easy to transpose matrix using an auxiliary array. If the matrix is symmetric in size,
we can transpose the matrix inplace by mirroring the 2D array across it’s diagonal (try yourself). How to
transpose an arbitrary size matrix inplace? See the following matrix,

a b c a d g j
d e f ==> b e h k
g h i c f i l
j k l

As per 2D numbering in C/C++, corresponding location mapping looks like,

Org element New
0 a 0
1 b 4
2 c 8
3 d 1
4 e 5
5 f 9
6 g 2
7 h 6
8 i 10
9 j 3
10 k 7
11 l 11

Note that the first and last elements stay in their original location. We can easily see
the transformation forms few permutation cycles. 1->4->5->9->3->1 – Total 5 elements form the cycle 2-
>8->10->7->6->2 – Another 5 elements form the cycle 0 – Self cycle 11 – Self cycle From the above
example, we can easily devise an algorithm to move the elements along these cycles. How can we generate
permutation cycles? Number of elements in both the matrices are constant, given by N = R * C, where R is
row count and C is column count. An element at location ol (old location in R x C matrix), moved to nl (new
location in C x R matrix). We need to establish relation between ol, nl, R and C. Assume ol = A[or][oc]. In
C/C++ we can calculate the element address as,

ol = or x C + oc (ignore base reference for simplicity)

It is to be moved to new location nl in the transposed matrix, say nl = A[nr][nc], or in C/C++ terms

nl = nr x R + nc (R - column count, C is row count as the matrix is transposed)

Observe, nr = oc and nc = or, so replacing these for nl,

nl = oc x R + or -----> [eq 1]

after solving for relation between ol and nl, we get

ol = or x C + oc
ol x R = or x C x R + oc x R
= or x N + oc x R (from the fact R * C = N)
= or x N + (nl - or) --- from [eq 1]
= or x (N-1) + nl

OR,

nl = ol x R - or x (N-1)

Note that the values of nl and ol never go beyond N-1, so considering modulo division on both the sides by
(N-1), we get the following based on properties of congruence,

nl mod (N-1) = (ol x R - or x (N-1)) mod (N-1)
= (ol x R) mod (N-1) - or x (N-1) mod(N-1)
= ol x R mod (N-1), since second term evaluates to zero
nl = (ol x R) mod (N-1), since nl is always less than N-1

A curious reader might have observed the significance of above relation. Every location is
scaled by a factor of R (row size). It is obvious from the matrix that every location is
displaced by scaled factor of R. The actual multiplier depends on congruence class of (N-1),
i.e. the multiplier can be both -ve and +ve value of the congruent class.Hence every
location transformation is simple modulo division. These modulo divisions form cyclic permutations. We
need some book keeping information to keep track of already moved elements. Here is code for inplace
matrix transformation,
// Program for in-place matrix transpose

#include <stdio.h>
#include <iostream>
#include <bitset>
#define HASH_SIZE 128
// A utility function to print a 2D array of size nr x nc and base address A

void Print2DArray(int *A, int nr, int nc)
{
for(int r = 0; r < nr; r++)
{
for(int c = 0; c < nc; c++)
printf("%4d", *(A + r*nc + c));
printf("\n");
}
printf("\n\n");
}
// Non-square matrix transpose of matrix of size r x c and base address A

void MatrixInplaceTranspose(int *A, int r, int c)
{
int size = r*c - 1;
int t; // holds element to be replaced, eventually becomes next element to move
int next; // location of 't' to be moved
int cycleBegin; // holds start of cycle
int i; // iterator
bitset<HASH_SIZE> b; // hash to mark moved elements
b.reset();
b[0] = b[size] = 1;
i = 1; // Note that A[0] and A[size-1] won't move
while (i < size)
{
cycleBegin = i;
t = A[i];
do
{
// Input matrix [r x c]
// Output matrix 1
// i_new = (i*r)%(N-1)
next = (i*r)%size;
swap(A[next], t);
b[i] = 1;
i = next;
}
while (i != cycleBegin);
// Get Next Move (what about querying random location?)

for (i = 1; i < size && b[i]; i++)
;
cout << endl;
}
}

int main(void)
{
int r = 5, c = 6;
int size = r*c;
int *A = new int[size];

A[i] = i+1;
Print2DArray(A, r, c);
MatrixInplaceTranspose(A, r, c);
Print2DArray(A, c, r);
delete[] A;
return 0;
}

Output:

1 2 3 4 5 6
7 8 9 10 11 12
13 14 15 16 17 18
19 20 21 22 23 24
25 26 27 28 29 30
1 7 13 19 25
2 8 14 20 26
3 9 15 21 27
4 10 16 22 28
5 11 17 23 29
6 12 18 24 30

Extension: 17 – March – 2013 Some readers identified similarity between the matrix transpose and
string transformation. Without much theory I am presenting the problem and solution. In given array of
elements like [a1b2c3d4e5f6g7h8i9j1k2l3m4]. Convert it to [abcdefghijklm1234567891234]. The program
should run inplace. What we need is an inplace transpose. Given below is code.
#include <stdio.h>
#include <iostream>
#include <bitset>
#define HASH_SIZE 128
typedef char data_t;
void Print2DArray(char A[], int nr, int nc) {

int size = nr*nc;
printf("%4c", *(A + i));
printf("\n");
}
void MatrixTransposeInplaceArrangement(data_t A[], int r, int c) {

int size = r*c - 1;
data_t t; // holds element to be replaced, eventually becomes next element to move
int next; // location of 't' to be moved
int cycleBegin; // holds start of cycle
int i; // iterator
bitset<HASH_SIZE> b; // hash to mark moved elements
b.reset();
b[0] = b[size] = 1;
i = 1; // Note that A[0] and A[size-1] won't move
while( i < size ) {
cycleBegin = i;
t = A[i];
do {
// Input matrix [r x c]
// Output matrix 1
// i_new = (i*r)%size
next = (i*r)%size;
swap(A[next], t);
b[i] = 1;
i = next;
} while( i != cycleBegin );
// Get Next Move (what about querying random location?)

for(i = 1; i < size && b[i]; i++)
;
cout << endl;
}
}
void Fill(data_t buf[], int size) {

// Fill abcd ...
buf[i] = 'a'+i;
// Fill 0123 ...

buf += size;
buf[i] = '0'+i;
}
void TestCase_01(void) {
int r = 2, c = 10;
int size = r*c;
data_t *A = new data_t[size];
Fill(A, c);
Print2DArray(A, r, c), cout << endl;

MatrixTransposeInplaceArrangement(A, r, c);
Print2DArray(A, c, r), cout << endl;
delete[] A;
}
int main() {
TestCase_01();
return 0;
}

The post is incomplete without mentioning two links.
1. Aashish covered good theory behind cycle leader algorithm. See his post on string transformation.
2. As usual, Sambasiva demonstrated his exceptional skills in recursion to the problem. Ensure to
understand his solution.
Find the number of islands
Given a boolean 2D matrix, find the number of islands.
This is an variation of the standard problem: “Counting number of connected components in a undirected
graph”.
Before we go to the problem, let us understand what is a connected component. A connected component of
an undirected graph is a subgraph in which every two vertices are connected to each other by a path(s), and
which is connected to no other vertices outside the subgraph.
For example, the graph shown below has three connected components.
A graph where all vertices are connected with each other, has exactly one connected component, consisting
of the whole graph. Such graph with only one connected component is called as Strongly Connected Graph.
The problem can be easily solved by applying DFS() on each component. In each DFS() call, a component or
a sub-graph is visited. We will call DFS on the next un-visited component. The number of calls to DFS()
gives the number of connected components. BFS can also be used.
What is an island?
A group of connected 1s forms an island. For example, the below matrix contains 5 islands
{1, 1, 0, 0, 0},
{0, 1, 0, 0, 1},
{1, 0, 0, 1, 1},
{0, 0, 0, 0, 0},
{1, 0, 1, 0, 1}

A cell in 2D matrix can be connected to 8 neighbors. So, unlike standard DFS(), where we recursively call for
all adjacent vertices, here we can recursive call for 8 neighbors only. We keep track of the visited 1s so that
they are not visited again.
// Program to count islands in boolean 2D matrix
#include <stdio.h>
#include <string.h>
#define ROW 5
#define COL 5
// A function to check if a given cell (row, col) can be included in DFS

// A function to check if a given cell (row, col) can be included in DFS
int isSafe(int M[][COL], int row, int col, bool visited[][COL])
{
return (row >= 0) && (row < ROW) && // row number is in range
(col >= 0) && (col < COL) && // column number is in range
(M[row][col] && !visited[row][col]); // value is 1 and not yet visited
}
// A utility function to do DFS for a 2D boolean matrix. It only considers

// the 8 neighbors as adjacent vertices
void DFS(int M[][COL], int row, int col, bool visited[][COL])
{
// These arrays are used to get row and column numbers of 8 neighbors
// of a given cell
static int rowNbr[] = {-1, -1, -1, 0, 0, 1, 1, 1};
static int colNbr[] = {-1, 0, 1, -1, 1, -1, 0, 1};
// Mark this cell as visited

visited[row][col] = true;
// Recur for all connected neighbours

for (int k = 0; k < 8; ++k)
if (isSafe(M, row + rowNbr[k], col + colNbr[k], visited) )
DFS(M, row + rowNbr[k], col + colNbr[k], visited);
}
// The main function that returns count of islands in a given boolean

// 2D matrix
int countIslands(int M[][COL])
{
// Make a bool array to mark visited cells.
// Initially all cells are unvisited
bool visited[ROW][COL];
memset(visited, 0, sizeof(visited));
// Initialize count as 0 and travese through the all cells of

// given matrix
int count = 0;
for (int i = 0; i < ROW; ++i)
for (int j = 0; j < COL; ++j)
if (M[i][j] && !visited[i][j]) // If a cell with value 1 is not
{ // visited yet, then new island found
DFS(M, i, j, visited); // Visit all cells in this island.
++count; // and increment island count
}
return count;
}

int main()
{
int M[][COL]= { {1, 1, 0, 0, 0},
{0, 1, 0, 0, 1},
{1, 0, 0, 1, 1},
{0, 0, 0, 0, 0},
{1, 0, 1, 0, 1}
};
printf("Number of islands is: %d\n", countIslands(M));
return 0;
}

Output:

Number of islands is: 5

Time complexity: O(ROW x COL)
Reference:
http://en.wikipedia.org/wiki/Connected_component_%28graph_theory%29
discussed above.
Floor and Ceil from a BST
There are numerous applications we need to find floor (ceil) value of a key in a binary search tree or sorted
array. For example, consider designing memory management system in which free nodes are arranged in
BST. Find best fit for the input request.
Ceil Value Node: Node with smallest data larger than or equal to key value.
Imagine we are moving down the tree, and assume we are root node. The comparison yields three
possibilities,
A) Root data is equal to key. We are done, root data is ceil value.
B) Root data < key value, certainly the ceil value can’t be in left subtree. Proceed to search on right subtree
as reduced problem instance.
C) Root data > key value, the ceil value may be in left subtree. We may find a node with is larger data than
key value in left subtree, if not the root itself will be ceil node.
Here is code in C for ceil value.
// Program to find ceil of a given value in BST

#include <stdio.h>
#include <stdlib.h>
/* A binary tree node has key, left child and right child */
struct node
{
int key;
struct node* left;
struct node* right;
};
NULL left and right pointers.*/
{
node->key = key;
node->left = NULL;
node->right = NULL;
return(node);
}
// Function to find ceil of a given input in BST. If input is more

// than the max key in BST, return -1
int Ceil(node *root, int input)
{
// Base case
if( root == NULL )
return -1;
// We found equal key

if( root->key == input )
return root->key;
// If root's key is smaller, ceil must be in right subtree

if( root->key < input )
return Ceil(root->right, input);
// Else, either left subtree or root has the ceil value

// Else, either left subtree or root has the ceil value
int ceil = Ceil(root->left, input);
return (ceil >= input) ? ceil : root->key;
}

int main()
{
node *root = newNode(8);
for(int i = 0; i < 16; i++)

printf("%d %d\n", i, Ceil(root, i));
return 0;
}

Output:

0 2
1 2
2 2
3 4
4 4
5 6
6 6
7 8
8 8
9 10
10 10
11 12
12 12
13 14
14 14
15 -1

Exercise:
1. Modify above code to find floor value of input key in a binary search tree.
2. Write neat algorithm to find floor and ceil values in a sorted array. Ensure to handle all possible boundary
conditions.
Longest Palindromic Substring | Set 2
Given a string, find the longest substring which is palindrome. For example, if the given string is
“forgeeksskeegfor”, the output should be “geeksskeeg”.
We have discussed dynamic programming solution in the previous post. The time complexity of the Dynamic
Programming based solution is O(n^2) and it requires O(n^2) extra space. We can find the longest
palindrome substring in (n^2) time with O(1) extra space. The idea is to generate all even length and odd
length palindromes and keep track of the longest palindrome seen so far.
Step to generate odd length palindrome:

Fix a centre and expand in both directions for longer palindromes.
Step to generate even length palindrome

Fix two centre ( low and high ) and expand in both directions for longer palindromes.
// A O(n^2) time and O(1) space program to find the longest palindromic substring
#include <stdio.h>
#include <string.h>
// A utility function to print a substring str[low..high]

void printSubStr(char* str, int low, int high)
{
for( int i = low; i <= high; ++i )
}
// This function prints the longest palindrome substring (LPS)

// of str[]. It also returns the length of the longest palindrome
int longestPalSubstr(char *str)
{
int maxLength = 1; // The result (length of LPS)
int start = 0;
int low, high;
// One by one consider every character as center point of

// even and length palindromes
for (int i = 1; i < len; ++i)
{
// Find the longest even length palindrome with center points
// as i-1 and i.
low = i - 1;
high = i;
while (low >= 0 && high < len && str[low] == str[high])
{
if (high - low + 1 > maxLength)
{
start = low;
maxLength = high - low + 1;
}
--low;
++high;
}
// Find the longest odd length palindrome with center

// point as i
low = i - 1;
high = i + 1;
while (low >= 0 && high < len && str[low] == str[high])
{
if (high - low + 1 > maxLength)
{
start = low;
maxLength = high - low + 1;
}
--low;
++high;
}
}
printf("Longest palindrome substring is: ");

printSubStr(str, start, start + maxLength - 1);
return maxLength;
}

int main()
{
char str[] = "forgeeksskeegfor";
printf("\nLength is: %d\n", longestPalSubstr( str ) );
return 0;
}

Output:
Longest palindrome substring is: geeksskeeg

Length is: 10

Time complexity: O ( n^2 ) where n is the length of input string.

Auxiliary Space: O ( 1 )
We will soon be adding more optimized method as separate post.
discussed above.
Reservoir Sampling
Reservoir sampling is a family of randomized algorithms for randomly choosing k samples from a list of n
items, where n is either a very large or unknown number. Typically n is large enough that the list doesn’t fit
into main memory. For example, a list of search queries in Google and Facebook.
So we are given a big array (or stream) of numbers (to simplify), and we need to write an efficient function to
randomly select k numbers where 1 . Let the input array be stream[].
A simple solution is to create an array reservoir[] of maximum size k. One by one randomly select an item
from stream[0..n-1]. If the selected item is not previously selected, then put it in reservoir[]. To check if an
item is previously selected or not, we need to search the item in reservoir[]. The time complexity of this
algorithm will be O(k^2). This can be costly if k is big. Also, this is not efficient if the input is in the form of a
stream.
It can be solved in O(n) time. The solution also suits well for input in the form of stream. The idea is
similar to this post. Following are the steps.
1) Create an array reservoir[0..k-1] and copy first k items of stream[] to it.

2) Now one by one consider all items from (k+1)th item to nth item.
…a) Generate a random number from 0 to i where i is index of current item in stream[]. Let the generated
random number is j.
…b) If j is in range 0 to k-1, replace reservoir[j] with arr[i]
Following is C implementation of the above algorithm.

// An efficient program to randomly select k items from a stream of items
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

void printArray(int stream[], int n)
{
for (int i = 0; i < n; i++)
printf("%d ", stream[i]);
printf("\n");
}
// A function to randomly select k items from stream[0..n-1].

void selectKItems(int stream[], int n, int k)
{
int i; // index for elements in stream[]
// reservoir[] is the output array. Initialize it with

// first k elements from stream[]
int reservoir[k];
for (i = 0; i < k; i++)
reservoir[i] = stream[i];
// Use a different seed value so that we don't get

// same result each time we run this program
srand(time(NULL));
// Iterate from the (k+1)th element to nth element

for (; i < n; i++)
{
// Pick a random index from 0 to i.
int j = rand() % (i+1);
// If the randomly picked index is smaller than k, then replace

// the element present at the index with new element from stream
if (j < k)
reservoir[j] = stream[i];
}
printf("Following are k randomly selected items \n");

printArray(reservoir, k);
}

int main()
{
int stream[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
int n = sizeof(stream)/sizeof(stream[0]);
int k = 5;
selectKItems(stream, n, k);
return 0;
}

Output:

Following are k randomly selected items
6 2 11 8 12

How does this work?

To prove that this solution works perfectly, we must prove that the probability that any item stream[i] where
0 will be in final reservoir[] is k/n. Let us divide the proof in two cases as first k items are treated
differently.
Case 1: For last n-k stream items, i.e., for stream[i] where k
For every such stream item stream[i], we pick a random index from 0 to i and if the picked index is one of
the first k indexes, we replace the element at picked index with stream[i]
To simplify the proof, let us first consider the last item. The probability that the last item is in final reservoir
= The probability that one of the first k indexes is picked for last item = k/n (the probability of picking one of
the k items from a list of size n)
Let us now consider the second last item. The probability that the second last item is in final reservoir[] =
[Probability that one of the first k indexes is picked in iteration for stream[n-2]] X [Probability that the index
picked in iteration for stream[n-1] is not same as index picked for stream[n-2] ] = [k/(n-1)]*[(n-1)/n] = k/n.
Similarly, we can consider other items for all stream items from stream[n-1] to stream[k] and generalize the
proof.
Case 2: For first k stream items, i.e., for stream[i] where 0

The first k items are initially copied to reservoir[] and may be removed later in iterations for stream[k] to
stream[n].
The probability that an item from stream[0..k-1] is in final array = Probability that the item is not picked
when items stream[k], stream[k+1], …. stream[n-1] are considered = [k/(k+1)] x [(k+1)/(k+2)] x
[(k+2)/(k+3)] x … x [(n-1)/n] = k/n
References:
http://en.wikipedia.org/wiki/Reservoir_sampling
discussed above.
Add two numbers represented by linked lists | Set 2
Given two numbers represented by two linked lists, write a function that returns sum list. The sum list is
linked list representation of addition of two input numbers. It is not allowed to modify the lists. Also, not
allowed to use explicit extra space (Hint: Use Recursion).
Example
Input:
First List: 5->6->3 // represents number 563
Second List: 8->4->2 // represents number 842
Output
Resultant list: 1->4->0->5 // represents number 1405

We have discussed a solution here which is for linked lists where least significant digit is first node of lists
and most significant digit is last node. In this problem, most significant node is first node and least
significant digit is last node and we are not allowed to modify the lists. Recursion is used here to calculate
sum from right to left.
Following are the steps.

1) Calculate sizes of given two linked lists.
2) If sizes are same, then calculate sum using recursion. Hold all nodes in recursion call stack till the
rightmost node, calculate sum of rightmost nodes and forward carry to left side.
3) If size is not same, then follow below steps:
….a) Calculate difference of sizes of two linked lists. Let the difference be diff
….b) Move diff nodes ahead in the bigger linked list. Now use step 2 to calculate sum of smaller list and right
sub-list (of same size) of larger list. Also, store the carry of this sum.
….c) Calculate sum of the carry (calculated in previous step) with the remaining left sub-list of larger list.
Nodes of this sum are added at the beginning of sum list obtained previous step.
// A recursive program to add two linked lists
#include <stdio.h>
#include <stdlib.h>
// A linked List Node

struct node
{
int data;
struct node* next;
};
typedef struct node node;
/* A utility function to insert a node at the beginning of linked list */

{
/* allocate node */



}
/* A utility function to print linked list */

{
{
node = node->next;
}
printf("\n");
}
// A utility function to swap two pointers

void swapPointer( node** a, node** b )
{
node* t = *a;
*a = *b;
*b = t;
}
/* A utility function to get size of linked list */

int getSize(struct node *node)
{
int size = 0;
{
node = node->next;
size++;
}
return size;
}
// Adds two linked lists of same size represented by head1 and head2 and returns
// head of the resultant linked list. Carry is propagated while returning from
// the recursion
node* addSameSize(node* head1, node* head2, int* carry)
{
// Since the function assumes linked lists are of same size,
// check any of the two head pointers
if (head1 == NULL)
return NULL;
int sum;
// Allocate memory for sum node of current two nodes

node* result = (node *)malloc(sizeof(node));
// Recursively add remaining nodes and get the carry

result->next = addSameSize(head1->next, head2->next, carry);
// add digits of current nodes and propagated carry

sum = head1->data + head2->data + *carry;
*carry = sum / 10;
sum = sum % 10;
// Assigne the sum to current node of resultant list

result->data = sum;
result->data = sum;
return result;
}
// This function is called after the smaller list is added to the bigger
// lists's sublist of same size. Once the right sublist is added, the carry
// must be added toe left side of larger list to get the final result.
void addCarryToRemaining(node* head1, node* cur, int* carry, node** result)
{
int sum;
// If diff. number of nodes are not traversed, add carry

if (head1 != cur)
{
addCarryToRemaining(head1->next, cur, carry, result);
sum = head1->data + *carry;

*carry = sum/10;
sum %= 10;
// add this node to the front of the result

push(result, sum);
}
}
// The main function that adds two linked lists represented by head1 and head2.
// The sum of two lists is stored in a list referred by result
void addList(node* head1, node* head2, node** result)
{
node *cur;
// first list is empty

if (head1 == NULL)
{
*result = head2;
return;
}
// second list is empty

else if (head2 == NULL)
{
*result = head1;
return;
}
int size1 = getSize(head1);

int size2 = getSize(head2) ;
int carry = 0;
// Add same size lists

if (size1 == size2)
*result = addSameSize(head1, head2, &carry);
else
{
int diff = abs(size1 - size2);
// First list should always be larger than second list.

// If not, swap pointers
if (size1 < size2)
swapPointer(&head1, &head2);
// move diff. number of nodes in first list

// move diff. number of nodes in first list
for (cur = head1; diff--; cur = cur->next);
// get addition of same size lists

*result = addSameSize(cur, head2, &carry);
// get addition of remaining first list and carry

addCarryToRemaining(head1, cur, &carry, result);
}
// if some carry is still there, add a new node to the fron of

// the result list. e.g. 999 and 87
if (carry)
push(result, carry);
}

int main()
{
node *head1 = NULL, *head2 = NULL, *result = NULL;
int arr1[] = {9, 9, 9};

int arr2[] = {1, 8};
int size1 = sizeof(arr1) / sizeof(arr1[0]);

int size2 = sizeof(arr2) / sizeof(arr2[0]);
// Create first list as 9->9->9

int i;
for (i = size1-1; i >= 0; --i)
push(&head1, arr1[i]);
// Create second list as 1->8

for (i = size2-1; i >= 0; --i)
push(&head2, arr2[i]);
addList(head1, head2, &result);
printList(result);
return 0;
}

Output:

1 0 1 7

Time Complexity: O(m+n) where m and n are the sizes of given two linked lists.
discussed above.
Question 1
#include <iostream>
template <int N>

class A {
int arr[N];
public:
virtual void fun() { cout << "A::fun()"; }
};
class B : public A<2> {

public:
void fun() { cout << "B::fun()"; }
};
class C : public B { };
int main() {
A<2> *a = new C;
a->fun();
return 0;
}

Output:

B::fun()

In general, the purpose of using templates in C++ is to avoid code redundancy. We create generic classes (or
functions) that can be used for any datatype as long as logic is identical. Datatype becomes a parameter and
an instance of class/function is created at compile time when a data type is passed. C++ Templates also allow
nontype (a parameter that represents a value, not a datatype) things as parameters.
In the above program, there is a generic class A which takes a nontype parameter N. The class B inherits
from an instance of generic class A. The value of N for this instance of A is 2. The class B overrides fun() of
class A. The class C inherits from B. In main(), there is a pointer ‘a’ of type A that points to an instance of C.
When ‘a->fun()’ is called, the function of class B is executed because fun() is virtual and virtual functions are
called according to the actual object, not according to pointer. In class C, there is no function ‘fun()’, so it is
looked up in the hierarchy and found in class B.
Question 2

#include <iostream>
template <int i>

int fun()
{
i =20;
}
int main() {
fun<4>();
return 0;
}

Output:

Compiler Error

The value of nontype parameters must be constant as they are used at compile time to create instance of
classes/functions. In the above program, templated fun() receives a nontype parameter and tries to modify
it which is not possible. Therefore, compiler error.
discussed above
Iterative Preorder Traversal
Given a Binary Tree, write an iterative function to print Preorder traversal of the given binary tree.
Refer this for recursive preorder traversal of Binary Tree. To convert an inherently recursive procedures to
iterative, we need an explicit stack. Following is a simple stack based iterative process to print Preorder
traversal.
1) Create an empty stack nodeStack and push root node to stack.
2) Do following while nodeStack is not empty.
….a) Pop an item from stack and print it.
….b) Push right child of popped item to stack
….c) Push left child of popped item to stack
Right child is pushed before left child to make sure that left subtree is processed first.
#include <stdlib.h>
#include <stdio.h>
#include <iostream>
#include <stack>
struct node
{
int data;
struct node* left;
struct node* right;
};
/* Helper function that allocates a new node with the given data and
{
struct node* node = new struct node;
node->data = data;
node->left = NULL;
node->right = NULL;
return(node);
}
// An iterative process to print preorder traversal of Binary tree

void iterativePreorder(node *root)
{
// Base Case
if (root == NULL)
return;
// Create an empty stack and push root to it

stack<node *> nodeStack;
nodeStack.push(root);
/* Pop all items one by one. Do following for every popped item
a) print it
b) push its right child
c) push its left child
Note that right child is pushed first so that left is processed first */
while (nodeStack.empty() == false)
{
// Pop the top item from stack and print it
// Pop the top item from stack and print it
struct node *node = nodeStack.top();
printf ("%d ", node->data);
nodeStack.pop();
// Push right and left children of the popped node to stack

if (node->right)
nodeStack.push(node->right);
if (node->left)
nodeStack.push(node->left);
}
}

int main()
{
10
/ \
8 2
/ \ /
3 5 2
*/
iterativePreorder(root);
return 0;
}

Output:

10 8 3 5 2 2

This article is compiled by Saurabh Sharma and reviewed by GeeksforGeeks team. Please write comments if
Significance of Pascal’s Identity
We know the Pascal’s Identity very well, i.e. n cr = n-1 cr + n-1 cr-1
A curious reader might have observed that Pascal’s Identity is instrumental in establishing recursive relation
in solving binomial coefficients. It is quite easy to prove the above identity using simple algebra. Here I’m
trying to explain it’s practical significance.
Recap from counting techniques, n cr means selecting r elements from n elements. Let us pick a special
element k from these n elements, we left with (n – 1 ) elements.
We can group these r elements selection n cr into two categories,
1) group that contains the element k.
2) group that does not contain the element k.
Consider first group, the special element k is in all r selections. Since k is part of r elements, we need to
choose (r – 1) elements from remaining (n – 1 ) elements, there are n-1cr-1 ways.
Consider second group, the special element k is not there in all r selections, i.e. we will have to select all the r
elements from available (n – 1 ) elements (as we must exclude element k from n). This can be done in n-1cr
ways.
Now it is evident that sum of these two is selecting r elements from n elements.
There can be many ways to prove the above fact. There might be many applications of Pascal’s Identity.
Please share your knowledge.
Given a sequence of words, print all anagrams together | Set 1
Given an array of words, print all anagrams together. For example, if the given array is {“cat”, “dog”, “tac”,
“god”, “act”}, then output may be “cat tac act dog god”.
A simple method is to create a Hash Table. Calculate the hash value of each word in such a way that all
anagrams have the same hash value. Populate the Hash Table with these hash values. Finally, print those
words together with same hash values. A simple hashing mechanism can be modulo sum of all characters.
With modulo sum, two non-anagram words may have same hash value. This can be handled by matching
individual characters.
Following is another method to print all anagrams together. Take two auxiliary arrays, index array and
word array. Populate the word array with the given sequence of words. Sort each individual word of the word
array. Finally, sort the word array and keep track of the corresponding indices. After sorting, all the
anagrams cluster together. Use the index array to print the strings from the original array of strings.
Let us understand the steps with following input Sequence of Words:

"cat", "dog", "tac", "god", "act"

1) Create two auxiliary arrays index[] and words[]. Copy all given words to words[] and store the original
indexes in index[]
index[]: 0 1 2 3 4
words[]: cat dog tac god act

2) Sort individual words in words[]. Index array doesn’t change.
index[]: 0 1 2 3 4
words[]: act dgo act dgo act

3) Sort the words array. Compare individual words using strcmp() to sort
index: 0 2 4 1 3
words[]: act act act dgo dgo

4) All anagrams come together. But words are changed in words array. To print the original words, take
index from the index array and use it in the original array. We get

"cat tac act dog god"

Following is C implementation of the above algorithm. In the following program, an array of structure
“Word” is used to store both index and word arrays. DupArray is another structure that stores array of
structure “Word”.
// A program to print all anagarms together

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// structure for each word of duplicate array

struct Word
{
char* str; // to store word itself
int index; // index of the word in the original array
};
// structure to represent duplicate array.

struct DupArray
{
struct Word* array; // Array of words
int size; // Size of array
};
// Create a DupArray object that contains an array of Words

struct DupArray* createDupArray(char* str[], int size)
{
// Allocate memory for dupArray and all members of it
struct DupArray* dupArray =
(struct DupArray*) malloc( sizeof(struct DupArray) );
dupArray->size = size;
dupArray->array =
(struct Word*) malloc( dupArray->size * sizeof(struct Word) );
// One by one copy words from the given wordArray to dupArray

int i;
for (i = 0; i < size; ++i)
{
dupArray->array[i].index = i;
dupArray->array[i].str = (char*) malloc( strlen(str[i]) + 1 );
strcpy(dupArray->array[i].str, str[i] );
}
return dupArray;
}
// Compare two characters. Used in qsort() for sorting an array of characters (Word)
int compChar(const void* a, const void* b)
{
return *(char*)a - *(char*)b;
}
// Compare two words. Used in qsort() for sorting an array of words

int compStr(const void* a, const void* b)
{
struct Word* a1 = (struct Word *)a;
struct Word* b1 = (struct Word *)b;
return strcmp(a1->str, b1->str);
}
// Given a list of words in wordArr[],

void printAnagramsTogether(char* wordArr[], int size)
{
// Step 1: Create a copy of all words present in given wordArr.
// The copy will also have orignal indexes of words
struct DupArray* dupArray = createDupArray(wordArr, size);
// Step 2: Iterate through all words in dupArray and sort individual words.
int i;
for (i = 0; i < size; ++i)
qsort(dupArray->array[i].str,
strlen(dupArray->array[i].str), sizeof(char), compChar);
// Step 3: Now sort the array of words in dupArray

qsort(dupArray->array, size, sizeof(dupArray->array[0]), compStr);
// Step 4: Now all words in dupArray are together, but these words are
// changed. Use the index member of word struct to get the corresponding
// original word
for (i = 0; i < size; ++i)
printf("%s ", wordArr[dupArray->array[i].index]);
}

int main()
{
char* wordArr[] = {"cat", "dog", "tac", "god", "act"};
int size = sizeof(wordArr) / sizeof(wordArr[0]);
printAnagramsTogether(wordArr, size);
return 0;
}

Output:

act tac cat god dog

Time Complexity: Let there be N words and each word has maximum M characters. The upper bound is
O(NMLogM + MNLogN).
Step 2 takes O(NMLogM) time. Sorting a word takes maximum O(MLogM) time. So sorting N words takes
O(NMLogM) time. step 3 takes O(MNLogN) Sorting array of words takes NLogN comparisons. A
comparison may take maximum O(M) time. So time to sort array of words will be O(MNLogN).
We will soon be publishing more efficient methods to solve this problem. Please write comments if you find
anything incorrect, or you want to share more information about the topic discussed above.
Given a sequence of words, print all anagrams together | Set 2
Given an array of words, print all anagrams together. For example, if the given array is {“cat”, “dog”, “tac”,
“god”, “act”}, then output may be “cat tac act dog god”.
We have discussed two different methods in the previous post. In this post, a more efficient solution is
discussed.
Trie data structure can be used for a more efficient solution. Insert the sorted order of each word in the trie.
Since all the anagrams will end at the same leaf node. We can start a linked list at the leaf nodes where each
node represents the index of the original array of words. Finally, traverse the Trie. While traversing the Trie,
traverse each linked list one line at a time. Following are the detailed steps.
1) Create an empty Trie

2) One by one take all words of input sequence. Do following for each word
…a) Copy the word to a buffer.
…b) Sort the buffer
…c) Insert the sorted buffer and index of this word to Trie. Each leaf node of Trie is head of a Index list. The
Index list stores index of words in original sequence. If sorted buffe is already present, we insert index of this
word to the index list.
3) Traverse Trie. While traversing, if you reach a leaf node, traverse the index list. And print all words using
the index obtained from Index list.
// An efficient program to print all anagrams together

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
// Structure to represent list node for indexes of words in

// the given sequence. The list nodes are used to connect
// anagrams at leaf nodes of Trie
struct IndexNode
{
int index;
struct IndexNode* next;
};
// Structure to represent a Trie Node

struct TrieNode
{
bool isEnd; // indicates end of word
struct TrieNode* child[NO_OF_CHARS]; // 26 slots each for 'a' to 'z'
struct IndexNode* head; // head of the index list
};
// A utility function to create a new Trie node

struct TrieNode* newTrieNode()
{
struct TrieNode* temp = new TrieNode;
temp->isEnd = 0;
temp->head = NULL;
for (int i = 0; i < NO_OF_CHARS; ++i)
temp->child[i] = NULL;
return temp;
}
}

int compare(const void* a, const void* b)
{ return *(char*)a - *(char*)b; }
/* A utility function to create a new linked list node */

struct IndexNode* newIndexNode(int index)
{
struct IndexNode* temp = new IndexNode;
temp->index = index;
temp->next = NULL;
return temp;
}
// A utility function to insert a word to Trie

void insert(struct TrieNode** root, char* word, int index)
{
// Base case
if (*root == NULL)
*root = newTrieNode();
if (*word != '\0')
insert( &( (*root)->child[tolower(*word) - 'a'] ), word+1, index );
else // If end of the word reached
{
// Insert index of this word to end of index linked list
if ((*root)->isEnd)
{
IndexNode* pCrawl = (*root)->head;
while( pCrawl->next )
pCrawl = pCrawl->next;
pCrawl->next = newIndexNode(index);
}
else // If Index list is empty
{
(*root)->isEnd = 1;
(*root)->head = newIndexNode(index);
}
}
}
// This function traverses the built trie. When a leaf node is reached,
// all words connected at that leaf node are anagrams. So it traverses
// the list at leaf node and uses stored index to print original words
void printAnagramsUtil(struct TrieNode* root, char *wordArr[])
{
if (root == NULL)
return;
// If a lead node is reached, print all anagrams using the indexes

// stored in index linked list
if (root->isEnd)
{
// traverse the list
IndexNode* pCrawl = root->head;
while (pCrawl != NULL)
{
printf( "%s \n", wordArr[ pCrawl->index ] );
}
}
for (int i = 0; i < NO_OF_CHARS; ++i)
printAnagramsUtil(root->child[i], wordArr);
}
// The main function that prints all anagrams together. wordArr[] is input
// sequence of words.
{
// Create an empty Trie
struct TrieNode* root = NULL;
// Iterate through all input words

for (int i = 0; i < size; ++i)
{
// Create a buffer for this word and copy the word to buffer
int len = strlen(wordArr[i]);
char *buffer = new char[len+1];
strcpy(buffer, wordArr[i]);
// Sort the buffer

qsort( (void*)buffer, strlen(buffer), sizeof(char), compare );
// Insert the sorted buffer and its original index to Trie

insert(&root, buffer, i);
}
// Traverse the built Trie and print all anagrms together

printAnagramsUtil(root, wordArr);
}

int main()
{
char* wordArr[] = {"cat", "dog", "tac", "god", "act", "gdo"};
int size = sizeof(wordArr) / sizeof(wordArr[0]);
printAnagramsTogether(wordArr, size);
return 0;
}

Output:

cat
tac
act
dog
god
gdo

discussed above.
Union-Find Algorithm | Set 2 (Union By Rank and Path Compression)
In the previous post, we introduced union find algorithm and used it to detect cycle in a graph. We used
following union() and find() operations for subsets.
// Naive implementation of find

int find(int parent[], int i)
{
if (parent[i] == -1)
return i;
return find(parent, parent[i]);
}

// Naive implementation of union()
void Union(int parent[], int x, int y)
{
int xset = find(parent, x);
int yset = find(parent, y);
parent[xset] = yset;
}

The above union() and find() are naive and the worst case time complexity is linear. The trees created to
represent subsets can be skewed and can become like a linked list. Following is an example worst case
scenario.
Let there be 4 elements 0, 1, 2, 3
Initially all elements are single element subsets.

0 1 2 3
Do Union(0, 1)
1 2 3
/
0
Do Union(1, 2)
2 3
/
1
/
0
Do Union(2, 3)
3
/
2
/
1
/
0

The above operations can be optimized to O(Log n) in worst case. The idea is to always attach smaller depth
tree under the root of the deeper tree. This technique is called union by rank. The term rank is preferred
instead of height because if path compression technique (we have discussed it below) is used, then rank is
not always equal to height. Also, size (in place of height) of trees can also be used as rank. Using size as rank
also yields worst case time complexity as O(Logn) (See this for prrof)
Let us see the above example with union by rank

Initially all elements are single element subsets.
0 1 2 3
Do Union(0, 1)
1 2 3
/
0
Do Union(1, 2)
1 3
/ \
0 2
Do Union(2, 3)
1
/ | \
0 2 3

The second optimization to naive method is Path Compression. The idea is to flatten the tree when find()
is called. When find() is called for an element x, root of the tree is returned. The find() operation traverses up
from x to find root. The idea of path compression is to make the found root as parent of x so that we don’t
have to traverse all intermediate nodes again. If x is root of a subtree, then path (to root) from all nodes
under x also compresses.

Let the subset {0, 1, .. 9} be represented as below and find() is called
for element 3.
9
/ | \
4 5 6
/ \ / \
0 3 7 8
/ \
1 2
When find() is called for 3, we traverse up and find 9 as representative

of this subset. With path compression, we also make 3 as child of 9 so
that when find() is called next time for 1, 2 or 3, the path to root is
reduced.
9
/ / \ \
4 5 6 3
/ / \ / \
0 7 8 1 2
The two techniques complement each other. The time complexity of each operations becomes even smaller
than O(Logn). In fact, amortized time complexity effectively becomes small constant.
Following is union by rank and path compression based implementation to find cycle in a graph.
// A union by rank and path compression based program to detect cycle in a graph
#include <stdio.h>
#include <stdlib.h>
// a structure to represent an edge in graph

struct Edge
{
int src, dest;
};
// a structure to represent a graph

struct Graph
{
// V-> Number of vertices, E-> Number of edges
int V, E;
// graph is represented as an array of edges

struct Edge* edge;
};
struct subset
{
int parent;
int rank;
};
// Creates a graph with V vertices and E edges

struct Graph* createGraph(int V, int E)
{
struct Graph* graph = (struct Graph*) malloc( sizeof(struct Graph) );
graph->V = V;
graph->E = E;
graph->edge = (struct Edge*) malloc( graph->E * sizeof( struct Edge ) );
return graph;
}
// A utility function to find set of an element i

// (uses path compression technique)
int find(struct subset subsets[], int i)
{
// find root and make root as parent of i (path compression)
if (subsets[i].parent != i)
subsets[i].parent = find(subsets, subsets[i].parent);
return subsets[i].parent;
}
// A function that does union of two sets of x and y

// (uses union by rank)
void Union(struct subset subsets[], int x, int y)
{
int xroot = find(subsets, x);
int yroot = find(subsets, y);
// Attach smaller rank tree under root of high rank tree

// (Union by Rank)
if (subsets[xroot].rank < subsets[yroot].rank)
subsets[xroot].parent = yroot;
else if (subsets[xroot].rank > subsets[yroot].rank)
subsets[yroot].parent = xroot;
// If ranks are same, then make one as root and increment

// its rank by one
else
{
subsets[xroot].rank++;
}
}
// The main function to check whether a given graph contains cycle or not
int isCycle( struct Graph* graph )
{
int V = graph->V;
int E = graph->E;
// Allocate memory for creating V sets

struct subset *subsets =
(struct subset*) malloc( V * sizeof(struct subset) );
for (int v = 0; v < V; ++v)

{
subsets[v].parent = v;
subsets[v].rank = 0;
}
// Iterate through all edges of graph, find sets of both

// vertices of every edge, if sets are same, then there is
// cycle in graph.
for(int e = 0; e < E; ++e)
{
int x = find(subsets, graph->edge[e].src);
int y = find(subsets, graph->edge[e].dest);
if (x == y)
return 1;
Union(subsets, x, y);
}
return 0;
}

int main()
{
/* Let us create following graph
0
| \
| \
1-----2 */
int V = 3, E = 3;
struct Graph* graph = createGraph(V, E);
// add edge 0-1

graph->edge[0].src = 0;
graph->edge[0].dest = 1;
// add edge 1-2

// add edge 0-2
if (isCycle(graph))
printf( "Graph contains cycle" );
else
printf( "Graph doesn't contain cycle" );
return 0;
}

Output:


We will soon be discussing Kruskal’s Algorithm as next application of Union-Find Algorithm.
References:
http://en.wikipedia.org/wiki/Disjoint-set_data_structure
IITD Video Lecture
discussed above.
Union-Find Algorithm | Set 1 (Detect Cycle in a an Undirected Graph)
A disjoint-set data structure is a data structure that keeps track of a set of elements partitioned into a
number of disjoint (non-overlapping) subsets. A union-find algorithm is an algorithm that performs two
useful operations on such a data structure:
Find: Determine which subset a particular element is in. This can be used for determining if two elements
are in the same subset.
Union: Join two subsets into a single subset.
In this post, we will discuss an application of Disjoint Set Data Structure. The application is to check
whether a given graph contains a cycle or not.
Union-Find Algorithm can be used to check whether an undirected graph contains cycle or not. Note that we
have discussed an algorithm to detect cycle. This is another method based on Union-Find. This method
assumes that graph doesn’t contain any self-loops.
We can keeps track of the subsets in a 1D array, lets call it parent[].
Let us consider the following graph:
0
| \
| \
1-----2

For each edge, make subsets using both the vertices of the edge. If both the vertices are in the same subset, a
cycle is found.
Initially, all slots of parent array are initialized to -1 (means there is only one item in every subset).
0 1 2
-1 -1 -1

Now process all edges one by one.
Edge 0-1: Find the subsets in which vertices 0 and 1 are. Since they are in different subsets, we take the
union of them. For taking the union, either make node 0 as parent of node 1 or vice-versa.
0 1 2
Edge 1-2: 1 is in subset 1 and 2 is in subset 2. So, take union.

0 1 2
Edge 0-2: 0 is in subset 2 and 2 is also in subset 2. Hence, including this edge forms
a cycle.
How subset of 0 is same as 2?
0->1->2 // 1 is parent of 0 and 2 is parent of 1

Based on the above explanation, below is the code:

// A union-find algorithm to detect cycle in a graph
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// a structure to represent an edge in graph

struct Edge
{
int src, dest;
};
// a structure to represent a graph

struct Graph
{
int V, E;
// graph is represented as an array of edges

struct Edge* edge;
};

{
graph->V = V;
graph->E = E;
return graph;
}
// A utility function to find the subset of an element i

int find(int parent[], int i)
{
return i;
return find(parent, parent[i]);
}
// A utility function to do union of two subsets

void Union(int parent[], int x, int y)
{
int xset = find(parent, x);
int yset = find(parent, y);
parent[xset] = yset;
}
// The main function to check whether a given graph contains cycle or not
int isCycle( struct Graph* graph )
{
// Allocate memory for creating V subsets
int *parent = (int*) malloc( graph->V * sizeof(int) );
// Initialize all subsets as single element sets

memset(parent, -1, sizeof(int) * graph->V);
// Iterate through all edges of graph, find subset of both

// Iterate through all edges of graph, find subset of both
// vertices of every edge, if both subsets are same, then there is
// cycle in graph.
for(int i = 0; i < graph->E; ++i)
{
int x = find(parent, graph->edge[i].src);
int y = find(parent, graph->edge[i].dest);
if (x == y)
return 1;
Union(parent, x, y);
}
return 0;
}

int main()
{
/* Let us create following graph
0
| \
| \
1-----2 */
struct Graph* graph = createGraph(3, 3);
// add edge 0-1

// add edge 1-2

// add edge 0-2

if (isCycle(graph))
printf( "Graph contains cycle" );
else
printf( "Graph doesn't contain cycle" );
return 0;
}

Output:
Note that the implementation of union() and find() is naive and takes O(n) time in wor
st case. These methods can be improved to O(Logn) using Union by Rank or Height. We w
ill soon be discussing Union by Rank in a separate post.
This article is compiled by Aashish Barnwal and reviewed by GeeksforGeeks team. Please
write comments if you find anything incorrect, or you want to share more information a
bout the topic discussed above.

Greedy Algorithms | Set 2 (Kruskal’s Minimum Spanning Tree Algorithm)
What is Minimum Spanning Tree?
Given a connected and undirected graph, a spanning tree of that graph is a subgraph that is a tree and
connects all the vertices together. A single graph can have many different spanning trees. A minimum
spanning tree (MST) or minimum weight spanning tree for a weighted, connected and undirected graph is a
spanning tree with weight less than or equal to the weight of every other spanning tree. The weight of a
spanning tree is the sum of weights given to each edge of the spanning tree.
How many edges does a minimum spanning tree has?

A minimum spanning tree has (V – 1) edges where V is the number of vertices in the given graph.
What are the applications of Minimum Spanning Tree?

See this for applications of MST.
Below are the steps for finding MST using Kruskal’s algorithm
1. Sort all the edges in non-decreasing order of their weight.
2. Pick the smallest edge. Check if it forms a cycle with the spanning tree
formed so far. If cycle is not formed, include this edge. Else, discard it.
3. Repeat step#2 until there are (V-1) edges in the spanning tree.

The step#2 uses Union-Find algorithm to detect cycle. So we recommend to read following post as a
prerequisite.
Union-Find Algorithm | Set 1 (Detect Cycle in a Graph)
Union-Find Algorithm | Set 2 (Union By Rank and Path Compression)
The algorithm is a Greedy Algorithm. The Greedy Choice is to pick the smallest weight edge that does not
cause a cycle in the MST constructed so far. Let us understand it with an example: Consider the below input
graph.
The graph contains 9 vertices and 14 edges. So, the minimum spanning tree formed will be having (9 – 1) = 8
edges.

After sorting:
Weight Src Dest
1 7 6
2 8 2
2 6 5
4 0 1
4 2 5
6 8 6
7 2 3
7 7 8
8 0 7
8 1 2
9 3 4
10 5 4
11 1 7
14 3 5

Now pick all edges one by one from sorted list of edges
1. Pick edge 7-6: No cycle is formed, include it.

6. Pick edge 8-6: Since including this edge results in cycle, discard it.
Since the number of edges included equals (V – 1), the algorithm stops here.
// Kruskal's algortihm to find Minimum Spanning Tree of a given connected,

// undirected and weighted graph
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// a structure to represent a weighted edge in graph

struct Edge
{
int src, dest, weight;
};
// a structure to represent a connected, undirected and weighted graph

struct Graph
{
int V, E;
// graph is represented as an array of edges. Since the graph is

// undirected, the edge from src to dest is also edge from dest
// to src. Both are counted as 1 edge here.
struct Edge* edge;
};

{
graph->V = V;
graph->E = E;
return graph;
}
// A structure to represent a subset for union-find

struct subset
{
int parent;
int rank;
};

{
// find root and make root as parent of i (path compression)
subsets[i].parent = find(subsets, subsets[i].parent);
}

{
// Attach smaller rank tree under root of high rank tree

// (Union by Rank)
// If ranks are same, then make one as root and increment

// its rank by one
else
{
}
}
// Compare two edges according to their weights.

// Used in qsort() for sorting an array of edges
int myComp(const void* a, const void* b)
{
struct Edge* a1 = (struct Edge*)a;
struct Edge* b1 = (struct Edge*)b;
return a1->weight > b1->weight;
}
// The main function to construct MST using Kruskal's algorithm

void KruskalMST(struct Graph* graph)
{
{
int V = graph->V;
struct Edge result[V]; // Tnis will store the resultant MST
int e = 0; // An index variable, used for result[]
int i = 0; // An index variable, used for sorted edges
// Step 1: Sort all the edges in non-decreasing order of their weight

// If we are not allowed to change the given graph, we can create a copy of
// array of edges
qsort(graph->edge, graph->E, sizeof(graph->edge[0]), myComp);
// Allocate memory for creating V ssubsets

struct subset *subsets =
(struct subset*) malloc( V * sizeof(struct subset) );
// Create V subsets with single elements

for (int v = 0; v < V; ++v)
{
}
// Number of edges to be taken is equal to V-1

while (e < V - 1)
{
// Step 2: Pick the smallest edge. And increment the index
// for next iteration
struct Edge next_edge = graph->edge[i++];
int x = find(subsets, next_edge.src);

int y = find(subsets, next_edge.dest);
// If including this edge does't cause cycle, include it

// in result and increment the index of result for next edge
if (x != y)
{
result[e++] = next_edge;
Union(subsets, x, y);
}
// Else discard the next_edge
}
// print the contents of result[] to display the built MST

printf("Following are the edges in the constructed MST\n");
for (i = 0; i < e; ++i)
printf("%d -- %d == %d\n", result[i].src, result[i].dest,
result[i].weight);
return;
}

int main()
{
/* Let us create following weighted graph
10
0--------1
| \ |
6| 5\ |15
| \ |
2--------3
4 */
int V = 4; // Number of vertices in graph
int E = 5; // Number of edges in graph
// add edge 0-1
graph->edge[0].weight = 10;
// add edge 0-2

// add edge 0-3

// add edge 1-3

// add edge 2-3

KruskalMST(graph);
return 0;
}

Following are the edges in the constructed MST
2 -- 3 == 4
0 -- 3 == 5
0 -- 1 == 10

Time Complexity: O(ElogE) or O(ElogV). Sorting of edges takes O(ELogE) time. After sorting, we iterate
through all edges and apply find-union algorithm. The find and union operations can take atmost O(LogV)
time. So overall complexity is O(ELogE + ELogV) time. The value of E can be atmost V^2, so O(LogV) are
O(LogE) same. Therefore, overall time complexity is O(ElogE) or O(ElogV)
References:
http://en.wikipedia.org/wiki/Minimum_spanning_tree
Predict the output of following Java Programs:
// filename: Test.java
class Test {
int x = 10;
System.out.println(t.x);
}
}

The program works fine and prints 10. Unlike C++, in Java, members can initialized with declaration of
class. This initialization works well when the initialization value is available and the initialization can be put
on one line (See this for more details). For example, the following program also works fine.
class Test {
int y = 2;
int x = y+2;
Test m = new Test();
System.out.println("x = " + m.x + ", y = " + m.y);
}
}

Output of the above program is “x = 4, y = 2″. y is initialized first, then x is initialized as y + 2. So the value of
x becomes 4.
What happen when a member is initialized in class declaration and constructor both? Consider the following
program.
public class Test
{
int x = 2;
Test(int i) { x = i; }
Test t = new Test(5);
System.out.println("x = " + t.x);
}
}

Output of the above program is “x = 5″. The initialization with class declaration in Java is like initialization
using Initializer List in C++. So, in the above program, the value assigned inside the constructor overwrites
the previous value of x which is 2, and x becomes 5.
As an exercise, predict the output of following program.

// filename: Test2.java
class Test1 {
Test1(int x) {
System.out.println("Constructor called " + x);
}
}

// This class contains an instance of Test1
class Test2 {
Test1 t1 = new Test1(10);

Test2(int i) { t1 = new Test1(i); }

Test2 t2 = new Test2(5);
}
}

Pascal’s Triangle
Pascal’s triangle is a triangular array of the binomial coefficients. Write a function that takes an integer value
n as input and prints first n lines of the Pascal’s triangle. Following are the first 6 rows of Pascal’s Triangle.
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1

Method 1 ( O(n^3) time complexity )

Number of entries in every line is equal to line number. For example, the first line has “1”, the second line
has “1 1″, the third line has “1 2 1″,.. and so on. Every entry in a line is value of a Binomial Coefficient. The
value of ith entry in line number line is C(line, i). The value can be calculated using following formula.
C(line, i) = line! / ( (line-i)! * i! )

A simple method is to run two loops and calculate the value of Binomial Coefficient in inner loop.

// A simple O(n^3) program for Pascal's Triangle

#include <stdio.h>
// See http://www.geeksforgeeks.org/archives/25621 for details of this function

int binomialCoeff(int n, int k);
// Function to print first n lines of Pascal's Triangle

void printPascal(int n)
{
// Iterate through every line and print entries in it
for (int line = 0; line < n; line++)
{
// Every line has number of integers equal to line number
for (int i = 0; i <= line; i++)
printf("%d ", binomialCoeff(line, i));
printf("\n");
}
}
// See http://www.geeksforgeeks.org/archives/25621 for details of this function

{
int res = 1;
if (k > n - k)
k = n - k;
for (int i = 0; i < k; ++i)
{
res *= (n - i);
res /= (i + 1);
}
return res;
}

int main()
{
int n = 7;
printPascal(n);
return 0;
}

Time complexity of this method is O(n^3). Following are optimized methods.
Method 2( O(n^2) time and O(n^2) extra space )

If we take a closer at the triangle, we observe that every entry is sum of the two values above it. So we can
create a 2D array that stores previously generated values. To generate a value in a line, we can use the
previously stored values from array.

// A O(n^2) time and O(n^2) extra space method for Pascal's Triangle
{
int arr[n][n]; // An auxiliary array to store generated pscal triangle values
// Iterate through every line and print integer(s) in it

for (int line = 0; line < n; line++)
{
// Every line has number of integers equal to line number
{
// First and last values in every row are 1
if (line == i || i == 0)
arr[line][i] = 1;
else // Other values are sum of values just above and left of above
arr[line][i] = arr[line-1][i-1] + arr[line-1][i];
printf("%d ", arr[line][i]);
}
printf("\n");
}
}

This method can be optimized to use O(n) extra space as we need values only from previous row. So we can
create an auxiliary array of size n and overwrite values. Following is another method uses only O(1) extra
space.
Method 3 ( O(n^2) time and O(1) extra space )

This method is based on method 1. We know that ith entry in a line number line is Binomial Coefficient
C(line, i) and all lines start with value 1. The idea is to calculate C(line, i) using C(line, i-1). It can be
calculated in O(1) time using the following.
C(line, i) = line! / ( (line-i)! * i! )

C(line, i-1) = line! / ( (line - i + 1)! * (i-1)! )
We can derive following expression from above two expressions.
C(line, i) = C(line, i-1) * (line - i + 1) / i
So C(line, i) can be calculated from C(line, i-1) in O(1) time

// A O(n^2) time and O(1) extra space function for Pascal's Triangle
{
for (int line = 1; line <= n; line++)
{
int C = 1; // used to represent C(line, i)
{
printf("%d ", C); // The first value in a line is always 1
C = C * (line - i) / i;
}
printf("\n");
}
}

So method 3 is the best method among all, but it may cause integer overflow for large values of n as it
multiplies two integers to obtain values.
This article is compiled by Rahul and reviewed by GeeksforGeeks team. Please write comments if you find
Greedy Algorithms | Set 3 (Huffman Coding)
Huffman coding is a lossless data compression algorithm. The idea is to assign variable-legth codes to input
characters, lengths of the assigned codes are based on the frequencies of corresponding characters. The most
frequent character gets the smallest code and the least frequent character gets the largest code.
The variable-length codes assigned to input characters are Prefix Codes, means the codes (bit sequences) are
assigned in such a way that the code assigned to one character is not prefix of code assigned to any other
character. This is how Huffman Coding makes sure that there is no ambiguity when decoding the generated
bit stream.
Let us understand prefix codes with a counter example. Let there be four characters a, b, c and d, and their
corresponding variable length codes be 00, 01, 0 and 1. This coding leads to ambiguity because code
assigned to c is prefix of codes assigned to a and b. If the compressed bit stream is 0001, the de-compressed
output may be “cccd” or “ccb” or “acd” or “ab”.
See this for applications of Huffman Coding.
There are mainly two major parts in Huffman Coding

1) Build a Huffman Tree from input characters.
2) Traverse the Huffman Tree and assign codes to characters.
Steps to build Huffman Tree

Input is array of unique characters along with their frequency of occurrences and output is Huffman Tree.
1. Create a leaf node for each unique character and build a min heap of all leaf nodes (Min Heap is used as a
priority queue. The value of frequency field is used to compare two nodes in min heap. Initially, the least
frequent character is at root)
2. Extract two nodes with the minimum frequency from the min heap.
3. Create a new internal node with frequency equal to the sum of the two nodes frequencies. Make the first
extracted node as its left child and the other extracted node as its right child. Add this node to the min heap.
4. Repeat steps#2 and #3 until the heap contains only one node. The remaining node is the root node and
the tree is complete.
Let us understand the algorithm with an example:
character Frequency
a 5
b 9
c 12
d 13
e 16
f 45

Step 1. Build a min heap that contains 6 nodes where each node represents root of a tree with single node.
Step 2 Extract two minimum frequency nodes from min heap. Add a new internal node with frequency 5 +
9 = 14.
Now min heap contains 5 nodes where 4 nodes are roots of trees with single element each, and one heap
node is root of tree with 3 elements
character Frequency
c 12
d 13
Internal Node 14
e 16
f 45

Step 3: Extract two minimum frequency nodes from heap. Add a new internal node with frequency 12 + 13
= 25
Now min heap contains 4 nodes where 2 nodes are roots of trees with single element each, and two heap
nodes are root of tree with more than one nodes.
character Frequency
Internal Node 14
e 16
Internal Node 25
f 45

Step 4: Extract two minimum frequency nodes. Add a new internal node with frequency 14 + 16 = 30
Now min heap contains 3 nodes.
character Frequency
Internal Node 25
Internal Node 30
f 45

Now min heap contains 2 nodes.
character Frequency
f 45
Internal Node 55

Now min heap contains only one node.
character Frequency
Internal Node 100

Since the heap contains only one node, the algorithm stops here.
Steps to print codes from Huffman Tree:

Traverse the tree formed starting from the root. Maintain an auxiliary array. While moving to the left child,
write 0 to the array. While moving to the right child, write 1 to the array. Print the array when a leaf node is
encountered.
The codes are as follows:

character code-word
f 0
c 100
d 101
a 1100
b 1101
e 111

// C program for Huffman Coding

#include <stdio.h>
#include <stdlib.h>
// This constant can be avoided by explicitly calculating height of Huffman Tree

#define MAX_TREE_HT 100
// A Huffman tree node

struct MinHeapNode
{
char data; // One of the input characters
unsigned freq; // Frequency of the character
struct MinHeapNode *left, *right; // Left and right child of this node
};
// A Min Heap: Collection of min heap (or Hufmman tree) nodes

struct MinHeap
{
unsigned size; // Current size of min heap
unsigned capacity; // capacity of min heap
struct MinHeapNode **array; // Attay of minheap node pointers
};
// A utility function allocate a new min heap node with given character
// and frequency of the character
struct MinHeapNode* newNode(char data, unsigned freq)
{
struct MinHeapNode* temp =
(struct MinHeapNode*) malloc(sizeof(struct MinHeapNode));
temp->data = data;
temp->freq = freq;
return temp;
}
// A utility function to create a min heap of given capacity

struct MinHeap* createMinHeap(unsigned capacity)
{
struct MinHeap* minHeap =
(struct MinHeap*) malloc(sizeof(struct MinHeap));
minHeap->size = 0; // current size is 0
minHeap->array =
(struct MinHeapNode**)malloc(minHeap->capacity * sizeof(struct MinHeapNode*));
return minHeap;
}
// A utility function to swap two min heap nodes

void swapMinHeapNode(struct MinHeapNode** a, struct MinHeapNode** b)
{
struct MinHeapNode* t = *a;
*a = *b;
*b = t;
}

void minHeapify(struct MinHeap* minHeap, int idx)
{
int smallest = idx;
int left = 2 * idx + 1;
int right = 2 * idx + 2;
if (left < minHeap->size &&

minHeap->array[left]->freq < minHeap->array[smallest]->freq)
smallest = left;
if (right < minHeap->size &&

minHeap->array[right]->freq < minHeap->array[smallest]->freq)
smallest = right;
if (smallest != idx)
{
swapMinHeapNode(&minHeap->array[smallest], &minHeap->array[idx]);
minHeapify(minHeap, smallest);
}
}
// A utility function to check if size of heap is 1 or not

int isSizeOne(struct MinHeap* minHeap)
{
return (minHeap->size == 1);
}
// A standard function to extract minimum value node from heap

struct MinHeapNode* extractMin(struct MinHeap* minHeap)
{
struct MinHeapNode* temp = minHeap->array[0];
minHeap->array[0] = minHeap->array[minHeap->size - 1];
--minHeap->size;
minHeapify(minHeap, 0);
return temp;
}
// A utility function to insert a new node to Min Heap

void insertMinHeap(struct MinHeap* minHeap, struct MinHeapNode* minHeapNode)
{
++minHeap->size;
int i = minHeap->size - 1;
while (i && minHeapNode->freq < minHeap->array[(i - 1)/2]->freq)
{
minHeap->array[i] = minHeap->array[(i - 1)/2];
i = (i - 1)/2;
}
minHeap->array[i] = minHeapNode;
}
// A standard funvtion to build min heap

void buildMinHeap(struct MinHeap* minHeap)
{
int n = minHeap->size - 1;
int i;
for (i = (n - 1) / 2; i >= 0; --i)
minHeapify(minHeap, i);
}
// A utility function to print an array of size n

void printArr(int arr[], int n)
{
int i;
for (i = 0; i < n; ++i)
printf("%d", arr[i]);
printf("\n");
}
// Utility function to check if this node is leaf

int isLeaf(struct MinHeapNode* root)
{
return !(root->left) && !(root->right) ;
}
// Creates a min heap of capacity equal to size and inserts all character of
// data[] in min heap. Initially size of min heap is equal to capacity
struct MinHeap* createAndBuildMinHeap(char data[], int freq[], int size)
{
struct MinHeap* minHeap = createMinHeap(size);
minHeap->array[i] = newNode(data[i], freq[i]);
minHeap->size = size;
buildMinHeap(minHeap);
return minHeap;
}
// The main function that builds Huffman tree

struct MinHeapNode* buildHuffmanTree(char data[], int freq[], int size)
{
struct MinHeapNode *left, *right, *top;
// Step 1: Create a min heap of capacity equal to size. Initially, there are
// modes equal to size.
struct MinHeap* minHeap = createAndBuildMinHeap(data, freq, size);
// Iterate while size of heap doesn't become 1

while (!isSizeOne(minHeap))
{
// Step 2: Extract the two minimum freq items from min heap
left = extractMin(minHeap);
right = extractMin(minHeap);
// Step 3: Create a new internal node with frequency equal to the

// sum of the two nodes frequencies. Make the two extracted node as
// left and right children of this new node. Add this node to the min heap
// '$' is a special value for internal nodes, not used
top = newNode('$', left->freq + right->freq);
top->left = left;
top->right = right;
insertMinHeap(minHeap, top);
}
// Step 4: The remaining node is the root node and the tree is complete.
return extractMin(minHeap);
}
// Prints huffman codes from the root of Huffman Tree. It uses arr[] to
// store codes
void printCodes(struct MinHeapNode* root, int arr[], int top)
{
// Assign 0 to left edge and recur
if (root->left)
{
arr[top] = 0;
printCodes(root->left, arr, top + 1);
}
// Assign 1 to right edge and recur

if (root->right)
{
arr[top] = 1;
printCodes(root->right, arr, top + 1);
}
// If this is a leaf node, then it contains one of the input

// characters, print the character and its code from arr[]
if (isLeaf(root))
{
printf("%c: ", root->data);
printArr(arr, top);
}
}
// The main function that builds a Huffman Tree and print codes by traversing
// the built Huffman Tree
void HuffmanCodes(char data[], int freq[], int size)
{
// Construct Huffman Tree
struct MinHeapNode* root = buildHuffmanTree(data, freq, size);
// Print Huffman codes using the Huffman tree built above

int arr[MAX_TREE_HT], top = 0;
printCodes(root, arr, top);
}

int main()
{
char arr[] = {'a', 'b', 'c', 'd', 'e', 'f'};
int freq[] = {5, 9, 12, 13, 16, 45};
HuffmanCodes(arr, freq, size);
return 0;
}

f: 0
c: 100
d: 101
a: 1100
b: 1101
e: 111

Time complexity: O(nlogn) where n is the number of unique characters. If there are n nodes, extractMin()
is called 2*(n – 1) times. extractMin() takes O(logn) time as it calles minHeapify(). So, overall complexity is
O(nlogn).
If the input array is sorted, there exists a linear time algorithm. We will soon be discussing in our next post.
Reference:
http://en.wikipedia.org/wiki/Huffman_coding
Greedy Algorithms | Set 4 (Efficient Huffman Coding for Sorted Input)
We recommend to read following post as a prerequisite for this.
Greedy Algorithms | Set 3 (Huffman Coding)
Time complexity of the algorithm discussed in above post is O(nLogn). If we know that the given array is
sorted (by non-decreasing order of frequency), we can generate Huffman codes in O(n) time. Following is a
O(n) algorithm for sorted input.
1. Create two empty queues.
2. Create a leaf node for each unique character and Enqueue it to the first queue in non-decreasing order of
frequency. Initially second queue is empty.
3. Dequeue two nodes with the minimum frequency by examining the front of both queues. Repeat following
steps two times
…..a) If second queue is empty, dequeue from first queue.
…..b) If first queue is empty, dequeue from second queue.
…..c) Else, compare the front of two queues and dequeue the minimum.
4. Create a new internal node with frequency equal to the sum of the two nodes frequencies. Make the first
Dequeued node as its left child and the second Dequeued node as right child. Enqueue this node to second
queue.
5. Repeat steps#3 and #4 until there is more than one node in the queues. The remaining node is the root
node and the tree is complete.
// C Program for Efficient Huffman Coding for Sorted input

#include <stdio.h>
#include <stdlib.h>
// This constant can be avoided by explicitly calculating height of Huffman Tree

#define MAX_TREE_HT 100
// A node of huffman tree

struct QueueNode
{
char data;
unsigned freq;
struct QueueNode *left, *right;
};
// Structure for Queue: collection of Huffman Tree nodes (or QueueNodes)

struct Queue
{
int front, rear;
int capacity;
struct QueueNode **array;
};
// A utility function to create a new Queuenode

struct QueueNode* newNode(char data, unsigned freq)
{
struct QueueNode* temp =
(struct QueueNode*) malloc(sizeof(struct QueueNode));
temp->data = data;
temp->freq = freq;
return temp;
return temp;
}
// A utility function to create a Queue of given capacity

struct Queue* createQueue(int capacity)
{
struct Queue* queue = (struct Queue*) malloc(sizeof(struct Queue));
queue->capacity = capacity;
queue->array =
(struct QueueNode**) malloc(queue->capacity * sizeof(struct QueueNode*));
return queue;
}
// A utility function to check if size of given queue is 1

int isSizeOne(struct Queue* queue)
{
return queue->front == queue->rear && queue->front != -1;
}
// A utility function to check if given queue is empty

int isEmpty(struct Queue* queue)
{
}
// A utility function to check if given queue is full

int isFull(struct Queue* queue)
{
return queue->rear == queue->capacity - 1;
}
// A utility function to add an item to queue

void enQueue(struct Queue* queue, struct QueueNode* item)
{
if (isFull(queue))
return;
queue->array[++queue->rear] = item;
if (queue->front == -1)
++queue->front;
}
// A utility function to remove an item from queue

struct QueueNode* deQueue(struct Queue* queue)
{
if (isEmpty(queue))
return NULL;
struct QueueNode* temp = queue->array[queue->front];
if (queue->front == queue->rear) // If there is only one item in queue
else
++queue->front;
return temp;
}
// A utility function to get from of queue

struct QueueNode* getFront(struct Queue* queue)
{
if (isEmpty(queue))
return NULL;
return queue->array[queue->front];
}
/* A function to get minimum item from two queues */

struct QueueNode* findMin(struct Queue* firstQueue, struct Queue* secondQueue)
struct QueueNode* findMin(struct Queue* firstQueue, struct Queue* secondQueue)
{
// Step 3.a: If second queue is empty, dequeue from first queue
if (isEmpty(firstQueue))
return deQueue(secondQueue);
// Step 3.b: If first queue is empty, dequeue from second queue

if (isEmpty(secondQueue))
return deQueue(firstQueue);
// Step 3.c: Else, compare the front of two queues and dequeue minimum
if (getFront(firstQueue)->freq < getFront(secondQueue)->freq)
return deQueue(firstQueue);
}
// Utility function to check if this node is leaf

int isLeaf(struct QueueNode* root)
{
return !(root->left) && !(root->right) ;
}

{
int i;
for (i = 0; i < n; ++i)
printf("%d", arr[i]);
printf("\n");
}
// The main function that builds Huffman tree

struct QueueNode* buildHuffmanTree(char data[], int freq[], int size)
{
struct QueueNode *left, *right, *top;
// Step 1: Create two empty queues

struct Queue* firstQueue = createQueue(size);
struct Queue* secondQueue = createQueue(size);
// Step 2:Create a leaf node for each unique character and Enqueue it to
// the first queue in non-decreasing order of frequency. Initially second
// queue is empty
enQueue(firstQueue, newNode(data[i], freq[i]));
// Run while Queues contain more than one node. Finally, first queue will
// be empty and second queue will contain only one node
while (!(isEmpty(firstQueue) && isSizeOne(secondQueue)))
{
// Step 3: Dequeue two nodes with the minimum frequency by examining
// the front of both queues
left = findMin(firstQueue, secondQueue);
right = findMin(firstQueue, secondQueue);
// Step 4: Create a new internal node with frequency equal to the sum
// of the two nodes frequencies. Enqueue this node to second queue.
top = newNode('$' , left->freq + right->freq);
top->left = left;
top->right = right;
enQueue(secondQueue, top);
}
}
// Prints huffman codes from the root of Huffman Tree. It uses arr[] to
// store codes
void printCodes(struct QueueNode* root, int arr[], int top)
{
if (root->left)
{
arr[top] = 0;
printCodes(root->left, arr, top + 1);
}
// Assign 1 to right edge and recur

if (root->right)
{
arr[top] = 1;
printCodes(root->right, arr, top + 1);
}
// If this is a leaf node, then it contains one of the input

// characters, print the character and its code from arr[]
if (isLeaf(root))
{
printf("%c: ", root->data);
printArr(arr, top);
}
}
// The main function that builds a Huffman Tree and print codes by traversing
// the built Huffman Tree
void HuffmanCodes(char data[], int freq[], int size)
{
// Construct Huffman Tree
struct QueueNode* root = buildHuffmanTree(data, freq, size);
// Print Huffman codes using the Huffman tree built above

int arr[MAX_TREE_HT], top = 0;
printCodes(root, arr, top);
}

int main()
{
char arr[] = {'a', 'b', 'c', 'd', 'e', 'f'};
int freq[] = {5, 9, 12, 13, 16, 45};
HuffmanCodes(arr, freq, size);
return 0;
}

Output:

f: 0
c: 100
d: 101
a: 1100
b: 1101
e: 111

If the input is not sorted, it need to be sorted first before it can be processed by the above algorithm. Sorting
can be done using heap-sort or merge-sort both of which run in Theta(nlogn). So, the overall time
complexity becomes O(nlogn) for unsorted input.
Reference:
http://en.wikipedia.org/wiki/Huffman_coding
Select a random number from stream, with O(1) space
Given a stream of numbers, generate a random number from the stream. You are allowed to use only O(1)
space and the input is in the form of stream, so can’t store the previously seen numbers.
So how do we generate a random number from the whole stream such that the probability of picking any
number is 1/n. with O(1) extra space? This problem is a variation of Reservoir Sampling. Here the value of k
is 1.
1) Initialize ‘count’ as 0, ‘count’ is used to store count of numbers seen so far in stream.
2) For each number ‘x’ from stream, do following
…..a) Increment ‘count’ by 1.
…..b) If count is 1, set result as x, and return result.
…..c) Generate a random number from 0 to ‘count-1′. Let the generated random number be i.
…..d) If i is equal to ‘count – 1′, update the result as x.
// An efficient program to randomly select a number from stream of numbers.

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
// A function to randomly select a item from stream[0], stream[1], .. stream[i-1]

int selectRandom(int x)
{
static int res; // The resultant random number
static int count = 0; //Count of numbers visited so far in stream
count++; // increment count of numbers seen so far
// If this is the first element from stream, return it

if (count == 1)
res = x;
else
{
// Generate a random number from 0 to count - 1
int i = rand() % count;
// Replace the prev random number with new number with 1/count probability
if (i == count - 1)
res = x;
}
return res;
}

int main()
{
int stream[] = {1, 2, 3, 4};
int n = sizeof(stream)/sizeof(stream[0]);
// Use a different seed value for every run.

srand(time(NULL));
for (int i = 0; i < n; ++i)
printf("Random number from first %d numbers is %d \n",
i+1, selectRandom(stream[i]));
return 0;
}

Output:

Random number from first 1 numbers is 1

How does this work

We need to prove that every element is picked with 1/n probability where n is the number of items seen so
far. For every new stream item x, we pick a random number from 0 to ‘count -1′, if the picked number is
‘count-1′, we replace the previous result with x.
To simplify proof, let us first consider the last element, the last element replaces the previously stored result
with 1/n probability. So probability of getting last element as result is 1/n.
Let us now talk about second last element. When second last element processed first time, the probability
that it replaced the previous result is 1/(n-1). The probability that previous result stays when nth item is
considered is (n-1)/n. So probability that the second last element is picked in last iteration is [1/(n-1)] * [(n-
1)/n] which is 1/n.
Similarly, we can prove for third last element and others.
References:
Reservoir Sampling
discussed above.
[TopTalent.in] How Tech companies Like Their Résumés
Have all the skills require to be a great Software Engineer? Here are 9 tips to make your résumé look just like
how the Tech Companies want them to be. After all, your résumé is the most powerful ship to a perfect job,
suitable for your skills.
1. The Opening: If your résumé starts with “Objective: To utilize my knowledge, skills and abilities as a
Software Engineer” then you can definitely bid the job a farewell.
2. Long = Boring: Unless you have 10+ years of experience, your résumé’s length cannot exceed one page.
When the HR professional has only get 15 seconds to read someone’s resume, paragraphs would simply get
overlooked. Use bullets which are short (1-2 lines) and ideally, no more than half of the bullets should be 2
lines.
3. Always provide specifics: You can speak about all the positions you held and companies you worked
for, but it may all go in vain. Most HR professionals don’t have time to interview you just to bring those
specifics out. Focus on specific accomplishments, not responsibilities. Just that one point, arguably, can give
you an edge over most people in the pile of résumé.
4. Grammar Voes: I know we have endlessly told this (Read Your résumé is your sharpest sword, keep it
sharp and clean ), but it deserves repetition. Grievous spelling errors = trash can. As simple as that. In
today’s world, poor mastery of the English language is not acceptable – even if your job is related to coding
and developing software.
5. Ignore the obvious: You have experience with Windows and MS Office? Please tell the person more,
because that definitely is uninteresting. Furthermore, No acronyms on the résumé unless the word is very
popular in the industry.
6. Best format for experience: Unless the company you’re applying for is huge, where you are sure that
only keyword matching systems can get your résumé from the mail box to the HR official’s table please
avoid listing every single programming language that you’ve worked with on your resume. Here’s a good
example of a format which provides the key words that Applicant Tracking Systems search for, at the same
time giving any recruiter a better idea of how you used each technology at each of your jobs.
What it should be like:
Software Engineer, Company X 2007- present:
– Coded a web application using JavaScript, HTML5, and CSS3
– Designed and implemented a JSON/REST API to allow access to the Company database
What it shouldn’t be like:
Programming languages known: C, C++, Java, C#, Python, JavaScript, Visual Basic, Visual C#, Visual
Basic .NET, and so on. A dozen languages listed together don’t make much sense. How can you make it
worse? By listing all the versions of a language you’ve used.
7. More content, less space: Use a good resume template, with columns. This will allow you to fit more
content on your resume while making it easier to scan for key information like company names and titles.
3 lines –
Microsoft Corporation
Software Engineer
2008 – 2011
1 line –
Software Engineer Microsoft Corporation 2008 – 2011
8. Team vs. You: The HR guy knows that most of your work in companies must be team work. But, he is
hiring you. So, tell them what you specifically built, created, implemented, designed, programmed. But
showing that you are team focussed and good with adapting to team work is also a good thing to do
9. Failure can be great: To conclude, we advise you to stop thinking about what does and doesn’t belong
on a resume and start thinking about whether something makes you look more or less awesome. For
example, a large number of people decide not to include meaty projects because they were for a class
assignment/independent projects/unfinished/unsuccessful. But coding is coding, and your exposure to real
work rather than courses at college can put you in a really good position. Links to code (having a GitHub link
is a great thing), portfolio work, or publicly visible projects can also act as positive things on your résumé.
This article is powered by TopTalent.in – A high end Job portal for students and alumni of Premier
Colleges in India. Sign up now for free exclusive access to top notch jobs in India and abroad. Get in touch
with them via facebook, twitter or linkedin. If you like GeeksforGeeks and would like to contribute, you can
also write an article and mail your article to contribute@geeksforgeeks.org. See your article appearing on the
GeeksforGeeks main page and help other Geeks
Implement Stack using Queues
The problem is opposite of this post. We are given a Queue data structure that supports standard operations
like enqueue() and dequeue(). We need to implement a Stack data structure using only instances of Queue.
A stack can be implemented using two queues. Let stack to be implemented be ‘s’ and queues used to
implement be ‘q1′ and ‘q2′. Stack ‘s’ can be implemented in two ways:
Method 1 (By making push operation costly)

This method makes sure that newly entered element is always at the front of ‘q1′, so that pop operation just
dequeues from ‘q1′. ‘q2′ is used to put every new element at front of ‘q1′.
push(s, x) // x is the element to be pushed and s is stack

1) Enqueue x to q2
2) One by one dequeue everything from q1 and enqueue to q2.
3) Swap the names of q1 and q2
// Swapping of names is done to avoid one more movement of all elements
// from q2 to q1.
pop(s)
1) Dequeue an item from q1 and return it.

Method 2 (By making pop operation costly)

In push operation, the new element is always enqueued to q1. In pop() operation, if q2 is empty then all the
elements except the last, are moved to q2. Finally the last element is dequeued from q1 and returned.
push(s, x)
1) Enqueue x to q1 (assuming size of q1 is unlimited).
pop(s)
1) One by one dequeue everything except the last element from q1 and enqueue to q2.
2) Dequeue the last item of q1, the dequeued item is result, store it.
3) Swap the names of q1 and q2
4) Return the item stored in step 2.
// Swapping of names is done to avoid one more movement of all elements
// from q2 to q1.

References:
Implement Stack using Two Queues
This article is compiled by Sumit Jain and reviewed by GeeksforGeeks team. Please write comments if you
find anything incorrect, or you want to share more information about the topic discussed above.
Predict the output of following Java Programs:
Question 1
// file name: Main.java
class Base {
protected void foo() {}
}
void foo() {}
}
public class Main {
Derived d = new Derived();
d.foo();
}
}


foo() is protected in Base and default in Derived. Default access is more restrictive. When a derived class
overrides a base class function, more restrictive access can’t be given to the overridden function. If we make
foo() public, then the program works fine without any error. The behavior in C++ is different. C++ allows to
give more restrictive access to derived class methods.
Question 2
// file name: Main.java
class Complex {
public String toString() {
return "(" + re + " + " + im + "i)";
}
Complex(Complex c) {
re = c.re;
im = c.im;
}
}
public class Main {

Complex c1 = new Complex();
Complex c2 = new Complex(c1);
System.out.println(c2);
}
}

Output: Compiler Error in line “Complex c1 = new Complex();”

In Java, if we write our own copy constructor or parameterized constructor, then compiler doesn’t create the
default constructor. This behavior is same as C++.
discussed above.
Find the largest multiple of 2, 3 and 5
An array of size n is given. The array contains digits from 0 to 9. Generate the largest number using the
digits in the array such that the number is divisible by 2, 3 and 5.
For example, if the arrays is {1, 8, 7, 6, 0}, output must be: 8760. And if the arrays is {7, 7, 7, 6}, output must
be: “no number can be formed”.
Source: Amazon Interview | Set 7
This problem is a variation of “Find the largest multiple of 3“.
Since the number has to be divisible by 2 and 5, it has to have last digit as 0. So if the given array doesn’t
contain any zero, then no solution exists.
Once a 0 is available, extract 0 from the given array. Only thing left is, the number should be is divisible by 3
and the largest of all. Which has been discussed here.
Thanks to shashank for suggesting this solution. Please write comments if you find anything incorrect, or
you want to share more information about the topic discussed above.
Graph and its representations
Graph is a data structure that consists of following two components:
1. A finite set of vertices also called as nodes.
2. A finite set of ordered pair of the form (u, v) called as edge. The pair is ordered because (u, v) is not same
as (v, u) in case of directed graph(di-graph). The pair of form (u, v) indicates that there is an edge from
vertex u to vertex v. The edges may contain weight/value/cost.
Graphs are used to represent many real life applications: Graphs are used to represent networks. The
networks may include paths in a city or telephone network or circuit network. Graphs are also used in social
networks like linkedIn, facebook. For example, in facebook, each person is represented with a vertex(or
node). Each node is a structure and contains information like person id, name, gender and locale. This can
be easily viewed by http://graph.facebook.com/barnwal.aashish where barnwal.aashish is the profile name.
See this for more applications of graph.
Following is an example undirected graph with 5 vertices.
Following two are the most commonly used representations of graph.

1. Adjacency Matrix
2. Adjacency List
There are other representations also like, Incidence Matrix and Incidence List. The choice of the graph
representation is situation specific. It totally depends on the type of operations to be performed and ease of
use.
Adjacency Matrix:
Adjacency Matrix is a 2D array of size V x V where V is the number of vertices in a graph. Let the 2D array be
adj[][], a slot adj[i][j] = 1 indicates that there is an edge from vertex i to vertex j. Adjacency matrix for
undirected graph is always symmetric. Adjacency Matrix is also used to represent weighted graphs. If adj[i]
[j] = w, then there is an edge from vertex i to vertex j with weight w.
The adjacency matrix for the above example graph is:
Adjacency Matrix Representation of the above graph
Pros: Representation is easier to implement and follow. Removing an edge takes O(1) time. Queries like
whether there is an edge from vertex ‘u’ to vertex ‘v’ are efficient and can be done O(1).
Cons: Consumes more space O(V^2). Even if the graph is sparse(contains less number of edges), it
consumes the same space. Adding a vertex is O(V^2) time.
Adjacency List:
An array of linked lists is used. Size of the array is equal to number of vertices. Let the array be array[]. An
entry array[i] represents the linked list of vertices adjacent to the ith vertex. This representation can also be
used to represent a weighted graph. The weights of edges can be stored in nodes of linked lists. Following is
adjacency list representation of the above graph.
Adjacency List Representation of the above Graph
Below is C code for adjacency list representation of an undirected graph:
// A C Program to demonstrate adjacency list representation of graphs
#include <stdio.h>
#include <stdlib.h>
// A structure to represent an adjacency list node

struct AdjListNode
{
int dest;
struct AdjListNode* next;
};
// A structure to represent an adjacency liat

struct AdjList
{
struct AdjListNode *head; // pointer to head node of list
};
// A structure to represent a graph. A graph is an array of adjacency lists.

// Size of array will be V (number of vertices in graph)
struct Graph
{
int V;
struct AdjList* array;
};
// A utility function to create a new adjacency list node

struct AdjListNode* newAdjListNode(int dest)
{
struct AdjListNode* newNode =
(struct AdjListNode*) malloc(sizeof(struct AdjListNode));
newNode->dest = dest;
newNode->next = NULL;
return newNode;
}
// A utility function that creates a graph of V vertices

struct Graph* createGraph(int V)
{
struct Graph* graph = (struct Graph*) malloc(sizeof(struct Graph));
graph->V = V;
// Create an array of adjacency lists. Size of array will be V

graph->array = (struct AdjList*) malloc(V * sizeof(struct AdjList));
// Initialize each adjacency list as empty by making head as NULL

int i;
for (i = 0; i < V; ++i)
graph->array[i].head = NULL;
return graph;
}
// Adds an edge to an undirected graph

void addEdge(struct Graph* graph, int src, int dest)
{
// Add an edge from src to dest. A new node is added to the adjacency
// list of src. The node is added at the begining
struct AdjListNode* newNode = newAdjListNode(dest);
newNode->next = graph->array[src].head;
graph->array[src].head = newNode;
// Since graph is undirected, add an edge from dest to src also

newNode = newAdjListNode(src);
newNode->next = graph->array[dest].head;
graph->array[dest].head = newNode;
}
// A utility function to print the adjacenncy list representation of graph

void printGraph(struct Graph* graph)
{
int v;
for (v = 0; v < graph->V; ++v)
{
struct AdjListNode* pCrawl = graph->array[v].head;
printf("\n Adjacency list of vertex %d\n head ", v);
while (pCrawl)
{
printf("-> %d", pCrawl->dest);
}
printf("\n");
}
}

int main()
{
// create the graph given in above fugure
int V = 5;
struct Graph* graph = createGraph(V);
addEdge(graph, 0, 1);
// print the adjacency list representation of the above graph

printGraph(graph);
return 0;
}

Output:
Adjacency list of vertex 0

head -> 4-> 1

head -> 4-> 3-> 2-> 0

head -> 3-> 1

head -> 4-> 2-> 1

head -> 3-> 1-> 0

Pros: Saves space O(|V|+|E|) . In the worst case, there can be C(V, 2) number of edges in a graph thus
consuming O(V^2) space. Adding a vertex is easier.
Cons: Queries like whether there is an edge from vertex u to vertex v are not efficient and can be done O(V).
Reference:
http://en.wikipedia.org/wiki/Graph_%28abstract_data_type%29
Divide and Conquer | Set 1 (Introduction)
Like Greedy and Dynamic Programming, Divide and Conquer is an algorithmic paradigm. A typical Divide
and Conquer algorithm solves a problem using following three steps.
1. Divide: Break the given problem into subproblems of same type.

2. Conquer: Recursively solve these subproblems
3. Combine: Appropriately combine the answers
Following are some standard algorithms that are Divide and Conquer algorithms.
1) Binary Search is a searching algorithm. In each step, the algorithm compares the input element x with
the value of the middle element in array. If the values match, return the index of middle. Otherwise, if x is
less than the middle element, then the algorithm recurs for left side of middle element, else recurs for right
side of middle element.
2) Quicksort is a sorting algorithm. The algorithm picks a pivot element, rearranges the array elements in
such a way that all elements smaller than the picked pivot element move to left side of pivot, and all greater
elements move to right side. Finally, the algorithm recursively sorts the subarrays on left and right of pivot
element.
3) Merge Sort is also a sorting algorithm. The algorithm divides the array in two halves, recursively sorts
them and finally merges the two sorted halves.
4) Closest Pair of Points The problem is to find the closest pair of points in a set of points in x-y plane.
The problem can be solved in O(n^2) time by calculating distances of every pair of points and comparing the
distances to find the minimum. The Divide and Conquer algorithm solves the problem in O(nLogn) time.
5) Strassen’s Algorithm is an efficient algorithm to multiply two matrices. A simple method to multiply
two matrices need 3 nested loops and is O(n^3). Strassen’s algorithm multiplies two matrices in
O(n^2.8974) time.
6) Cooley–Tukey Fast Fourier Transform (FFT) algorithm is the most common algorithm for FFT.
It is a divide and conquer algorithm which works in O(nlogn) time.
7) Karatsuba algorithm for fast multiplication it does multiplication of two n-digit numbers in at
most
single-digit multiplications in general (and exactly
when n is a power of 2). It is therefore faster than the classical algorithm, which requires n2 single-digit
products. If n = 210 = 1024, in particular, the exact counts are 310 = 59,049 and (210)2 = 1,048,576,
respectively.
We will publishing above algorithms in separate posts.
Divide and Conquer (D & C) vs Dynamic Programming (DP)

Both paradigms (D & C and DP) divide the given problem into subproblems and solve subproblems. How to
choose one of them for a given problem? Divide and Conquer should be used when same subproblems are
not evaluated many times. Otherwise Dynamic Programming or Memoization should be used. For example,
Binary Search is a Divide and Conquer algorithm, we never evaluate the same subproblems again. On the
other hand, for calculating nth Fibonacci number, Dynamic Programming should be preferred (See this for
details).
References
Algorithms by Sanjoy Dasgupta, Christos Papadimitriou, Umesh Vazirani
Introduction to Algorithms by Clifford Stein, Thomas H. Cormen, Charles E. Leiserson, Ronald L.
http://en.wikipedia.org/wiki/Karatsuba_algorithm
discussed above.
Greedy Algorithms | Set 5 (Prim’s Minimum Spanning Tree (MST))
We have discussed Kruskal’s algorithm for Minimum Spanning Tree. Like Kruskal’s algorithm, Prim’s
algorithm is also a Greedy algorithm. It starts with an empty spanning tree. The idea is to maintain two sets
of vertices. The first set contains the vertices already included in the MST, the other set contains the vertices
not yet included. At every step, it considers all the edges that connect the two sets, and picks the minimum
weight edge from these edges. After picking the edge, it moves the other endpoint of the edge to the set
containing MST.
A group of edges that connects two set of vertices in a graph is called cut in graph theory. So, at every step of
Prim’s algorithm, we find a cut (of two sets, one contains the vertices already included in MST and other
contains rest of the verices), pick the minimum weight edge from the cut and include this vertex to MST Set
(the set that contains already included vertices).
How does Prim’s Algorithm Work? The idea behind Prim’s algorithm is simple, a spanning tree means
all vertices must be connected. So the two disjoint subsets (discussed above) of vertices must be connected
to make a Spanning Tree. And they must be connected with the minimum weight edge to make it
a Minimum Spanning Tree.
Algorithm
1) Create a set mstSet that keeps track of vertices already included in MST.
2) Assign a key value to all vertices in the input graph. Initialize all key values as INFINITE. Assign key value
as 0 for the first vertex so that it is picked first.
3) While mstSet doesn’t include all vertices
….a) Pick a vertex u which is not there in mstSet and has minimum key value.
….b) Include u to mstSet.
….c) Update key value of all adjacent vertices of u. To update the key values, iterate through all adjacent
vertices. For every adjacent vertex v, if weight of edge u-v is less than the previous key value of v , update the
key value as weight of u-v
The idea of using key values is to pick the minimum weight edge from cut. The key values are used only for
vertices which are not yet included in MST, the key value for these vertices indicate the minimum weight
edges connecting them to the set of vertices included in MST.
Let us understand with the following example:
The set mstSet is initially empty and keys assigned to vertices are {0, INF, INF, INF, INF, INF, INF, INF}
where INF indicates infinite. Now pick the vertex with minimum key value. The vertex 0 is picked, include it
in mstSet. So mstSet becomes {0}. After including to mstSet, update key values of adjacent vertices. Adjacent
vertices of 0 are 1 and 7. The key values of 1 and 7 are updated as 4 and 8. Following subgraph shows vertices
and their key values, only the vertices with finite key values are shown. The vertices included in MST are
shown in green color.
Pick the vertex with minimum key value and not already included in MST (not in mstSET). The vertex 1 is
picked and added to mstSet. So mstSet now becomes {0, 1}. Update the key values of adjacent vertices of 1.
The key value of vertex 2 becomes 8.
Pick the vertex with minimum key value and not already included in MST (not in mstSET). We can either
pick vertex 7 or vertex 2, let vertex 7 is picked. So mstSet now becomes {0, 1, 7}. Update the key values of
adjacent vertices of 7. The key value of vertex 6 and 8 becomes finite (7 and 1 respectively).
Pick the vertex with minimum key value and not already included in MST (not in mstSET). Vertex 6 is
picked. So mstSet now becomes {0, 1, 7, 6}. Update the key values of adjacent vertices of 6. The key value of
vertex 5 and 8 are updated.
We repeat the above steps until mstSet includes all vertices of given graph. Finally, we get the following
graph.
How to implement the above algorithm?

We use a boolean array mstSet[] to represent the set of vertices included in MST. If a value mstSet[v] is true,
then vertex v is included in MST, otherwise not. Array key[] is used to store key values of all vertices.
Another array parent[] to store indexes of parent nodes in MST. The parent array is the output array which
is used to show the constructed MST.
// A C / C++ program for Prim's Minimum Spanning Tree (MST) algorithm.

// The program is for adjacency matrix representation of the graph
#include <stdio.h>
#include <limits.h>

#define V 5
// A utility function to find the vertex with minimum key value, from
// the set of vertices not yet included in MST
int minKey(int key[], bool mstSet[])
{
// Initialize min value
int min = INT_MAX, min_index;
for (int v = 0; v < V; v++)

if (mstSet[v] == false && key[v] < min)
min = key[v], min_index = v;
return min_index;
}
// A utility function to print the constructed MST stored in parent[]

int printMST(int parent[], int n, int graph[V][V])
{
printf("Edge Weight\n");
for (int i = 1; i < V; i++)
printf("%d - %d %d \n", parent[i], i, graph[i][parent[i]]);
}
// Function to construct and print MST for a graph represented using adjacency
// matrix representation
void primMST(int graph[V][V])
{
int parent[V]; // Array to store constructed MST
int key[V]; // Key values used to pick minimum weight edge in cut
bool mstSet[V]; // To represent set of vertices not yet included in MST
// Initialize all keys as INFINITE

for (int i = 0; i < V; i++)
key[i] = INT_MAX, mstSet[i] = false;
// Always include first 1st vertex in MST.

key[0] = 0; // Make key 0 so that this vertex is picked as first vertex
parent[0] = -1; // First node is always root of MST
// The MST will have V vertices

for (int count = 0; count < V-1; count++)
{
// Pick thd minimum key vertex from the set of vertices
// not yet included in MST
int u = minKey(key, mstSet);
// Add the picked vertex to the MST Set

mstSet[u] = true;
// Update key value and parent index of the adjacent vertices of

// the picked vertex. Consider only those vertices which are not yet
// included in MST
// included in MST
for (int v = 0; v < V; v++)
// graph[u][v] is non zero only for adjacent vertices of m

// mstSet[v] is false for vertices not yet included in MST
// Update the key only if graph[u][v] is smaller than key[v]
if (graph[u][v] && mstSet[v] == false && graph[u][v] < key[v])
parent[v] = u, key[v] = graph[u][v];
}
// print the constructed MST

printMST(parent, V, graph);
}

int main()
{
2 3
(0)--(1)--(2)
| / \ |
6| 8/ \5 |7
| / \ |
(3)-------(4)
9 */
int graph[V][V] = {{0, 2, 0, 6, 0},
{2, 0, 3, 8, 5},
{0, 3, 0, 0, 7},
{6, 8, 0, 0, 9},
{0, 5, 7, 9, 0},
};

primMST(graph);
return 0;
}

Output:
Edge Weight
0 - 1 2
1 - 2 3
0 - 3 6
1 - 4 5

Time Complexity of the above program is O(V^2). If the input graph is represented using adjacency list, then
the time complexity of Prim’s algorithm can be reduced to O(E log V) with the help of binary heap. We will
soon be discussing O(E Log V) algorithm as a separate post.
discussed above.
Construction of Longest Monotonically Increasing Subsequence (N log N)
In my previous post, I have explained about longest monotonically increasing sub-sequence (LIS) problem
in detail. However, the post only covered code related to querying size of LIS, but not the construction of
LIS. I left it as an exercise. If you have solved, cheers. If not, you are not alone, here is code.
If you have not read my previous post, read here. Note that the below code prints LIS in reverse order. We
can modify print order using a stack (explicit or system stack). I am leaving explanation as an exercise
(easy).
#include <iostream>
#include <string.h>
#include <stdio.h>
// Binary search
int GetCeilIndex(int A[], int T[], int l, int r, int key) {
int m;
while( r - l > 1 ) {
m = l + (r - l)/2;
if( A[T[m]] >= key )
r = m;
else
l = m;
}
return r;
}
int LongestIncreasingSubsequence(int A[], int size) {

// Add boundary case, when array size is zero
// Depend on smart pointers
int *tailIndices = new int[size];

int *prevIndices = new int[size];
int len;
memset(tailIndices, 0, sizeof(tailIndices[0])*size);
memset(prevIndices, 0xFF, sizeof(prevIndices[0])*size);
tailIndices[0] = 0;
prevIndices[0] = -1;
len = 1; // it will always point to empty location
for( int i = 1; i < size; i++ ) {
if( A[i] < A[tailIndices[0]] ) {
// new smallest value
tailIndices[0] = i;
} else if( A[i] > A[tailIndices[len-1]] ) {
// A[i] wants to extend largest subsequence
prevIndices[i] = tailIndices[len-1];
tailIndices[len++] = i;
} else {
// A[i] wants to be a potential condidate of future subsequence
// It will replace ceil value in tailIndices
int pos = GetCeilIndex(A, tailIndices, -1, len-1, A[i]);
prevIndices[i] = tailIndices[pos-1];
tailIndices[pos] = i;
}
}
}
cout << "LIS of given input" << endl;
for( int i = tailIndices[len-1]; i >= 0; i = prevIndices[i] )
cout << A[i] << " ";
cout << endl;
delete[] tailIndices;
delete[] prevIndices;
return len;
}
int main() {
int A[] = { 2, 5, 3, 7, 11, 8, 10, 13, 6 };
int size = sizeof(A)/sizeof(A[0]);
printf("LIS size %d\n", LongestIncreasingSubsequence(A, size));
return 0;
}

Exercises:
1. You know Kadane‘s algorithm to find maximum sum sub-array. Modify Kadane’s algorithm to trace
starting and ending location of maximum sum sub-array.
2. Modify Kadane‘s algorithm to find maximum sum sub-array in a circular array. Refer GFG forum for
many comments on the question.
3. Given two integers A and B as input. Find number of Fibonacci numbers existing in between these two
numbers (including A and B). For example, A = 3 and B = 18, there are 4 Fibonacci numbers in between
{3, 5, 8, 13}. Do it in O(log K) time, where K is max(A, B). What is your observation?
Greedy Algorithms | Set 6 (Prim’s MST for Adjacency List Representation)
We recommend to read following two posts as a prerequisite of this post.
1. Greedy Algorithms | Set 5 (Prim’s Minimum Spanning Tree (MST))

2. Graph and its representations
We have discussed Prim’s algorithm and its implementation for adjacency matrix representation of graphs.
The time complexity for the matrix representation is O(V^2). In this post, O(ELogV) algorithm for adjacency
list representation is discussed.
As discussed in the previous post, in Prim’s algorithm, two sets are maintained, one set contains list of
vertices already included in MST, other set contains vertices not yet included. With adjacency list
representation, all vertices of a graph can be traversed in O(V+E) time using BFS. The idea is to traverse all
vertices of graph using BFS and use a Min Heap to store the vertices not yet included in MST. Min Heap is
used as a priority queue to get the minimum weight edge from the cut. Min Heap is used as time complexity
of operations like extracting minimum element and decreasing key value is O(LogV) in Min Heap.

1) Create a Min Heap of size V where V is the number of vertices in the given graph. Every node of min heap
contains vertex number and key value of the vertex.
2) Initialize Min Heap with first vertex as root (the key value assigned to first vertex is 0). The key value
assigned to all other vertices is INF (infinite).
3) While Min Heap is not empty, do following
…..a) Extract the min value node from Min Heap. Let the extracted vertex be u.
…..b) For every adjacent vertex v of u, check if v is in Min Heap (not yet included in MST). If v is in Min
Heap and its key value is more than weight of u-v, then update the key value of v as weight of u-v.
Let us understand the above algorithm with the following example:
Initially, key value of first vertex is 0 and INF (infinite) for all other vertices. So vertex 0 is extracted from
Min Heap and key values of vertices adjacent to 0 (1 and 7) are updated. Min Heap contains all vertices
except vertex 0.
The vertices in green color are the vertices included in MST.
Since key value of vertex 1 is minimum among all nodes in Min Heap, it is extracted from Min Heap and key
values of vertices adjacent to 1 are updated (Key is updated if the a vertex is not in Min Heap and previous
key value is greater than the weight of edge from 1 to the adjacent). Min Heap contains all vertices except
vertex 0 and 1.
vertex 0, 1 and 7.
vertex 0, 1, 7 and 6.
The above steps are repeated for rest of the nodes in Min Heap till Min Heap becomes empty
// C / C++ program for Prim's MST for adjacency list representation of graph
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
// A structure to represent a node in adjacency list

struct AdjListNode
{
int dest;
int weight;
};

struct AdjList
{
};

struct Graph
{
int V;
};

struct AdjListNode* newAdjListNode(int dest, int weight)
{
newNode->weight = weight;
return newNode;
}

{
graph->V = V;


for (int i = 0; i < V; ++i)
return graph;
}

void addEdge(struct Graph* graph, int src, int dest, int weight)
{
struct AdjListNode* newNode = newAdjListNode(dest, weight);

newNode = newAdjListNode(src, weight);
}
// Structure to represent a min heap node

struct MinHeapNode
{
int v;
int key;
};
// Structure to represent a min heap

struct MinHeap
{
int size; // Number of heap nodes present currently
int capacity; // Capacity of min heap
int *pos; // This is needed for decreaseKey()
struct MinHeapNode **array;
};
// A utility function to create a new Min Heap Node

struct MinHeapNode* newMinHeapNode(int v, int key)
{
struct MinHeapNode* minHeapNode =
minHeapNode->v = v;
minHeapNode->key = key;
return minHeapNode;
}
// A utilit function to create a Min Heap

struct MinHeap* createMinHeap(int capacity)
{
minHeap->pos = (int *)malloc(capacity * sizeof(int));
minHeap->size = 0;
minHeap->array =
(struct MinHeapNode**) malloc(capacity * sizeof(struct MinHeapNode*));
return minHeap;
}
// A utility function to swap two nodes of min heap. Needed for min heapify
{
*a = *b;
*b = t;
}
// A standard function to heapify at given idx

// This function also updates position of nodes when they are swapped.
// Position is needed for decreaseKey()
{
int smallest, left, right;
smallest = idx;
left = 2 * idx + 1;

minHeap->array[left]->key < minHeap->array[smallest]->key )
smallest = left;

minHeap->array[right]->key < minHeap->array[smallest]->key )
smallest = right;
{
// The nodes to be swapped in min heap
MinHeapNode *smallestNode = minHeap->array[smallest];
MinHeapNode *idxNode = minHeap->array[idx];
// Swap positions
// Swap positions
minHeap->pos[smallestNode->v] = idx;
minHeap->pos[idxNode->v] = smallest;
// Swap nodes
}
}
// A utility function to check if the given minHeap is ampty or not

int isEmpty(struct MinHeap* minHeap)
{
return minHeap->size == 0;
}
// Standard function to extract minimum node from heap

{
if (isEmpty(minHeap))
return NULL;
// Store the root node

struct MinHeapNode* root = minHeap->array[0];
// Replace root node with last node

struct MinHeapNode* lastNode = minHeap->array[minHeap->size - 1];
minHeap->array[0] = lastNode;
// Update position of last node

minHeap->pos[root->v] = minHeap->size-1;
minHeap->pos[lastNode->v] = 0;
// Reduce heap size and heapify root

--minHeap->size;
return root;
}
// Function to decreasy key value of a given vertex v. This function

// uses pos[] of min heap to get the current index of node in min heap
void decreaseKey(struct MinHeap* minHeap, int v, int key)
{
// Get the index of v in heap array
int i = minHeap->pos[v];
// Get the node and update its key value

minHeap->array[i]->key = key;
// Travel up while the complete tree is not hepified.

// This is a O(Logn) loop
while (i && minHeap->array[i]->key < minHeap->array[(i - 1) / 2]->key)
{
// Swap this node with its parent
minHeap->pos[minHeap->array[i]->v] = (i-1)/2;
minHeap->pos[minHeap->array[(i-1)/2]->v] = i;
swapMinHeapNode(&minHeap->array[i], &minHeap->array[(i - 1) / 2]);
// move to parent index

i = (i - 1) / 2;
}
}
// A utility function to check if a given vertex
// 'v' is in min heap or not
bool isInMinHeap(struct MinHeap *minHeap, int v)
{
if (minHeap->pos[v] < minHeap->size)
return true;
return false;
}
// A utility function used to print the constructed MST

{
for (int i = 1; i < n; ++i)
printf("%d - %d\n", arr[i], i);
}
// The main function that constructs Minimum Spanning Tree (MST)

// using Prim's algorithm
void PrimMST(struct Graph* graph)
{
int V = graph->V;// Get the number of vertices in graph
int parent[V]; // Array to store constructed MST
int key[V]; // Key values used to pick minimum weight edge in cut
// minHeap represents set E

struct MinHeap* minHeap = createMinHeap(V);
// Initialize min heap with all vertices. Key value of

// all vertices (except 0th vertex) is initially infinite
for (int v = 1; v < V; ++v)
{
parent[v] = -1;
key[v] = INT_MAX;
minHeap->array[v] = newMinHeapNode(v, key[v]);
minHeap->pos[v] = v;
}
// Make key value of 0th vertex as 0 so that it

// is extracted first
key[0] = 0;
minHeap->array[0] = newMinHeapNode(0, key[0]);
minHeap->pos[0] = 0;
// Initially size of min heap is equal to V

minHeap->size = V;
// In the followin loop, min heap contains all nodes

// not yet added to MST.
while (!isEmpty(minHeap))
{
// Extract the vertex with minimum key value
struct MinHeapNode* minHeapNode = extractMin(minHeap);
int u = minHeapNode->v; // Store the extracted vertex number
// Traverse through all adjacent vertices of u (the extracted

// vertex) and update their key values
struct AdjListNode* pCrawl = graph->array[u].head;
{
int v = pCrawl->dest;
// If v is not yet included in MST and weight of u-v is

// less than key value of v, then update key value and
// parent of v
// parent of v
if (isInMinHeap(minHeap, v) && pCrawl->weight < key[v])
{
key[v] = pCrawl->weight;
parent[v] = u;
decreaseKey(minHeap, v, key[v]);
}
}
}
// print edges of MST

printArr(parent, V);
}

int main()
{
// Let us create the graph given in above fugure
int V = 9;
addEdge(graph, 0, 1, 4);
PrimMST(graph);
return 0;
}

Output:

0 - 1
5 - 2
2 - 3
3 - 4
6 - 5
7 - 6
0 - 7
2 - 8

Time Complexity: The time complexity of the above code/algorithm looks O(V^2) as there are two nested
while loops. If we take a closer look, we can observe that the statements in inner loop are executed O(V+E)
times (similar to BFS). The inner loop has decreaseKey() operation which takes O(LogV) time. So overall
time complexity is O(E+V)*O(LogV) which is O((E+V)*LogV) = O(ELogV) (For a connected graph, V =
O(E))
References:
http://en.wikipedia.org/wiki/Prim’s_algorithm
Greedy Algorithms | Set 7 (Dijkstra’s shortest path algorithm)
Given a graph and a source vertex in graph, find shortest paths from source to all vertices in the given graph.
Dijkstra’s algorithm is very similar to Prim’s algorithm for minimum spanning tree. Like Prim’s MST, we
generate a SPT (shortest path tree) with given source as root. We maintain two sets, one set contains vertices
included in shortest path tree, other set includes vertices not yet included in shortest path tree. At every step
of the algorithm, we find a vertex which is in the other set (set of not yet included) and has minimum
distance from source.
Below are the detailed steps used in Dijkstra’s algorithm to find the shortest path from a single source vertex
to all other vertices in the given graph.
Algorithm
1) Create a set sptSet (shortest path tree set) that keeps track of vertices included in shortest path tree, i.e.,
whose minimum distance from source is calculated and finalized. Initially, this set is empty.
2) Assign a distance value to all vertices in the input graph. Initialize all distance values as INFINITE. Assign
distance value as 0 for the source vertex so that it is picked first.
3) While sptSet doesn’t include all vertices
….a) Pick a vertex u which is not there in sptSetand has minimum distance value.
….b) Include u to sptSet.
….c) Update distance value of all adjacent vertices of u. To update the distance values, iterate through all
adjacent vertices. For every adjacent vertex v, if sum of distance value of u (from source) and weight of edge
u-v, is less than the distance value of v, then update the distance value of v.
Let us understand with the following example:
The set sptSetis initially empty and distances assigned to vertices are {0, INF, INF, INF, INF, INF, INF,
INF} where INF indicates infinite. Now pick the vertex with minimum distance value. The vertex 0 is picked,
include it in sptSet. So sptSet becomes {0}. After including 0 to sptSet, update distance values of its adjacent
vertices. Adjacent vertices of 0 are 1 and 7. The distance values of 1 and 7 are updated as 4 and 8. Following
subgraph shows vertices and their distance values, only the vertices with finite distance values are shown.
The vertices included in SPT are shown in green color.
Pick the vertex with minimum distance value and not already included in SPT (not in sptSET). The vertex 1
is picked and added to sptSet. So sptSet now becomes {0, 1}. Update the distance values of adjacent vertices
of 1. The distance value of vertex 2 becomes 12.
Pick the vertex with minimum distance value and not already included in SPT (not in sptSET). Vertex 7 is
picked. So sptSet now becomes {0, 1, 7}. Update the distance values of adjacent vertices of 7. The distance
value of vertex 6 and 8 becomes finite (15 and 9 respectively).
Pick the vertex with minimum distance value and not already included in SPT (not in sptSET). Vertex 6 is
picked. So sptSet now becomes {0, 1, 7, 6}. Update the distance values of adjacent vertices of 6. The distance
value of vertex 5 and 8 are updated.
We repeat the above steps until sptSet doesn’t include all vertices of given graph. Finally, we get the
following Shortest Path Tree (SPT).
How to implement the above algorithm?

We use a boolean array sptSet[] to represent the set of vertices included in SPT. If a value sptSet[v] is true,
then vertex v is included in SPT, otherwise not. Array dist[] is used to store shortest distance values of all
vertices.
// A C / C++ program for Dijkstra's single source shortest path algorithm.

// The program is for adjacency matrix representation of the graph
#include <stdio.h>
#include <limits.h>

#define V 9
// A utility function to find the vertex with minimum distance value, from
// the set of vertices not yet included in shortest path tree
int minDistance(int dist[], bool sptSet[])
{
// Initialize min value
int min = INT_MAX, min_index;
for (int v = 0; v < V; v++)

if (sptSet[v] == false && dist[v] <= min)
min = dist[v], min_index = v;
return min_index;
}
// A utility function to print the constructed distance array

int printSolution(int dist[], int n)
{
printf("Vertex Distance from Source\n");
for (int i = 0; i < V; i++)
printf("%d \t\t %d\n", i, dist[i]);
}
// Funtion that implements Dijkstra's single source shortest path algorithm

// for a graph represented using adjacency matrix representation
void dijkstra(int graph[V][V], int src)
{
int dist[V]; // The output array. dist[i] will hold the shortest
// distance from src to i
bool sptSet[V]; // sptSet[i] will true if vertex i is included in shortest

// path tree or shortest distance from src to i is finalized
// Initialize all distances as INFINITE and stpSet[] as false

for (int i = 0; i < V; i++)
dist[i] = INT_MAX, sptSet[i] = false;
// Distance of source vertex from itself is always 0

dist[src] = 0;
// Find shortest path for all vertices

for (int count = 0; count < V-1; count++)
{
// Pick the minimum distance vertex from the set of vertices not
// yet processed. u is always equal to src in first iteration.
int u = minDistance(dist, sptSet);
// Mark the picked vertex as processed

sptSet[u] = true;
// Update dist value of the adjacent vertices of the picked vertex.

for (int v = 0; v < V; v++)
// Update dist[v] only if is not in sptSet, there is an edge from

// u to v, and total weight of path from src to v through u is
// smaller than current value of dist[v]
if (!sptSet[v] && graph[u][v] && dist[u] != INT_MAX
&& dist[u]+graph[u][v] < dist[v])
dist[v] = dist[u] + graph[u][v];
}
// print the constructed distance array

printSolution(dist, V);
printSolution(dist, V);
}

int main()
{
/* Let us create the example graph discussed above */
int graph[V][V] = {{0, 4, 0, 0, 0, 0, 0, 8, 0},
{4, 0, 8, 0, 0, 0, 0, 11, 0},
{0, 8, 0, 7, 0, 4, 0, 0, 2},
{0, 0, 7, 0, 9, 14, 0, 0, 0},
{0, 0, 0, 9, 0, 10, 0, 0, 0},
{0, 0, 4, 0, 10, 0, 2, 0, 0},
{0, 0, 0, 14, 0, 2, 0, 1, 6},
{8, 11, 0, 0, 0, 0, 1, 0, 7},
{0, 0, 2, 0, 0, 0, 6, 7, 0}
};
dijkstra(graph, 0);
return 0;
}

Output:

Vertex Distance from Source
0 0
1 4
2 12
3 19
4 21
5 11
6 9
7 8
8 14

Notes:
1) The code calculates shortest distance, but doesn’t calculate the path information. We can create a parent
array, update the parent array when distance is updated (like prim’s implementation) and use it show the
shortest path from source to different vertices.
2) The code is for undirected graph, same dijekstra function can be used for directed graphs also.
3) The code finds shortest distances from source to all vertices. If we are interested only in shortest distance
from source to a single target, we can break the for loop when the picked minimum distance vertex is equal
to target (Step 3.a of algorithm).
4) Time Complexity of the implementation is O(V^2). If the input graph is represented using adjacency list,
it can be reduced to O(E log V) with the help of binary heap. We will soon be discussing O(E Log V)
algorithm as a separate post.
5) Dijkstra’s algorithm doesn’t work for graphs with negative weight edges. For graphs with negative weight
edges, Bellman–Ford algorithm can be used, we will soon be discussing it as a separate post.
discussed above.
Greedy Algorithms | Set 8 (Dijkstra’s Algorithm for Adjacency List
Representation)
We recommend to read following two posts as a prerequisite of this post.
1. Greedy Algorithms | Set 7 (Dijkstra’s shortest path algorithm)

2. Graph and its representations
We have discussed Dijkstra’s algorithm and its implementation for adjacency matrix representation of
graphs. The time complexity for the matrix representation is O(V^2). In this post, O(ELogV) algorithm for
adjacency list representation is discussed.
As discussed in the previous post, in Dijkstra’s algorithm, two sets are maintained, one set contains list of
vertices already included in SPT (Shortest Path Tree), other set contains vertices not yet included. With
adjacency list representation, all vertices of a graph can be traversed in O(V+E) time using BFS. The idea is
to traverse all vertices of graph using BFS and use a Min Heap to store the vertices not yet included in SPT
(or the vertices for which shortest distance is not finalized yet). Min Heap is used as a priority queue to get
the minimum distance vertex from set of not yet included vertices. Time complexity of operations like
extract-min and decrease-key value is O(LogV) for Min Heap.

1) Create a Min Heap of size V where V is the number of vertices in the given graph. Every node of min heap
contains vertex number and distance value of the vertex.
2) Initialize Min Heap with source vertex as root (the distance value assigned to source vertex is 0). The
distance value assigned to all other vertices is INF (infinite).
3) While Min Heap is not empty, do following
…..a) Extract the vertex with minimum distance value node from Min Heap. Let the extracted vertex be u.
…..b) For every adjacent vertex v of u, check if v is in Min Heap. If v is in Min Heap and distance value is
more than weight of u-v plus distance value of u, then update the distance value of v.
Let us understand with the following example. Let the given source vertex be 0
Initially, distance value of source vertex is 0 and INF (infinite) for all other vertices. So source vertex is
extracted from Min Heap and distance values of vertices adjacent to 0 (1 and 7) are updated. Min Heap
contains all vertices except vertex 0.
The vertices in green color are the vertices for which minimum distances are finalized and are not in Min
Heap
Since distance value of vertex 1 is minimum among all nodes in Min Heap, it is extracted from Min Heap
and distance values of vertices adjacent to 1 are updated (distance is updated if the a vertex is not in Min
Heap and distance through 1 is shorter than the previous distance). Min Heap contains all vertices except
vertex 0 and 1.
Pick the vertex with minimum distance value from min heap. Vertex 7 is picked. So min heap now contains
all vertices except 0, 1 and 7. Update the distance values of adjacent vertices of 7. The distance value of vertex
6 and 8 becomes finite (15 and 9 respectively).
Pick the vertex with minimum distance from min heap. Vertex 6 is picked. So min heap now contains all
vertices except 0, 1, 7 and 6. Update the distance values of adjacent vertices of 6. The distance value of vertex
5 and 8 are updated.
Above steps are repeated till min heap doesn’t become empty. Finally, we get the following shortest path tree.
// C / C++ program for Dijkstra's shortest path algorithm for adjacency

// list representation of graph
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
// A structure to represent a node in adjacency list

struct AdjListNode
{
int dest;
int dest;
int weight;
};

struct AdjList
{
};

struct Graph
{
int V;
};

struct AdjListNode* newAdjListNode(int dest, int weight)
{
newNode->weight = weight;
return newNode;
}

{
graph->V = V;


for (int i = 0; i < V; ++i)
return graph;
}

void addEdge(struct Graph* graph, int src, int dest, int weight)
{
struct AdjListNode* newNode = newAdjListNode(dest, weight);

newNode = newAdjListNode(src, weight);
}
// Structure to represent a min heap node

struct MinHeapNode
{
int v;
int v;
int dist;
};
// Structure to represent a min heap

struct MinHeap
{
int size; // Number of heap nodes present currently
int capacity; // Capacity of min heap
int *pos; // This is needed for decreaseKey()
struct MinHeapNode **array;
};
// A utility function to create a new Min Heap Node

struct MinHeapNode* newMinHeapNode(int v, int dist)
{
struct MinHeapNode* minHeapNode =
minHeapNode->v = v;
minHeapNode->dist = dist;
return minHeapNode;
}
// A utility function to create a Min Heap

{
minHeap->pos = (int *)malloc(capacity * sizeof(int));
minHeap->size = 0;
minHeap->array =
(struct MinHeapNode**) malloc(capacity * sizeof(struct MinHeapNode*));
return minHeap;
}
// A utility function to swap two nodes of min heap. Needed for min heapify
{
*a = *b;
*b = t;
}
// A standard function to heapify at given idx

// This function also updates position of nodes when they are swapped.
// Position is needed for decreaseKey()
{
smallest = idx;
left = 2 * idx + 1;

minHeap->array[left]->dist < minHeap->array[smallest]->dist )
smallest = left;

minHeap->array[right]->dist < minHeap->array[smallest]->dist )
smallest = right;
{
// The nodes to be swapped in min heap
MinHeapNode *smallestNode = minHeap->array[smallest];
MinHeapNode *idxNode = minHeap->array[idx];
// Swap positions
minHeap->pos[smallestNode->v] = idx;
minHeap->pos[idxNode->v] = smallest;
// Swap nodes
}
}
// A utility function to check if the given minHeap is ampty or not

int isEmpty(struct MinHeap* minHeap)
{
return minHeap->size == 0;
}
// Standard function to extract minimum node from heap

{
if (isEmpty(minHeap))
return NULL;
// Store the root node

struct MinHeapNode* root = minHeap->array[0];
// Replace root node with last node

struct MinHeapNode* lastNode = minHeap->array[minHeap->size - 1];
minHeap->array[0] = lastNode;
// Update position of last node

minHeap->pos[root->v] = minHeap->size-1;
minHeap->pos[lastNode->v] = 0;
// Reduce heap size and heapify root

--minHeap->size;
return root;
}
// Function to decreasy dist value of a given vertex v. This function

// uses pos[] of min heap to get the current index of node in min heap
void decreaseKey(struct MinHeap* minHeap, int v, int dist)
{
// Get the index of v in heap array
int i = minHeap->pos[v];
// Get the node and update its dist value

minHeap->array[i]->dist = dist;
// Travel up while the complete tree is not hepified.

// This is a O(Logn) loop
while (i && minHeap->array[i]->dist < minHeap->array[(i - 1) / 2]->dist)
{
// Swap this node with its parent
minHeap->pos[minHeap->array[i]->v] = (i-1)/2;
minHeap->pos[minHeap->array[(i-1)/2]->v] = i;
swapMinHeapNode(&minHeap->array[i], &minHeap->array[(i - 1) / 2]);
// move to parent index
i = (i - 1) / 2;
}
}
// A utility function to check if a given vertex

// 'v' is in min heap or not
bool isInMinHeap(struct MinHeap *minHeap, int v)
{
if (minHeap->pos[v] < minHeap->size)
return true;
return false;
}
// A utility function used to print the solution

void printArr(int dist[], int n)
{
for (int i = 0; i < n; ++i)
}
// The main function that calulates distances of shortest paths from src to all
// vertices. It is a O(ELogV) function
void dijkstra(struct Graph* graph, int src)
{
int V = graph->V;// Get the number of vertices in graph
int dist[V]; // dist values used to pick minimum weight edge in cut
// minHeap represents set E

struct MinHeap* minHeap = createMinHeap(V);
// Initialize min heap with all vertices. dist value of all vertices
for (int v = 0; v < V; ++v)
{
dist[v] = INT_MAX;
minHeap->array[v] = newMinHeapNode(v, dist[v]);
minHeap->pos[v] = v;
}
// Make dist value of src vertex as 0 so that it is extracted first

minHeap->array[src] = newMinHeapNode(src, dist[src]);
minHeap->pos[src] = src;
dist[src] = 0;
decreaseKey(minHeap, src, dist[src]);
// Initially size of min heap is equal to V

minHeap->size = V;
// In the followin loop, min heap contains all nodes

// whose shortest distance is not yet finalized.
while (!isEmpty(minHeap))
{
// Extract the vertex with minimum distance value
struct MinHeapNode* minHeapNode = extractMin(minHeap);
int u = minHeapNode->v; // Store the extracted vertex number
// Traverse through all adjacent vertices of u (the extracted

// vertex) and update their distance values
struct AdjListNode* pCrawl = graph->array[u].head;
{
int v = pCrawl->dest;
// If shortest distance to v is not finalized yet, and distance to v
// through u is less than its previously calculated distance
if (isInMinHeap(minHeap, v) && dist[u] != INT_MAX &&
pCrawl->weight + dist[u] < dist[v])
{
dist[v] = dist[u] + pCrawl->weight;
// update distance value in min heap also

decreaseKey(minHeap, v, dist[v]);
}
}
}
// print the calculated shortest distances

printArr(dist, V);
}

int main()
{
// create the graph given in above fugure
int V = 9;
dijkstra(graph, 0);
return 0;
}

Output:

0 0
1 4
2 12
3 19
4 21
5 11
6 9
7 8
8 14

Time Complexity: The time complexity of the above code/algorithm looks O(V^2) as there are two nested
while loops. If we take a closer look, we can observe that the statements in inner loop are executed O(V+E)
times (similar to BFS). The inner loop has decreaseKey() operation which takes O(LogV) time. So overall
time complexity is O(E+V)*O(LogV) which is O((E+V)*LogV) = O(ELogV)
Note that the above code uses Binary Heap for Priority Queue implementation. Time complexity can be
reduced to O(E + VLogV) using Fibonacci Heap. The reason is, Fibonacci Heap takes O(1) time for decrease-
key operation while Binary Heap takes O(Logn) time.
Notes:
1) The code calculates shortest distance, but doesn’t calculate the path information. We can create a parent
array, update the parent array when distance is updated (like prim’s implementation) and use it show the
shortest path from source to different vertices.
2) The code is for undirected graph, same dijekstra function can be used for directed graphs also.
3) The code finds shortest distances from source to all vertices. If we are interested only in shortest distance
from source to a single target, we can break the for loop when the picked minimum distance vertex is equal
to target (Step 3.a of algorithm).
4) Dijkstra’s algorithm doesn’t work for graphs with negative weight edges. For graphs with negative weight
edges, Bellman–Ford algorithm can be used, we will soon be discussing it as a separate post.
References:
Algorithms by Sanjoy Dasgupta, Christos Papadimitriou, Umesh Vazirani
discussed above.
Divide and Conquer | Set 2 (Closest Pair of Points)
We are given an array of n points in the plane, and the problem is to find out the closest pair of points in the
array. This problem arises in a number of applications. For example, in air-traffic control, you may want to
monitor planes that come too close together, since this may indicate a possible collision. Recall the following
formula for distance between two points p and q.
The Brute force solution is O(n^2), compute the distance between each pair and return the smallest. We can
calculate the smallest distance in O(nLogn) time using Divide and Conquer strategy. In this post, a O(n x
(Logn)^2) approach is discussed. We will be discussing a O(nLogn) approach in a separate post.
Algorithm
Following are the detailed steps of a O(n (Logn)^2) algortihm.
Input: An array of n points P[]
Output: The smallest distance between two points in the given array.
As a pre-processing step, input array is sorted according to x coordinates.
1) Find the middle point in the sorted array, we can take P[n/2] as middle point.
2) Divide the given array in two halves. The first subarray contains points from P[0] to P[n/2]. The second
subarray contains points from P[n/2+1] to P[n-1].
3) Recursively find the smallest distances in both subarrays. Let the distances be dl and dr. Find the
minimum of dl and dr. Let the minimum be d.
4) From above 3 steps, we have an upper bound d of minimum distance. Now we need to consider the pairs
such that one point in pair is from left half and other is from right half. Consider the vertical line passing
through passing through P[n/2] and find all points whose x coordinate is closer than d to the middle vertical
line. Build an array strip[] of all such points.
5) Sort the array strip[] according to y coordinates. This step is O(nLogn). It can be optimized to O(n) by
recursively sorting and merging.
6) Find the smallest distance in strip[]. This is tricky. From first look, it seems to be a O(n^2) step, but it is
actually O(n). It can be proved geometrically that for every point in strip, we only need to check at most 7
points after it (note that strip is sorted according to Y coordinate). See this for more analysis.
7) Finally return the minimum of d and distance calculated in above step (step 6)
Implementation
Following is C/C++ implementation of the above algorithm.
// A divide and conquer program in C/C++ to find the smallest distance from a
// given set of points.
#include <stdio.h>
#include <float.h>
#include <stdlib.h>
#include <math.h>
// A structure to represent a Point in 2D plane

struct Point
{
int x, y;
};

Refer: http://www.cplusplus.com/reference/clibrary/cstdlib/qsort/ */
// Needed to sort array of points according to X coordinate

int compareX(const void* a, const void* b)
{
Point *p1 = (Point *)a, *p2 = (Point *)b;
return (p1->x - p2->x);
}
// Needed to sort array of points according to Y coordinate
int compareY(const void* a, const void* b)
{
return (p1->y - p2->y);
}
// A utility function to find the distance between two points

float dist(Point p1, Point p2)
{
return sqrt( (p1.x - p2.x)*(p1.x - p2.x) +
(p1.y - p2.y)*(p1.y - p2.y)
);
}
// A Brute Force method to return the smallest distance between two points
// in P[] of size n
float bruteForce(Point P[], int n)
{
float min = FLT_MAX;
for (int i = 0; i < n; ++i)
for (int j = i+1; j < n; ++j)
if (dist(P[i], P[j]) < min)
min = dist(P[i], P[j]);
return min;
}
// A utility function to find minimum of two float values
float min(float x, float y)
{
return (x < y)? x : y;
}
// A utility function to find the distance beween the closest points of

// strip of given size. All points in strip[] are sorted accordint to
// y coordinate. They all have an upper bound on minimum distance as d.
// Note that this method seems to be a O(n^2) method, but it's a O(n)
// method as the inner loop runs at most 6 times
float stripClosest(Point strip[], int size, float d)
{
float min = d; // Initialize the minimum distance as d
qsort(strip, size, sizeof(Point), compareY);
// Pick all points one by one and try the next points till the difference
// between y coordinates is smaller than d.
// This is a proven fact that this loop runs at most 6 times
for (int j = i+1; j < size && (strip[j].y - strip[i].y) < min; ++j)
if (dist(strip[i],strip[j]) < min)
min = dist(strip[i], strip[j]);
return min;
}
// A recursive function to find the smallest distance. The array P contains

// all points sorted according to x coordinate
float closestUtil(Point P[], int n)
{
// If there are 2 or 3 points, then use brute force
if (n <= 3)
return bruteForce(P, n);
// Find the middle point

int mid = n/2;
Point midPoint = P[mid];
// Consider the vertical line passing through the middle point

// calculate the smallest distance dl on left of middle point and
// dr on right side
float dl = closestUtil(P, mid);
float dr = closestUtil(P + mid, n-mid);
// Find the smaller of two distances

float d = min(dl, dr);
// Build an array strip[] that contains points close (closer than d)

// to the line passing through the middle point
Point strip[n];
int j = 0;
for (int i = 0; i < n; i++)
if (abs(P[i].x - midPoint.x) < d)
strip[j] = P[i], j++;
// Find the closest points in strip. Return the minimum of d and closest
// distance is strip[]
return min(d, stripClosest(strip, j, d) );
}
// The main functin that finds the smallest distance

// This method mainly uses closestUtil()
float closest(Point P[], int n)
{
qsort(P, n, sizeof(Point), compareX);
// Use recursive function closestUtil() to find the smallest distance

return closestUtil(P, n);
}

int main()
{
Point P[] = {{2, 3}, {12, 30}, {40, 50}, {5, 1}, {12, 10}, {3, 4}};
int n = sizeof(P) / sizeof(P[0]);
printf("The smallest distance is %f ", closest(P, n));
return 0;
}

Output:

The smallest distance is 1.414214

Time Complexity Let Time complexity of above algorithm be T(n). Let us assume that we use a O(nLogn)
sorting algorithm. The above algorithm divides all points in two sets and recursively calls for two sets. After
dividing, it finds the strip in O(n) time, sorts the strip in O(nLogn) time and finally finds the closest points in
strip in O(n) time. So T(n) can expressed as follows
T(n) = 2T(n/2) + O(n) + O(nLogn) + O(n)
T(n) = 2T(n/2) + O(nLogn)
T(n) = T(n x Logn x Logn)
Notes
1) Time complexity can be improved to O(nLogn) by optimizing step 5 of the above algorithm. We will soon
be discussing the optimized solution in a separate post.
2) The code finds smallest distance. It can be easily modified to find the points with smallest distance.
3) The code uses quick sort which can be O(n^2) in worst case. To have the upper bound as O(n (Logn)^2), a
O(nLogn) sorting algorithm like merge sort or heap sort can be used
References:
http://www.cs.umd.edu/class/fall2013/cmsc451/Lects/lect10.pdf
http://www.youtube.com/watch?v=vS4Zn1a9KUc
http://www.youtube.com/watch?v=T3T7T8Ym20M
http://en.wikipedia.org/wiki/Closest_pair_of_points_problem
Dynamic Programming | Set 23 (Bellman–Ford Algorithm)
Given a graph and a source vertex src in graph, find shortest paths from src to all vertices in the given graph.
The graph may contain negative weight edges.
We have discussed Dijkstra’s algorithm for this problem. Dijksra’s algorithm is a Greedy algorithm and time
complexity is O(VLogV) (with the use of Fibonacci heap). Dijkstra doesn’t work for Graphs with negative
weight edges, Bellman-Ford works for such graphs. Bellman-Ford is also simpler than Dijkstra and suites
well for distributed systems. But time complexity of Bellman-Ford is O(VE), which is more than Dijkstra.
Algorithm
Input: Graph and a source vertex src

Output: Shortest distance to all vertices from src. If there is a negative weight cycle, then shortest distances
are not calculated, negative weight cycle is reported.
1) This step initializes distances from source to all vertices as infinite and distance to source itself as 0.
Create an array dist[] of size |V| with all values as infinite except dist[src] where src is source vertex.
2) This step calculates shortest distances. Do following |V|-1 times where |V| is the number of vertices in
given graph.
…..a) Do following for each edge u-v
………………If dist[v] > dist[u] + weight of edge uv, then update dist[v]
………………….dist[v] = dist[u] + weight of edge uv
3) This step reports if there is a negative weight cycle in graph. Do following for each edge u-v
……If dist[v] > dist[u] + weight of edge uv, then “Graph contains negative weight cycle”
The idea of step 3 is, step 2 guarantees shortest distances if graph doesn’t contain negative weight cycle. If we
iterate through all edges one more time and get a shorter path for any vertex, then there is a negative weight
cycle
How does this work? Like other Dynamic Programming Problems, the algorithm calculate shortest paths
in bottom-up manner. It first calculates the shortest distances for the shortest paths which have at-most one
edge in the path. Then, it calculates shortest paths with at-nost 2 edges, and so on. After the ith iteration of
outer loop, the shortest paths with at most i edges are calculated. There can be maximum |V| – 1 edges in any
simple path, that is why the outer loop runs |v| – 1 times. The idea is, assuming that there is no negative
weight cycle, if we have calculated shortest paths with at most i edges, then an iteration over all edges
guarantees to give shortest path with at-most (i+1) edges (Proof is simple, you can refer this or MIT Video
Lecture)
Example
Let us understand the algorithm with following example graph. The images are taken from this source.
Let the given source vertex be 0. Initialize all distances as infinite, except the distance to source itself. Total
number of vertices in the graph is 5, so all edges must be processed 4 times.
Let all edges are processed in following order: (B,E), (D,B), (B,D), (A,B), (A,C), (D,C), (B,C), (E,D). We get
following distances when all edges are processed first time. The first row in shows initial distances. The
second row shows distances when edges (B,E), (D,B), (B,D) and (A,B) are processed. The third row shows
distances when (A,C) is processed. The fourth row shows when (D,C), (B,C) and (E,D) are processed.
The first iteration guarantees to give all shortest paths which are at most 1 edge long. We get following
distances when all edges are processed second time (The last row shows final values).
The second iteration guarantees to give all shortest paths which are at most 2 edges long. The algorithm
processes all edges 2 more times. The distances are minimized after the second iteration, so third and fourth
iterations don’t update the distances.
Implementation:
// A C / C++ program for Bellman-Ford's single source shortest path algorithm.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>

struct Edge
{
};
// a structure to represent a connected, directed and weighted graph

struct Graph
{
int V, E;
// graph is represented as an array of edges.

struct Edge* edge;
};
};

{
graph->V = V;
graph->E = E;
return graph;
}
// A utility function used to print the solution

void printArr(int dist[], int n)
{
for (int i = 0; i < n; ++i)
}
// The main function that finds shortest distances from src to all other
// vertices using Bellman-Ford algorithm. The function also detects negative
// weight cycle
void BellmanFord(struct Graph* graph, int src)
{
int V = graph->V;
int E = graph->E;
int dist[V];
// Step 1: Initialize distances from src to all other vertices as INFINITE

for (int i = 0; i < V; i++)
dist[i] = INT_MAX;
dist[src] = 0;
// Step 2: Relax all edges |V| - 1 times. A simple shortest path from src
// to any other vertex can have at-most |V| - 1 edges
for (int i = 1; i <= V-1; i++)
{
for (int j = 0; j < E; j++)
{
int u = graph->edge[j].src;
int v = graph->edge[j].dest;
int weight = graph->edge[j].weight;
if (dist[u] != INT_MAX && dist[u] + weight < dist[v])
dist[v] = dist[u] + weight;
}
}
// Step 3: check for negative-weight cycles. The above step guarantees

// shortest distances if graph doesn't contain negative weight cycle.
// If we get a shorter path, then there is a cycle.
for (int i = 0; i < E; i++)
{
int u = graph->edge[i].src;
int v = graph->edge[i].dest;
int weight = graph->edge[i].weight;
if (dist[u] != INT_MAX && dist[u] + weight < dist[v])
printf("Graph contains negative weight cycle");
}
printArr(dist, V);
return;
return;
}

int main()
{
/* Let us create the graph given in above example */
// add edge 0-1 (or A-B in above figure)

graph->edge[0].weight = -1;
// add edge 0-2 (or A-C in above figure)

// add edge 1-2 (or B-C in above figure)

// add edge 1-3 (or B-D in above figure)

// add edge 1-4 (or A-E in above figure)

// add edge 3-2 (or D-C in above figure)

// add edge 3-1 (or D-B in above figure)

// add edge 4-3 (or E-D in above figure)

graph->edge[7].weight = -3;
BellmanFord(graph, 0);
return 0;
}

Output:

0 0
1 -1
2 2
3 -2
4 1

Notes
1) Negative weights are found in various applications of graphs. For example, instead of paying cost for a
path, we may get some advantage if we follow the path.
2) Bellman-Ford works better (better than Dijksra’s) for distributed systems. Unlike Dijksra’s where we
need to find minimum value of all vertices, in Bellman-Ford, edges are considered one by one.
Exercise
1) The standard Bellman-Ford algorithm reports shortest path only if there is no negative weight cycles.
Modify it so that it reports minimum distances even if there is a negative weight cycle.
2) Can we use Dijksra’s algorithm for shortest paths for graphs with negative weights – one idea can be,
calculate the minimum weight value, add a positive value (equal to absolute value of minimum weight value)
to all weights and run the Dijksra’s algorithm for the modified graph. Will this algorithm work?
References:
http://www.youtube.com/watch?v=Ttezuzs39nk
http://en.wikipedia.org/wiki/Bellman%E2%80%93Ford_algorithm
http://www.cs.arizona.edu/classes/cs445/spring07/ShortestPath2.prn.pdf
discussed above.
Abstract Classes in Java
In C++, if a class has at least one pure virtual function, then the class becomes abstract. Unlike C++, in Java,
a separate keyword abstract is used to make a class abstract.
// An example abstract class in Java

abstract class Shape {
int color;
// An abstract function (like a pure virtual function in C++)

abstract void draw();
}

Following are some important observations about abstract classes in Java.
1) Like C++, in Java, an instance of an abstract class cannot be created, we can have references of abstract
class type though.
abstract class Base {

abstract void fun();
}
void fun() { System.out.println("Derived fun() called"); }
}
class Main {

// Uncommenting the following line will cause compiler error as the
// line tries to create an instance of abstract class.
// Base b = new Base();
// We can have references of Base type.

Base b = new Derived();
b.fun();
}
}

Output:

Derived fun() called

2) Like C++, an abstract class can contain constructors in Java. And a constructor of abstract class is called
when an instance of a inherited class is created. For example, the following is a valid Java program.

// An abstract class with constructor

Base() { System.out.println("Base Constructor Called"); }
abstract void fun();
}
Derived() { System.out.println("Derived Constructor Called"); }
void fun() { System.out.println("Derived fun() called"); }
}
class Main {
}
}

Output:

Base Constructor Called
Derived Constructor Called

3) In Java, we can have an abstract class without any abstract method. This allows us to create classes that
cannot be instantiated, but can only be inherited.
// An abstract class without any abstract method

void fun() { System.out.println("Base fun() called"); }
}

class Derived extends Base { }

class Main {
d.fun();
}
}

Output:

Base fun() called

4) Abstract classes can also have final methods (methods that cannot be overridden). For example, the
following program compiles and runs fine.

// An abstract class with a final method

final void fun() { System.out.println("Derived fun() called"); }
}

class Derived extends Base {}

class Main {
Base b = new Derived();
b.fun();
}
}

Output:

Derived fun() called

Exercise:
1. Is it possible to create abstract and final class in Java?
2. Is it possible to have an abstract method in a final class?
3. Is it possible to inherit from multiple abstract classes in Java?
discussed above.
Transitive closure of a graph
Given a directed graph, find out if a vertex j is reachable from another vertex i for all vertex pairs (i, j) in the
given graph. Here reachable mean that there is a path from vertex i to j. The reach-ability matrix is called
transitive closure of a graph.
The graph is given in the form of adjacency matrix say ‘graph[V][V]’ where graph[i][j] is 1 if there is an edge
from vertex i to vertex j or i is equal to j, otherwise graph[i][j] is 0.
Floyd Warshall Algorithm can be used, we can calculate the distance matrix dist[V][V] using Floyd Warshall,
if dist[i][j] is infinite, then j is not reachable from i, otherwise j is reachable and value of dist[i][j] will be less
than V.
Instead of directly using Floyd Warshall, we can optimize it in terms of space and time, for this particular
problem. Following are the optimizations:
1) Instead of integer resultant matrix (dist[V][V] in floyd warshall), we can create a boolean reach-ability
matrix reach[V][V] (we save space). The value reach[i][j] will be 1 if j is reachable from i, otherwise 0.
2) Instead of using arithmetic operations, we can use logical operations. For arithmetic operation ‘+’, logical
and ‘&&’ is used, and for min, logical or ‘||’ is used. (We save time by a constant factor. Time complexity is
same though)
// Program for transitive closure using Floyd Warshall Algorithm

#include<stdio.h>

#define V 4
// A function to print the solution matrix

void printSolution(int reach[][V]);
// Prints transitive closure of graph[][] using Floyd Warshall algorithm

void transitiveClosure(int graph[][V])
{
/* reach[][] will be the output matrix that will finally have the shortest
distances between every pair of vertices */
int reach[V][V], i, j, k;
/* Initialize the solution matrix same as input graph matrix. Or

we can say the initial values of shortest distances are based
on shortest paths considering no intermediate vertex. */
for (i = 0; i < V; i++)
for (j = 0; j < V; j++)
reach[i][j] = graph[i][j];
/* Add all vertices one by one to the set of intermediate vertices.

---> Before start of a iteration, we have reachability values for all
pairs of vertices such that the reachability values consider only the
vertices in set {0, 1, 2, .. k-1} as intermediate vertices.
----> After the end of a iteration, vertex no. k is added to the set of
intermediate vertices and the set becomes {0, 1, 2, .. k} */
for (k = 0; k < V; k++)
{
// Pick all vertices as source one by one
for (i = 0; i < V; i++)
{
// Pick all vertices as destination for the
// above picked source
for (j = 0; j < V; j++)
{
{
// If vertex k is on a path from i to j,
// then make sure that the value of reach[i][j] is 1
reach[i][j] = reach[i][j] || (reach[i][k] && reach[k][j]);
}
}
}
// Print the shortest distance matrix

printSolution(reach);
}

void printSolution(int reach[][V])
{
printf ("Following matrix is transitive closure of the given graph\n");
for (int i = 0; i < V; i++)
{
for (int j = 0; j < V; j++)
printf ("%d ", reach[i][j]);
printf("\n");
}
}

int main()
{
/* Let us create the following weighted graph
10
(0)------->(3)
| /|\
5 | |
| | 1
\|/ |
(1)------->(2)
3 */
int graph[V][V] = { {1, 1, 0, 1},
{0, 1, 1, 0},
{0, 0, 1, 1},
{0, 0, 0, 1}
};

transitiveClosure(graph);
return 0;
}

Output:

Following matrix is transitive closure of the given graph
1 1 1 1
0 1 1 1
0 0 1 1
0 0 0 1

Time Complexity: O(V^3) where V is number of vertices in the given graph.
References:
discussed above.
Program to find amount of water in a given glass
There are some glasses with equal capacity as 1 litre. The glasses are kept as follows:
1
2 3
4 5 6
7 8 9 10

You can put water to only top glass. If you put more than 1 litre water to 1st glass, water overflows and fills
equally in both 2nd and 3rd glasses. Glass 5 will get water from both 2nd glass and 3rd glass and so on.
If you have X litre of water and you put that water in top glass, how much water will be contained by jth glass
in ith row?
Example. If you will put 2 litre on top.

1st – 1 litre
2nd – 1/2 litre
3rd – 1/2 litre
Source: Amazon Interview | Set 12
The approach is similar to Method 2 of the Pascal’s Triangle. If we take a closer look at the problem, the
problem boils down to Pascal’s Triangle.
1 ---------------- 1
2 3 ---------------- 2
4 5 6 ------------ 3
7 8 9 10 --------- 4

Each glass contributes to the two glasses down the glass. Initially, we put all water in first glass. Then we
keep 1 litre (or less than 1 litre) in it, and move rest of the water to two glasses down to it. We follow the same
process for the two glasses and all other glasses till ith row. There will be i*(i+1)/2 glasses till ith row.
// Program to find the amount of water in jth glass of ith row

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// Returns the amount of water in jth glass of ith row

float findWater(int i, int j, float X)
{
// A row number i has maximum i columns. So input column number must
// be less than i
if (j > i)
{
printf("Incorrect Input\n");
exit(0);
}
// There will be i*(i+1)/2 glasses till ith row (including ith row)
float glass[i * (i + 1) / 2];
float glass[i * (i + 1) / 2];
// Initialize all glasses as empty

memset(glass, 0, sizeof(glass));
// Put all water in first glass

int index = 0;
glass[index] = X;
// Now let the water flow to the downward glassses till the
// amount of water X is not 0 and row number is less than or
// equal to i (given row)
for (int row = 1; row <= i && X !=0.0; ++row)
{
// Fill glasses in a given row. Number of columns in a row
// is equal to row number
for (int col = 1; col <= row; ++col, ++index)
{
// Get the water from current glass
X = glass[index];
// Keep the amount less than or equal to

// capacity in current glass
glass[index] = (X >= 1.0f) ? 1.0f : X;
// Get the remaining amount

X = (X >= 1.0f) ? (X - 1) : 0.0f;
// Distribute the remaining amount to the down two glasses

glass[index + row] += X / 2;
glass[index + row + 1] += X / 2;
}
}
// The index of jth glass in ith row will be i*(i-1)/2 + j - 1

return glass[i*(i-1)/2 + j - 1];
}

int main()
{
int i = 2, j = 2;
float X = 2.0; // Total amount of water
printf("Amount of water in jth glass of ith row is: %f",

findWater(i, j, X));
return 0;
}

Output:

Amount of water in jth glass of ith row is: 0.500000

Time Complexity: O(i*(i+1)/2) or O(i^2)

Auxiliary Space: O(i*(i+1)/2) or O(i^2)
anything incorrect, or you want to share more information about the topic discussed above
Program to convert a given number to words
Write code to convert a given number into words. For example, if “1234” is given as input, output should be
“one thousand two hundred thirty four”.
Source: Round 3, Q1 of Microsoft Interview | Set 3
Following is C implementation for the same. The code supports numbers up-to 4 digits, i.e., numbers from 0
to 9999. Idea is to create arrays that store individual parts of output strings. One array is used for single
digits, one for numbers from 10 to 19, one for 20, 30, 40, 50, .. etc, and one for powers of 10.
The given number is divided in two parts: first two digits and last two digits, and the two parts are printed
separately.
/* Program to print a given number in words. The program handles

numbers from 0 to 9999 */
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
/* A function that prints given number in words */

void convert_to_words(char *num)
{
int len = strlen(num); // Get number of digits in given number
/* Base cases */
if (len == 0) {
fprintf(stderr, "empty string\n");
return;
}
if (len > 4) {
fprintf(stderr, "Length more than 4 is not supported\n");
return;
}
/* The first string is not used, it is to make array indexing simple */

char *single_digits[] = { "zero", "one", "two", "three", "four",
"five", "six", "seven", "eight", "nine"};
/* The first string is not used, it is to make array indexing simple */

char *two_digits[] = {"", "ten", "eleven", "twelve", "thirteen", "fourteen",
"fifteen", "sixteen", "seventeen", "eighteen", "nineteen"};
/* The first two string are not used, they are to make array indexing simple*/
char *tens_multiple[] = {"", "", "twenty", "thirty", "forty", "fifty",
"sixty", "seventy", "eighty", "ninety"};
char *tens_power[] = {"hundred", "thousand"};
/* Used for debugging purpose only */

printf("\n%s: ", num);
/* For single digit number */

if (len == 1) {
printf("%s\n", single_digits[*num - '0']);
return;
}
/* Iterate while num is not '\0' */

while (*num != '\0') {
/* Code path for first 2 digits */
if (len >= 3) {
if (*num -'0' != 0) {
printf("%s ", single_digits[*num - '0']);
printf("%s ", tens_power[len-3]); // here len can be 3 or 4
}
--len;
}
/* Code path for last 2 digits */

else {
/* Need to explicitly handle 10-19. Sum of the two digits is
used as index of "two_digits" array of strings */
if (*num == '1') {
int sum = *num - '0' + *(num + 1)- '0';
printf("%s\n", two_digits[sum]);
return;
}
/* Need to explicitely handle 20 */

else if (*num == '2' && *(num + 1) == '0') {
printf("twenty\n");
return;
}
/* Rest of the two digit numbers i.e., 21 to 99 */

else {
int i = *num - '0';
printf("%s ", i? tens_multiple[i]: "");
++num;
if (*num != '0')
printf("%s ", single_digits[*num - '0']);
}
}
++num;
}
}

int main(void)
{
convert_to_words("9923");
return 0;
}

Output:

9923: nine thousand nine hundred twenty three
523: five hundred twenty three
89: eighty nine
8989: eight thousand nine hundred eighty nine

[TopTalent.in] Dhananjay Sathe Talks About His GSoC Experience And
How To Hack It
Google Summer of Code (GSoC) is the brain child of the Google founders Larry Page and Sergey Brin and
was first held in the summer of 2005 with an aim to provide some of the most challenging open source
projects to the top talent. Not so surprisingly it is one of the most sought after programs and some of the best
organizations in the world have now opened up their doors for brilliant students from different parts of the
world to collaborate and contribute on their projects. This year for the first time since inception, the highest
number of GSoC participants (227) came from India. IITs, IIITs, BITS Pilani are ruling the roost among
colleges. We had a chance to interact with Dhananjay Sathe who did GSoC for the second time in a row. Let’s
see what he has to say and how you can benefit from his experience.
What is the selection procedure for GSoC and what goes into creating a credible application?
The selection procedure for the Google Summer of Code program is quite straight forward. Technically all
you need is to be above the age of 18 and to be enrolled in any academic program in any of the 193 odd
countries. This means your CGPA, your branch, your stream (yes even folks perusing law, commerce or any
other field can apply) are completely immaterial. Folks perusing research or a PhD can apply too (quite a few
actually do).
You essentially need to come up with a new feature set, fix some nagging bugs or port some code in most
cases. You need to write a proposal for the same, it is then voted on both at Google and the concerned
organization and they select the most promising applications. So be sure the idea is something nifty, cool
and yet achievable in that period.
As for the application itself make sure you give a concrete plan and road-map. Clearly state what
your deliverables are and WHEN, HOW you plan to achieve them. Mention all the open source contributions
and other programming experiences you have (back it up with links to the code, adds a LOT
of credibility). Make sure you have your grammar right, communication is an extremely important part of
GSoC. Last but not the least mention why you would like to work on the project and what they, the end users
and you stand to gain out of it, this shows the thought process, reasoning and commitment.
How did you decide on your project and what prompted this decision?
I have been an avid linux user and FOSS enthusiast since around 2003 when I first got Linux to boot up on
my PC. Using it as a primary OS made me familiar to all the communities, software and norms involved in
this kind of development. It also made me aware of what problems one faces and what new stuff could be
done. I had this habit, perhaps out of frustration with open source software back in those days, if my app
crashed or lacked some functionality I would try to debug it or try and add in the new feature. Samba is a
great and powerful tool to have but unfortunately it has a 8500 line man page and can be quite intimidating
to new users. I found this a major issue in people around me on campus and I thought samba Gtk was a great
way to work on solving that issue. Of course the required background knowledge of Gtk, python and a decent
idea of what samba was and how it works were the final things that culminated in my app to Samba.org
What are the benefits of getting into Gsoc and how does it help further while applying for a
job?
In one word HUGE! If done right, it is perhaps one of the world’s best experiences for aspiring developers. It
exposes you to some of the best developers on the planet. You learn a lot more than you can think possible.
You get to deal with people from multiple time zones and ideologies. You learn about code development
practices, version control, communication, the code base itself and numerous other minor but very
important skills required in the real world but completely missing from the scope of formal academics.
The benefits show in you, you have much better ideas, practices and experience than most of
your contemporaries. Also the folks hiring you realize the value of it all. It gets much simpler to get involved
in new open source projects and further your passion and skillset. You develop a ton of contacts and gain
access to information and opportunities you otherwise wouldn’t know about .Last but not the least, it’s a
huge brownie point to have something concerned with Google and Open Source on your CV.
How should one prepare if they want to land a GSoC project? How was your journey and
what’s next?
Follow your passion for software development, learn something new every week, hack it. The last point is
most essential. People often try reading books and learning a new language or toolkit for the sake of it. Don’t
do that, learn the bare basics, get hold of the source, hack it up and learn as you move ahead. Google has a
great search engine and project wikis have a goldmine of information, make the most of it. It’s never too late
to start, but of course the earlier the better.
I had a blast during my two Summer of Code projects, it was great fun and a lot of learning too. I gained a
LOT from it. I will now be working on the next generation of the internet and robotics – cloud robotics at
ETH Zurich for my bachelors thesis on some exciting stuff with the open source cloud engine. It’s been one
heck of a journey.
This article is powered by TopTalent.in – A high end Job portal for students and alumni of Premier
Colleges in India. Sign up now for free exclusive access to top notch jobs in India and abroad. Get in touch
with them via facebook, twitter or linkedin. If you like GeeksforGeeks and would like to contribute, you can
GeeksforGeeks main page and help other Geeks
Efficient program to calculate e^x
The value of Exponential Function e^x can be expressed using following Taylor Series.

e^x = 1 + x/1! + x^2/2! + x^3/3! + ......

How to efficiently calculate the sum of above series?

The series can be re-written as

e^x = 1 + (x/1) (1 + (x/2) (1 + (x/3) (........) ) )

Let the sum needs to be calculated for n terms, we can calculate sum using following loop.
for (i = n - 1, sum = 1; i > 0; --i )

sum = 1 + x * sum / i;

Following is implementation of the above idea.
// Efficient program to calculate e raise to the power x

#include <stdio.h>
//Returns approximate value of e^x using sum of first n terms of Taylor Series
float exponential(int n, float x)
{
float sum = 1.0f; // initialize sum of series
for (int i = n - 1; i > 0; --i )

sum = 1 + x * sum / i;
return sum;
}

int main()
{
int n = 10;
float x = 1.0f;
printf("e^x = %f", exponential(n, x));
return 0;
}

Output:

e^x = 2.718282

Sort a linked list of 0s, 1s and 2s
Given a linked list of 0s, 1s and 2s, sort it.
Source: Microsoft Interview | Set 1
Following steps can be used to sort the given linked list.

1) Traverse the list and count the number of 0s, 1s and 2s. Let the counts be n1, n2 and n3 respectively.
2) Traverse the list again, fill the first n1 nodes with 0, then n2 nodes with 1 and finally n3 nodes with 2.
// Program to sort a linked list 0s, 1s or 2s

#include<stdio.h>
#include<stdlib.h>

struct node
{
int data;
struct node* next;
};
// Function to sort a linked list of 0s, 1s and 2s

void sortList(struct node *head)
{
int count[3] = {0, 0, 0}; // Initialize count of '0', '1' and '2' as 0
struct node *ptr = head;
/* count total number of '0', '1' and '2'

* count[0] will store total number of '0's
* count[1] will store total number of '1's
* count[2] will store total number of '2's */
while (ptr != NULL)
{
count[ptr->data] += 1;
ptr = ptr->next;
}
int i = 0;
ptr = head;
/* Let say count[0] = n1, count[1] = n2 and count[2] = n3

* now start traversing list from head node,
* 1) fill the list with 0, till n1 > 0
* 2) fill the list with 1, till n2 > 0
* 3) fill the list with 2, till n3 > 0 */
while (ptr != NULL)
{
if (count[i] == 0)
++i;
else
{
ptr->data = i;
--count[i];
ptr = ptr->next;
}
}
}

{
{
/* allocate node */



}

{
{
node = node->next;
}
printf("\n");
}

int main(void)
{
push(&head, 0);
push(&head, 1);
push(&head, 0);
push(&head, 2);
push(&head, 1);
push(&head, 1);
push(&head, 2);
push(&head, 1);
push(&head, 2);
printf("Linked List Before Sorting\n");

printList(head);
sortList(head);
printf("Linked List After Sorting\n");

printList(head);
return 0;
}

Output:

Linked List Before Sorting
2 1 2 1 1 2 0 1 0
Linked List After Sorting
0 0 1 1 1 1 2 2 2


Dynamic Programming | Set 24 (Optimal Binary Search Tree)
Given a sorted array keys[0.. n-1] of search keys and an array freq[0.. n-1] of frequency counts, where freq[i]
is the number of searches to keys[i]. Construct a binary search tree of all keys such that the total cost of all
the searches is as small as possible.
Let us first define the cost of a BST. The cost of a BST node is level of that node multiplied by its frequency.
Level of root is 1.
Example 1
Input: keys[] = {10, 12}, freq[] = {34, 50}
There can be following two possible BSTs
10 12
\ /
12 10
I II
Frequency of searches of 10 and 12 are 34 and 50 respectively.
The cost of tree I is 34*1 + 50*2 = 134
The cost of tree II is 50*1 + 34*2 = 118
Example 2
Input: keys[] = {10, 12, 20}, freq[] = {34, 8, 50}
There can be following possible BSTs
10 12 20 10 20
\ / \ / \ /
12 10 20 12 20 10
\ / / \
20 10 12 12
I II III IV V
Among all possible BSTs, cost of the fifth BST is minimum.
Cost of the fifth BST is 1*50 + 2*34 + 3*8 = 142

The optimal cost for freq[i..j] can be recursively calculated using following formula.
We need to calculate optCost(0, n-1) to find the result.
The idea of above formula is simple, we one by one try all nodes as root (r varies from i to j in second term).
When we make rth node as root, we recursively calculate optimal cost from i to r-1 and r+1 to j.
We add sum of frequencies from i to j (see first term in the above formula), this is added because every
search will go through root and one comparison will be done for every search.
// A naive recursive implementation of optimal binary search tree problem

#include <stdio.h>
#include <limits.h>
// A utility function to get sum of array elements freq[i] to freq[j]

int sum(int freq[], int i, int j);
// A recursive function to calculate cost of optimal binary search tree

// A recursive function to calculate cost of optimal binary search tree
int optCost(int freq[], int i, int j)
{
// Base cases
if (j < i) // If there are no elements in this subarray
return 0;
if (j == i) // If there is one element in this subarray
return freq[i];
// Get sum of freq[i], freq[i+1], ... freq[j]

int fsum = sum(freq, i, j);
// Initialize minimum value

int min = INT_MAX;
// One by one consider all elements as root and recursively find cost
// of the BST, compare the cost with min and update min if needed
for (int r = i; r <= j; ++r)
{
int cost = optCost(freq, i, r-1) + optCost(freq, r+1, j);
if (cost < min)
min = cost;
}
// Return minimum value

return min + fsum;
}
// The main function that calculates minimum cost of a Binary Search Tree.
// It mainly uses optCost() to find the optimal cost.
int optimalSearchTree(int keys[], int freq[], int n)
{
// Here array keys[] is assumed to be sorted in increasing order.
// If keys[] is not sorted, then add code to sort keys, and rearrange
// freq[] accordingly.
return optCost(freq, 0, n-1);
}

int sum(int freq[], int i, int j)
{
int s = 0;
for (int k = i; k <=j; k++)
s += freq[k];
return s;
}

int main()
{
int keys[] = {10, 12, 20};
int freq[] = {34, 8, 50};
int n = sizeof(keys)/sizeof(keys[0]);
printf("Cost of Optimal BST is %d ", optimalSearchTree(keys, freq, n));
return 0;
}

Output:

Cost of Optimal BST is 142

function computes the same subproblems again and again. We can see many subproblems being repeated in
the following recursion tree for freq[1..4].
Since same suproblems are called again, this problem has Overlapping Subprolems property. So optimal
BST problem has both properties (see this and this) of a dynamic programming problem. Like other typical
Dynamic Programming(DP) problems, recomputations of same subproblems can be avoided by constructing
a temporary array cost[][] in bottom up manner.

Following is C/C++ implementation for optimal BST problem using Dynamic Programming. We use an
auxiliary array cost[n][n] to store the solutions of subproblems. cost[0][n-1] will hold the final result. The
challenge in implementation is, all diagonal values must be filled first, then the values which lie on the line
just above the diagonal. In other words, we must first fill all cost[i][i] values, then all cost[i][i+1] values, then
all cost[i][i+2] values. So how to fill the 2D array in such manner> The idea used in the implementation is
same as Matrix Chain Multiplication problem, we use a variable ‘L’ for chain length and increment ‘L’, one
by one. We calculate column number ‘j’ using the values of ‘i’ and ‘L’.
// Dynamic Programming code for Optimal Binary Search Tree Problem

#include <stdio.h>
#include <limits.h>

int sum(int freq[], int i, int j);
/* A Dynamic Programming based function that calculates minimum cost of

a Binary Search Tree. */
int optimalSearchTree(int keys[], int freq[], int n)
{
/* Create an auxiliary 2D matrix to store results of subproblems */
int cost[n][n];
/* cost[i][j] = Optimal cost of binary search tree that can be

formed from keys[i] to keys[j].
cost[0][n-1] will store the resultant cost */
// For a single key, cost is equal to frequency of the key

for (int i = 0; i < n; i++)
cost[i][i] = freq[i];
// Now we need to consider chains of length 2, 3, ... .

// Now we need to consider chains of length 2, 3, ... .
// L is chain length.
for (int L=2; L<=n; L++)
{
// i is row number in cost[][]
for (int i=0; i<=n-L+1; i++)
{
// Get column number j from row number i and chain length L
int j = i+L-1;
cost[i][j] = INT_MAX;
// Try making all keys in interval keys[i..j] as root

for (int r=i; r<=j; r++)
{
// c = cost when keys[r] becomes root of this subtree
int c = ((r > i)? cost[i][r-1]:0) +
((r < j)? cost[r+1][j]:0) +
sum(freq, i, j);
if (c < cost[i][j])
cost[i][j] = c;
}
}
}
return cost[0][n-1];
}

int sum(int freq[], int i, int j)
{
int s = 0;
for (int k = i; k <=j; k++)
s += freq[k];
return s;
}

int main()
{
int keys[] = {10, 12, 20};
int freq[] = {34, 8, 50};
int n = sizeof(keys)/sizeof(keys[0]);
printf("Cost of Optimal BST is %d ", optimalSearchTree(keys, freq, n));
return 0;
}

Output:

Cost of Optimal BST is 142

Notes
1) The time complexity of the above solution is O(n^4). The time complexity can be easily reduced to O(n^3)
by pre-calculating sum of frequencies instead of calling sum() again and again.
2) In the above solutions, we have computed optimal cost only. The solutions can be easily modified to store
the structure of BSTs also. We can create another auxiliary array of size n to store the structure of tree. All we
need to do is, store the chosen ‘r’ in the innermost loop.
discussed above.
Binary representation of a given number
Write a program to print Binary representation of a given number.
Source: Microsoft Interview Set-3
Method 1: Iterative
For any number, we can check whether its ‘i’th bit is 0(OFF) or 1(ON) by bitwise ANDing it with “2î” (2
raise to i).
1) Let us take number 'NUM' and we want to check whether it's 0th bit is ON or OFF
bit = 2 ^ 0 (0th bit)
if NUM & bit == 1 means 0th bit is ON else 0th bit is OFF
2) Similarly if we want to check whether 5th bit is ON or OFF

bit = 2 ^ 5 (5th bit)
if NUM & bit == 1 means its 5th bit is ON else 5th bit is OFF.

Let us take unsigned integer (32 bit), which consist of 0-31 bits. To print binary representation of unsigned
integer, start from 31th bit, check whether 31th bit is ON or OFF, if it is ON print “1” else print “0”. Now
check whether 30th bit is ON or OFF, if it is ON print “1” else print “0”, do this for all bits from 31 to 0,
finally we will get binary representation of number.
void bin(unsigned n)
{
unsigned i;
for (i = 1 << 31; i > 0; i = i / 2)
(n & i)? printf("1"): printf("0");
}
int main(void)
{
bin(7);
printf("\n");
bin(4);
}

Method 2: Recursive
Following is recursive method to print binary representation of ‘NUM’.
step 1) if NUM > 1

a) push NUM on stack
b) recursively call function with 'NUM / 2'
step 2)
a) pop NUM from stack, divide it by 2 and print it's remainder.

void bin(unsigned n)
{
/* step 1 */
if (n > 1)
bin(n/2);
/* step 2 */
printf("%d", n % 2);
}
int main(void)
{
bin(7);
printf("\n");
bin(4);
}

Write your own strcmp that ignores cases
Write a modified strcmp function which ignores cases and returns -1 if s1
Source: Microsoft Interview Set 5
Following solution assumes that characters are represented using ASCII representation, i.e., codes for ‘a’, ‘b’,
‘c’, … ‘z’ are 97, 98, 99, … 122 respectively. And codes for ‘A’, “B”, ‘C’, … ‘Z’ are 65, 66, … 95 respectively.

1) Iterate through every character of both strings and do following for each character.
…a) If str1[i] is same as str2[i], then continue.
…b) If inverting the 6th least significant bit of str1[i] makes it same as str2[i], then continue. For example, if
str1[i] is 65, then inverting the 6th bit will make it 97. And if str1[i] is 97, then inverting the 6th bit will make
it 65.
…c) If any of the above two conditions is not true, then break.
2) Compare the last (or first mismatching in case of not same) characters.
#include <stdio.h>
/* implementation of strcmp that ingnores cases */

int ic_strcmp(char *s1, char *s2)
{
int i;
for (i = 0; s1[i] && s2[i]; ++i)
{
/* If characters are same or inverting the 6th bit makes them same */
if (s1[i] == s2[i] || (s1[i] ^ 32) == s2[i])
continue;
else
break;
}
/* Compare the last (or first mismatching in case of not same) characters */
if (s1[i] == s2[i])
return 0;
if ((s1[i]|32) < (s2[i]|32)) //Set the 6th bit in both, then compare
return -1;
return 1;
}

int main(void)
{
printf("ret: %d\n", ic_strcmp("Geeks", "apple"));
printf("ret: %d\n", ic_strcmp("", "ABCD"));
printf("ret: %d\n", ic_strcmp("ABCD", "z"));
printf("ret: %d\n", ic_strcmp("ABCD", "abcdEghe"));
printf("ret: %d\n", ic_strcmp("GeeksForGeeks", "gEEksFORGeEKs"));
printf("ret: %d\n", ic_strcmp("GeeksForGeeks", "geeksForGeeks"));
return 0;
}

Output:

ret: 1
ret: -1
ret: -1
ret: -1
ret: 0
ret: 0

Dynamic Programming | Set 25 (Subset Sum Problem)
Given a set of non-negative integers, and a value sum, determine if there is a subset of the given set with sum
equal to given sum.
Examples: set[] = {3, 34, 4, 12, 5, 2}, sum = 9

Output: True //There is a subset (4, 5) with sum 9.

Let isSubSetSum(int set[], int n, int sum) be the function to find whether there is a subset of set[] with sum
equal to sum. n is the number of elements in set[].
The isSubsetSum problem can be divided into two subproblems

…a) Include the last element, recur for n = n-1, sum = sum – set[n-1]
…b) Exclude the last element, recur for n = n-1.
If any of the above the above subproblems return true, then return true.
Following is the recursive formula for isSubsetSum() problem.
isSubsetSum(set, n, sum) = isSubsetSum(set, n-1, sum) ||

isSubsetSum(arr, n-1, sum-set[n-1])
Base Cases:
isSubsetSum(set, n, sum) = false, if sum > 0 and n == 0
isSubsetSum(set, n, sum) = true, if sum == 0

Following is naive recursive implementation that simply follows the recursive structure mentioned above.

// A recursive solution for subset sum problem

#include <stdio.h>
// Returns true if there is a subset of set[] with sun equal to given sum
bool isSubsetSum(int set[], int n, int sum)
{
// Base Cases
if (sum == 0)
return true;
if (n == 0 && sum != 0)
return false;
// If last element is greater than sum, then ignore it

if (set[n-1] > sum)
return isSubsetSum(set, n-1, sum);
/* else, check if sum can be obtained by any of the following

(a) including the last element
(b) excluding the last element */
return isSubsetSum(set, n-1, sum) || isSubsetSum(set, n-1, sum-set[n-1]);
}

int main()
{
int set[] = {3, 34, 4, 12, 5, 2};
int sum = 9;
int n = sizeof(set)/sizeof(set[0]);
if (isSubsetSum(set, n, sum) == true)
printf("Found a subset with given sum");
else
printf("No subset with given sum");
return 0;
}

Output:

Found a subset with given sum

The above solution may try all subsets of given set in worst case. Therefore time complexity of the above
solution is exponential. The problem is in-fact NP-Complete (There is no known polynomial time solution
for this problem).
We can solve the problem in Pseudo-polynomial time using Dynamic programming. We create
a boolean 2D table subset[][] and fill it in bottom up manner. The value of subset[i][j] will be true if there is
a subset of set[0..j-1] with sum equal to i., otherwise false. Finally, we return subset[sum][n]

// A Dynamic Programming solution for subset sum problem

#include <stdio.h>
// Returns true if there is a subset of set[] with sun equal to given sum
bool isSubsetSum(int set[], int n, int sum)
{
// The value of subset[i][j] will be true if there is a subset of set[0..j-1]
// with sum equal to i
bool subset[sum+1][n+1];
// If sum is 0, then answer is true

for (int i = 0; i <= n; i++)
subset[0][i] = true;
// If sum is not 0 and set is empty, then answer is false

for (int i = 1; i <= sum; i++)
subset[i][0] = false;
// Fill the subset table in botton up manner

{
for (int j = 1; j <= n; j++)
{
subset[i][j] = subset[i][j-1];
if (i >= set[j-1])
subset[i][j] = subset[i][j] || subset[i - set[j-1]][j-1];
}
}
/* // uncomment this code to print table

{
for (int j = 0; j <= n; j++)
printf ("%4d", subset[i][j]);
printf("\n");
} */
return subset[sum][n];
}

int main()
{
int set[] = {3, 34, 4, 12, 5, 2};
int sum = 9;
int n = sizeof(set)/sizeof(set[0]);
if (isSubsetSum(set, n, sum) == true)
printf("Found a subset with given sum");
else
printf("No subset with given sum");
return 0;
}

Output:

Found a subset with given sum

Time complexity of the above solution is O(sum*n).
discussed above.
Measure one litre using two vessels and infinite water supply
There are two vessels of capacities ‘a’ and ‘b’ respectively. We have infinite water supply. Give an efficient
algorithm to make exactly 1 litre of water in one of the vessels. You can throw all the water from any vessel
any point of time. Assume that ‘a’ and ‘b’ are Coprimes.
Following are the steps:

Let V1 be the vessel of capacity ‘a’ and V2 be the vessel of capacity ‘b’ and ‘a’ is smaller than ‘b’.
1) Do following while the amount of water in V1 is not 1.
….a) If V1 is empty, then completely fill V1
….b) Transfer water from V1 to V2. If V2 becomes full, then keep the remaining water in V1 and empty V2
2) V1 will have 1 litre after termination of loop in step 1. Return.
Following is C++ implementation of the above algorithm.
/* Sample run of the Algo for V1 with capacity 3 and V2 with capacity 7
1. Fill V1: V1 = 3, V2 = 0
2. Transfer from V1 to V2, and fill V1: V1 = 3, V2 = 3
3. Transfer from V1 to V2, and empty V2: V1 = 2, V2 = 0
6. Transfer from V1 to V2, and empty V2: V1 = 1, V2 = 0
7. Stop as V1 now contains 1 litre.
Note that V2 was made empty in steps 3 and 6 because it became full */
#include <iostream>
// A utility function to get GCD of two numbers

int gcd(int a, int b) { return b? gcd(b, a % b) : a; }
// Class to represent a Vessel

class Vessel
{
// A vessel has capacity, and current amount of water in it
int capacity, current;
public:
// Constructor: initializes capacity as given, and current as 0
Vessel(int capacity) { this->capacity = capacity; current = 0; }
// The main function to fill one litre in this vessel. Capacity of V2

// must be greater than this vessel and two capacities must be co-prime
void makeOneLitre(Vessel &V2);
// Fills vessel with given amount and returns the amount of water
// transferred to it. If the vessel becomes full, then the vessel
// is made empty.
int transfer(int amount);
};
// The main function to fill one litre in this vessel. Capacity

// of V2 must be greater than this vessel and two capacities
// must be coprime
void Vessel:: makeOneLitre(Vessel &V2)
{
// solution exists iff a and b are co-prime
if (gcd(capacity, V2.capacity) != 1)
return;
return;
while (current != 1)
{
// fill A (smaller vessel)
if (current == 0)
current = capacity;
cout << "Vessel 1: " << current << " Vessel 2: "
<< V2.current << endl;
// Transfer water from V1 to V2 and reduce current of V1 by

// the amount equal to transferred water
current = current - V2.transfer(current);
}
// Finally, there will be 1 litre in vessel 1

cout << "Vessel 1: " << current << " Vessel 2: "
<< V2.current << endl;
}
// Fills vessel with given amount and returns the amount of water
// transferred to it. If the vessel becomes full, then the vessel
// is made empty
int Vessel::transfer(int amount)
{
// If the vessel can accommodate the given amount
if (current + amount < capacity)
{
current += amount;
return amount;
}
// If the vessel cannot accommodate the given amount, then

// store the amount of water transferred
int transferred = capacity - current;
// Since the vessel becomes full, make the vessel

// empty so that it can be filled again
current = 0;
return transferred;
}

int main()
{
int a = 3, b = 7; // a must be smaller than b
// Create two vessels of capacities a and b

Vessel V1(a), V2(b);
// Get 1 litre in first vessel

V1.makeOneLitre(V2);
return 0;
}

Output:

Vessel 1: 3 Vessel 2: 0

How does this work?
To prove that the algorithm works, we need to proof that after certain number of iterations in the while loop,
we will get 1 litre in V1.
Let ‘a’ be the capacity of vessel V1 and ‘b’ be the capacity of V2. Since we repeatedly transfer water from V1 to
V2 until V2 becomes full, we will have ‘a – b (mod a)’ water in V1 when V2 becomes full first time . Once V2
becomes full, it is emptied. We will have ‘a – 2b (mod a)’ water in V1 when V2 is full second time. We repeat
the above steps, and get ‘a – nb (mod a)’ water in V1 after the vessel V2 is filled and emptied ‘n’ times. We
need to prove that the value of ‘a – nb (mod a)’ will be 1 for a finite integer ‘n’. To prove this, let us consider
the following property of coprime numbers.
For any two coprime integers ‘a’ and ‘b’, the integer ‘b’ has a multiplicative inverse modulo ‘a’. In other
words, there exists an integer ‘y’ such that ‘b*y ≡ 1(mod)a’ (See 3rd point here). After ‘(a – 1)*y’ iterations, we
will have ‘a – [(a-1)*y*b (mod a)]’ water in V1, the value of this expression is ‘a – [(a – 1) * 1] mod a’ which is
1. So the algorithm converges and we get 1 litre in V1.
This article is compiled by Aashish Barnwal. Please write comments if you find anything incorrect, or you
Efficient program to print all prime factors of a given number
Given a number n, write an efficient function to print all prime factors of n. For example, if the input number
is 12, then output should be “2 2 3″. And if the input number is 315, then output should be “3 3 5 7″.
Following are the steps to find all prime factors.

1) While n is divisible by 2, print 2 and divide n by 2.
2) After step 1, n must be odd. Now start a loop from i = 3 to square root of n. While i divides n, print i and
divide n by i, increment i by 2 and continue.
3) If n is a prime number and is greater than 2, then n will not become 1 by above two steps. So print n if it is
greater than 2.
// Program to print all prime factors

# include <stdio.h>
# include <math.h>
// A function to print all prime factors of a given number n

void primeFactors(int n)
{
// Print the number of 2s that divide n
while (n%2 == 0)
{
printf("%d ", 2);
n = n/2;
}
// n must be odd at this point. So we can skip one element (Note i = i +2)
for (int i = 3; i <= sqrt(n); i = i+2)
{
// While i divides n, print i and divide n
while (n%i == 0)
{
printf("%d ", i);
n = n/i;
}
}
// This condition is to handle the case whien n is a prime number

// greater than 2
if (n > 2)
printf ("%d ", n);
}

int main()
{
int n = 315;
primeFactors(n);
return 0;
}

Output:

3 3 5 7

How does this work?
The steps 1 and 2 take care of composite numbers and step 3 takes care of prime numbers. To prove that the
complete algorithm works, we need to prove that steps 1 and 2 actually take care of composite numbers. This
is clear that step 1 takes care of even numbers. And after step 1, all remaining prime factor must be odd
(difference of two prime factors must be at least 2), this explains why i is incremented by 2.
Now the main part is, the loop runs till square root of n not till. To prove that this optimization works, let us
consider the following property of composite numbers.
Every composite number has at least one prime factor less than or equal to square root of itself.
This property can be proved using counter statement. Let a and b be two factors of n such that a*b = n. If
both are greater than √n, then a.b > √n, * √n, which contradicts the expression “a * b = n”.
In step 2 of the above algorithm, we run a loop and do following in loop

a) Find the least prime factor i (must be less than √n,)
b) Remove all occurrences i from n by repeatedly dividing n by i.
c) Repeat steps a and b for divided n and i = i + 2. The steps a and b are repeated till n becomes either 1 or a
prime number.
Thanks to Vishwas Garg for suggesting the above algorithm. Please write comments if you find anything
incorrect, or you want to share more information about the topic discussed above
Convert a BST to a Binary Tree such that sum of all greater keys is added to
every key
Given a Binary Search Tree (BST), convert it to a Binary Tree such that every key of the original BST is
changed to key plus sum of all greater keys in BST.
Examples:
Input: Root of following BST

5
/ \
2 13
Output: The given BST is converted to following Binary Tree

18
/ \
20 13

Source: Convert a BST
Solution: Do reverse Inoorder traversal. Keep track of the sum of nodes visited so far. Let this sum be sum.
For every node currently being visited, first add the key of this node to sum, i.e. sum = sum + node->key.
Then change the key of current node to sum, i.e., node->key = sum.
When a BST is being traversed in reverse Inorder, for every key currently being visited, all keys that are
already visited are all greater keys.
// Program to change a BST to Binary Tree such that key of a node becomes
// original key plus sum of all greater keys in BST
#include <stdio.h>
#include <stdlib.h>
/* A BST node has key, left child and right child */

struct node
{
int key;
struct node* left;
struct node* right;
};
{
node->key = key;
node->left = NULL;
node->right = NULL;
return (node);
}
// A recursive function that traverses the given BST in reverse inorder and
// for every key, adds all greater keys to it
void addGreaterUtil(struct node *root, int *sum_ptr)
{
// Base Case
if (root == NULL)
if (root == NULL)
return;
// Recur for right subtree first so that sum of all greater

// nodes is stored at sum_ptr
addGreaterUtil(root->right, sum_ptr);
// Update the value at sum_ptr

*sum_ptr = *sum_ptr + root->key;
// Update key of this node

root->key = *sum_ptr;
// Recur for left subtree so that the updated sum is added

// to smaller nodes
addGreaterUtil(root->left, sum_ptr);
}
// A wrapper over addGreaterUtil(). It initializes sum and calls

// addGreaterUtil() to recursivel upodate and use value of sum
void addGreater(struct node *root)
{
int sum = 0;
addGreaterUtil(root, &sum);
}
// A utility function to print inorder traversal of Binary Tree

{
if (node == NULL)
return;
printf("%d ", node->key);
}

int main()
{
/* Create following BST
5
/ \
2 13 */
printf(" Inorder traversal of the given tree\n");

printInorder(root);
addGreater(root);
printf("\n Inorder traversal of the modified tree\n");

printInorder(root);
return 0;
}

Output:

Inorder traversal of the given tree
2 5 13
Inorder traversal of the modified tree
20 18 13

Time Complexity: O(n) where n is the number of nodes in given Binary Search Tree.
discussed above
Morris traversal for Preorder
Using Morris Traversal, we can traverse the tree without using stack and recursion. The algorithm for
Preorder is almost similar to Morris traversal for Inorder.
1...If left child is null, print the current node data. Move to right child.
….Else, Make the right child of the inorder predecessor point to the current node. Two cases arise:
………a) The right child of the inorder predecessor already points to the current node. Set right child to
NULL. Move to right child of current node.
………b) The right child is NULL. Set it to current node. Print current node’s data and move to left child of
current node.
2...Iterate until current node is not NULL.
// C program for Morris Preorder traversal

#include <stdio.h>
#include <stdlib.h>
struct node
{
int data;
};

{
struct node* temp = (struct node*) malloc(sizeof(struct node));
temp->data = data;
return temp;
}
// Preorder traversal without recursion and without stack

void morrisTraversalPreorder(struct node* root)
{
while (root)
{
// If left child is null, print the current node data. Move to
// right child.
if (root->left == NULL)
{
printf( "%d ", root->data );
root = root->right;
}
else
{
// Find inorder predecessor
struct node* current = root->left;
while (current->right && current->right != root)
// If the right child of inorder predecessor already points to

// this node
if (current->right == root)
{
current->right = NULL;
root = root->right;
root = root->right;
}
// If right child doesn't point to this node, then print this

// node and make right child point to this node
else
{
current->right = root;
root = root->left;
}
}
}
}
// Function for sStandard preorder traversal

void preorder(struct node* root)
{
if (root)
{
printf( "%d ", root->data);
preorder(root->left);
preorder(root->right);
}
}

int main()
{
root = newNode(1);
root->left->left->right = newNode(9);
morrisTraversalPreorder(root);
printf("\n");
preorder(root);
return 0;
}

Output:

1 2 4 8 9 5 10 11 3 6 7
1 2 4 8 9 5 10 11 3 6 7

Limitations:
Morris traversal modifies the tree during the process. It establishes the right links while moving down the
tree and resets the right links while moving up the tree. So the algorithm cannot be applied if write
operations are not allowed.
Linked complete binary tree & its creation
A complete binary tree is a binary tree where each level ‘l’ except the last has 2^l nodes and the nodes at the
last level are all left aligned. Complete binary trees are mainly used in heap based data structures.
The nodes in the complete binary tree are inserted from left to right in one level at a time. If a level is full,
the node is inserted in a new level.
Below are some of the complete binary trees.
1
/ \
2 3
1
/ \
2 3
/ \ /
4 5 6

Below binary trees are not complete:
1
/ \
2 3
/ /
4 5
1
/ \
2 3
/ \ /
4 5 6
/
7

Complete binary trees are generally represented using arrays. The array representation is better because it
doesn’t contain any empty slot. Given parent index i, its left child is given by 2 * i + 1 and its right child is
given by 2 * i + 2. So no extra space is wasted and space to store left and right pointers is saved. However, it
may be an interesting programming question to created a Complete Binary Tree using linked representation.
Here Linked mean a non-array representation where left and right pointers(or references) are used to refer
left and right children respectively. How to write an insert function that always adds a new node in the last
level and at the leftmost available position?
To create a linked complete binary tree, we need to keep track of the nodes in a level order fashion such that
the next node to be inserted lies in the leftmost position. A queue data structure can be used to keep track of
the inserted nodes.
Following are steps to insert a new node in Complete Binary Tree.

1. If the tree is empty, initialize the root with new node.
2. Else, get the front node of the queue.

…….If the left child of this front node doesn’t exist, set the left child as the new node.
…….else if the right child of this front node doesn’t exist, set the right child as the new node.
3. If the front node has both the left child and right child, Dequeue() it.
4. Enqueue() the new node.
Below is the implementation:
// Program for linked implementation of complete binary tree

#include <stdio.h>
#include <stdlib.h>
// For Queue Size

#define SIZE 50
// A tree node
struct node
{
int data;
struct node *right,*left;
};
// A queue node
struct Queue
{
int front, rear;
int size;
struct node* *array;
};

{
struct node* temp = (struct node*) malloc(sizeof( struct node ));
temp->data = data;
return temp;
}
// A utility function to create a new Queue

struct Queue* createQueue(int size)
{
struct Queue* queue = (struct Queue*) malloc(sizeof( struct Queue ));

queue->size = size;
queue->array = (struct node**) malloc(queue->size * sizeof( struct node* ));
int i;
for (i = 0; i < size; ++i)
queue->array[i] = NULL;
return queue;
}
// Standard Queue Functions

int isEmpty(struct Queue* queue)
{
}
int isFull(struct Queue* queue)
{ return queue->rear == queue->size - 1; }
int hasOnlyOneItem(struct Queue* queue)

{ return queue->front == queue->rear; }
void Enqueue(struct node *root, struct Queue* queue)

{
if (isFull(queue))
return;
queue->array[++queue->rear] = root;
if (isEmpty(queue))
++queue->front;
}
struct node* Dequeue(struct Queue* queue)

{
if (isEmpty(queue))
return NULL;
struct node* temp = queue->array[queue->front];
if (hasOnlyOneItem(queue))
else
++queue->front;
return temp;
}
struct node* getFront(struct Queue* queue)

{ return queue->array[queue->front]; }
// A utility function to check if a tree node has both left and right children
int hasBothChild(struct node* temp)
{
return temp && temp->left && temp->right;
}
// Function to insert a new node in complete binary tree

void insert(struct node **root, int data, struct Queue* queue)
{
// Create a new node for given data
struct node *temp = newNode(data);
// If the tree is empty, initialize the root with new node.

if (!*root)
*root = temp;
else
{
// get the front node of the queue.
struct node* front = getFront(queue);
// If the left child of this front node doesn’t exist, set the
// left child as the new node
if (!front->left)
front->left = temp;
// If the right child of this front node doesn’t exist, set the
// right child as the new node
else if (!front->right)
else if (!front->right)
front->right = temp;
// If the front node has both the left child and right child,
// Dequeue() it.
if (hasBothChild(front))
Dequeue(queue);
}
// Enqueue() the new node for later insertions

Enqueue(temp, queue);
}
// Standard level order traversal to test above function

void levelOrder(struct node* root)
{
struct Queue* queue = createQueue(SIZE);
Enqueue(root, queue);
while (!isEmpty(queue))
{
struct node* temp = Dequeue(queue);
if (temp->left)
Enqueue(temp->left, queue);
if (temp->right)
Enqueue(temp->right, queue);
}
}

int main()
{
struct Queue* queue = createQueue(SIZE);
int i;
for(i = 1; i <= 12; ++i)

insert(&root, i, queue);
levelOrder(root);
return 0;
}

Output:

1 2 3 4 5 6 7 8 9 10 11 12

Pattern Searching | Set 8 (Suffix Tree Introduction)
occurrences of pat[] in txt[]. You may assume that n > m.
Preprocess Pattern or Preoprocess Text?

KMP Algorithm
Finite Automata based Algorithm
Boyer Moore Algorithm
All of the above algorithms preprocess the pattern to make the pattern searching faster. The best time
complexity that we could get by preprocessing pattern is O(n) where n is length of the text. In this post, we
will discuss an approach that preprocesses the text. A suffix tree is built of the text. After preprocessing text
(building suffix tree of text), we can search any pattern in O(m) time where m is length of the pattern.
Imagine you have stored complete work of William Shakespeare and preprocessed it. You can search any
string in the complete work in time just proportional to length of the pattern. This is really a great
improvement because length of pattern is generally much smaller than text.
Preprocessing of text may become costly if the text changes frequently. It is good for fixed text or less
frequently changing text though.
A Suffix Tree for a given text is a compressed trie for all suffixes of the given text . We have
discussed Standard Trie. Let us understand Compressed Trie with the following array of words.

{bear, bell, bid, bull, buy, sell, stock, stop}

Following is standard trie for the above input set of words.
Following is the compressed trie. Compress Trie is obtained from standard trie by joining chains of single
nodes. The nodes of a compressed trie can be stored by storing index ranges at the nodes.
How to build a Suffix Tree for a given text?
As discussed above, Suffix Tree is compressed trie of all suffixes, so following are very abstract steps to build
a suffix tree from given text.
1) Generate all suffixes of given text.
2) Consider all suffixes as individual words and build a compressed trie.
Let us consider an example text “banana\0″ where ‘\0′ is string termination character. Following are all
suffixes of “banana\0″

banana\0
anana\0
nana\0
ana\0
na\0
a\0
\0

If we consider all of the above suffixes as individual words and build a trie, we get following.
If we join chains of single nodes, we get the following compressed trie, which is the Suffix Tree for given text
“banana\0″
Please note that above steps are just to manually create a Suffix Tree. We will be discussing actual algorithm
and implementation in a separate post.
How to search a pattern in the built suffix tree?

We have discussed above how to build a Suffix Tree which is needed as a preprocessing step in pattern
searching. Following are abstract steps to search a pattern in the built Suffix Tree.
1) Starting from the first character of the pattern and root of Suffix Tree, do following for every character.
…..a) For the current character of pattern, if there is an edge from the current node of suffix tree, follow the
edge.
…..b) If there is no edge, print “pattern doesn’t exist in text” and return.
2) If all characters of pattern have been processed, i.e., there is a path from root for characters of the given
pattern, then print “Pattern found”.
Let us consider the example pattern as “nan” to see the searching process. Following diagram shows the path
followed for searching “nan” or “nana”.
How does this work?

Every pattern that is present in text (or we can say every substring of text) must be a prefix of one of all
possible suffixes. The statement seems complicated, but it is a simple statement, we just need to take an
example to check validity of it.
Applications of Suffix Tree

Suffix tree can be used for a wide range of problems. Following are some famous problems where Suffix
Trees provide optimal time complexity solution.
1) Pattern Searching
2) Finding the longest repeated substring
3) Finding the longest common substring
4) Finding the longest palindrome in a string
There are many more applications. See this for more details.
Ukkonen’s Suffix Tree Construction is discussed in following articles:

Ukkonen’s Suffix Tree Construction – Part 1
References:
http://fbim.fh-regensburg.de/~saj39122/sal/skript/progr/pr45102/Tries.pdf
http://www.cs.ucf.edu/~shzhang/Combio12/lec3.pdf
http://www.allisons.org/ll/AlgDS/Tree/Suffix/
The Stock Span Problem
The stock span problem is a financial problem where we have a series of n daily price quotes for a stock and
we need to calculate span of stock’s price for all n days.
The span Si of the stock’s price on a given day i is defined as the maximum number of consecutive days just
before the given day, for which the price of the stock on the current day is less than or equal to its price on
the given day.
For example, if an array of 7 days prices is given as {100, 80, 60, 70, 60, 75, 85}, then the span values for
corresponding 7 days are {1, 1, 1, 2, 1, 4, 6}
A Simple but inefficient method

Traverse the input price array. For every element being visited, traverse elements on left of it and increment
the span value of it while elements on the left side are smaller.
Following is implementation of this method.

// A brute force method to calculate stock span values

#include <stdio.h>
// Fills array S[] with span values

void calculateSpan(int price[], int n, int S[])
{
// Span value of first day is always 1
S[0] = 1;
// Calculate span value of remaining days by linearly checking previous days

for (int i = 1; i < n; i++)
{
S[i] = 1; // Initialize span value
// Traverse left while the next element on left is smaller than price[i]
for (int j = i-1; (j>=0)&&(price[i]>=price[j]); j--)
S[i]++;
}
}
// A utility function to print elements of array

{
for (int i = 0; i < n; i++)
}

int main()
{
int price[] = {10, 4, 5, 90, 120, 80};
int n = sizeof(price)/sizeof(price[0]);
int S[n];
// Fill the span values in array S[]

calculateSpan(price, n, S);
// print the calculated span values

printArray(S, n);
return 0;
}

Time Complexity of the above method is O(n^2). We can calculate stock span values in O(n) time.
A Linear Time Complexity Method

We see that S[i] on day i can be easily computed if we know the closest day preceding i, such that the price is
greater than on that day than the price on day i. If such a day exists, let’s call it h(i), otherwise, we define h(i)
= -1.
The span is now computed as S[i] = i – h(i). See the following diagram.
To implement this logic, we use a stack as an abstract data type to store the days i, h(i), h(h(i)) and so on.
When we go from day i-1 to i, we pop the days when the price of the stock was less than or equal to price[i]
and then push the value of day i back into the stack.

// a linear time solution for stock span problem

#include <iostream>
#include <stack>
// A brute force method to calculate stock span values

void calculateSpan(int price[], int n, int S[])
{
// Create a stack and push index of first element to it
stack<int> st;
st.push(0);
// Span value of first element is always 1

S[0] = 1;
// Calculate span values for rest of the elements

for (int i = 1; i < n; i++)
{
// Pop elements from stack while stack is not empty and top of
// stack is smaller than price[i]
while (!st.empty() && price[st.top()] < price[i])
st.pop();
// If stack becomes empty, then price[i] is greater than all elements

// on left of it, i.e., price[0], price[1],..price[i-1]. Else price[i]
// is greater than elements after top of stack
S[i] = (st.empty())? (i + 1) : (i - st.top());
// Push this element to stack

st.push(i);
}
}
// A utility function to print elements of array

{
for (int i = 0; i < n; i++)
cout << arr[i] << " ";
}

int main()
{
int price[] = {10, 4, 5, 90, 120, 80};
int S[n];
// Fill the span values in array S[]

calculateSpan(price, n, S);
// print the calculated span values

printArray(S, n);
return 0;
}

Output:

1 1 2 4 5 1

Time Complexity: O(n). It seems more than O(n) at first look. If we take a closer look, we can observe that
every element of array is added and removed from stack at most once. So there are total 2n operations at
most. Assuming that a stack operation takes O(1) time, we can say that the time complexity is O(n).
Auxiliary Space: O(n) in worst case when all elements are sorted in decreasing order.
References:
http://en.wikipedia.org/wiki/Stack_(abstract_data_type)#The_Stock_Span_Problem
http://crypto.cs.mcgill.ca/~crepeau/CS250/2004/Stack-I.pdf
discussed above.
Ternary Search Tree
A ternary search tree is a special trie data structure where the child nodes of a standard trie are ordered as a
binary search tree.
Representation of ternary search trees:

Unlike trie(standard) data structure where each node contains 26 pointers for its children, each node in a
ternary search tree contains only 3 pointers:
1. The left pointer points to the node whose value is less than the value in the current node.
2. The equal pointer points to the node whose value is equal to the value in the current node.
3. The right pointer points to the node whose value is greater than the value in the current node.
Apart from above three pointers, each node has a field to indicate data(character in case of dictionary) and
another field to mark end of a string.
So, more or less it is similar to BST which stores data based on some order. However, data in a ternary
search tree is distributed over the nodes. e.g. It needs 4 nodes to store the word “Geek”.
Below figure shows how exactly the words in a ternary search tree are stored?
One of the advantage of using ternary search trees over tries is that ternary search trees are a more space
efficient (involve only three pointers per node as compared to 26 in standard tries). Further, ternary search
trees can be used any time a hashtable would be used to store strings.
Tries are suitable when there is a proper distribution of words over the alphabets so that spaces are utilized
most efficiently. Otherwise ternary search trees are better. Ternary search trees are efficient to use(in terms
of space) when the strings to be stored share a common prefix.
Applications of ternary search trees:

1. Ternary search trees are efficient for queries like “Given a word, find the next word in dictionary(near-
neighbor lookups)” or “Find all telephone numbers starting with 9342 or “typing few starting characters in a
web browser displays all website names with this prefix”(Auto complete feature)”.
2. Used in spell checks: Ternary search trees can be used as a dictionary to store all the words. Once the word
is typed in an editor, the word can be parallely searched in the ternary search tree to check for correct
spelling.
Implementation:
Following is C implementation of ternary search tree. The operations implemented are, search, insert and
traversal.
// C program to demonstrate Ternary Search Tree (TST) insert, travese

// and search operations
// and search operations
#include <stdio.h>
#include <stdlib.h>
#define MAX 50
// A node of ternary search tree

struct Node
{
char data;
// True if this character is last character of one of the words

unsigned isEndOfString: 1;
struct Node *left, *eq, *right;

};
// A utility function to create a new ternary search tree node

struct Node* newNode(char data)
{
struct Node* temp = (struct Node*) malloc(sizeof( struct Node ));
temp->data = data;
temp->isEndOfString = 0;
temp->left = temp->eq = temp->right = NULL;
return temp;
}
// Function to insert a new word in a Ternary Search Tree

void insert(struct Node** root, char *word)
{
// Base Case: Tree is empty
if (!(*root))
*root = newNode(*word);
// If current character of word is smaller than root's character,

// then insert this word in left subtree of root
if ((*word) < (*root)->data)
insert(&( (*root)->left ), word);
// If current character of word is greate than root's character,

// then insert this word in right subtree of root
else if ((*word) > (*root)->data)
insert(&( (*root)->right ), word);
// If current character of word is same as root's character,

else
{
if (*(word+1))
insert(&( (*root)->eq ), word+1);
// the last character of the word

else
(*root)->isEndOfString = 1;
}
}
// A recursive function to traverse Ternary Search Tree

void traverseTSTUtil(struct Node* root, char* buffer, int depth)
{
if (root)
{
// First traverse the left subtree
traverseTSTUtil(root->left, buffer, depth);
// Store the character of this node

buffer[depth] = root->data;
buffer[depth] = root->data;
if (root->isEndOfString)
{
buffer[depth+1] = '\0';
printf( "%s\n", buffer);
}
// Traverse the subtree using equal pointer (middle subtree)

traverseTSTUtil(root->eq, buffer, depth + 1);
// Finally Traverse the right subtree

traverseTSTUtil(root->right, buffer, depth);
}
}
// The main function to traverse a Ternary Search Tree.

// It mainly uses traverseTSTUtil()
void traverseTST(struct Node* root)
{
char buffer[MAX];
traverseTSTUtil(root, buffer, 0);
}
// Function to search a given word in TST

int searchTST(struct Node *root, char *word)
{
if (!root)
return 0;
if (*word < (root)->data)

return searchTST(root->left, word);
else if (*word > (root)->data)

return searchTST(root->right, word);
else
{
if (*(word+1) == '\0')
return root->isEndOfString;
return searchTST(root->eq, word+1);

}
}

int main()
{
struct Node *root = NULL;
insert(&root, "cat");
insert(&root, "cats");
insert(&root, "up");
insert(&root, "bug");
printf("Following is traversal of ternary search tree\n");

traverseTST(root);
printf("\nFollowing are search results for cats, bu and cat respectively\n");

searchTST(root, "cats")? printf("Found\n"): printf("Not Found\n");
searchTST(root, "bu")? printf("Found\n"): printf("Not Found\n");
searchTST(root, "cat")? printf("Found\n"): printf("Not Found\n");
return 0;
}

Output:

Following is traversal of ternary search tree
bug
cat
cats
up
Following are search results for cats, bu and cat respectively

Found
Not Found
Found

Time Complexity: The time complexity of the ternary search tree operations is similar to that of binary
search tree. i.e. the insertion, deletion and search operations take time proportional to the height of the
ternary search tree. The space is proportional to the length of the string to be stored.
Reference:
http://en.wikipedia.org/wiki/Ternary_search_tree
Segment Tree | Set 1 (Sum of given range)
Let us consider the following problem to understand Segment Trees.
We have an array arr[0 . . . n-1]. We should be able to

1 Find the sum of elements from index l to r where 0 2 Change value of a specified element of the array arr[i]
= x where 0
A simple solution is to run a loop from l to r and calculate sum of elements in given range. To update a
value, simply do arr[i] = x. The first operation takes O(n) time and second operation takes O(1) time.
Another solution is to create another array and store sum from start to i at the ith index in this array.
Sum of a given range can now be calculated in O(1) time, but update operation takes O(n) time now. This
works well if the number of query operations are large and very few updates.
What if the number of query and updates are equal? Can we perform both the operations in O(log n)
time once given the array? We can use a Segment Tree to do both operations in O(Logn) time.
Representation of Segment trees

1. Leaf Nodes are the elements of the input array.
2. Each internal node represents some merging of the leaf nodes. The merging may be different for different
problems. For this problem, merging is sum of leaves under a node.
An array representation of tree is used to represent Segment Trees. For each node at index i, the left child is
at index 2*i+1, right child at 2*i+2 and the parent is at
Construction of Segment Tree from given array

We start with a segment arr[0 . . . n-1]. and every time we divide the current segment into two halves(if it has
not yet become a segment of length 1), and then call the same procedure on both halves, and for each such
segment we store the sum in corresponding node.
All levels of the constructed segment tree will be completely filled except the last level. Also, the tree will be a
Full Binary Tree because we always divide segments in two halves at every level. Since the constructed tree is
always full binary tree with n leaves, there will be n-1 internal nodes. So total number of nodes will be 2*n –
1.
Height of the segment tree will be
. Since the tree is represented using array and relation between parent and child indexes must be
maintained, size of memory allocated for segment tree will be
Query for Sum of given range

Once the tree is constructed, how to get the sum using the constructed segment tree. Following is algorithm
to get the sum of elements.
int getSum(node, l, r)
{
if range of node is within l and r
return value in node
else if range of node is completely outside l and r
return 0
else
return getSum(node's left child, l, r) +
getSum(node's right child, l, r)
}

Update a value
Like tree construction and query operations, update can also be done recursively. We are given an index
which needs to updated. Let diff be the value to be added. We start from root of the segment tree, and add
diff to all nodes which have given index in their range. If a node doesn’t have given index in its range, we
don’t make any changes to that node.
Implementation:
Following is implementation of segment tree. The program implements construction of segment tree for any
given array. It also implements query and update operations.
// Program to show segment tree operations like construction, query and update
#include <stdio.h>
#include <math.h>
// A utility function to get the middle index from corner indexes.

int getMid(int s, int e) { return s + (e -s)/2; }
/* A recursive function to get the sum of values in given range of the array.
The following are parameters for this function.
st --> Pointer to segment tree

index --> Index of current node in the segment tree. Initially 0 is
passed as root is always at index 0
ss & se --> Starting and ending indexes of the segment represented by
current node, i.e., st[index]
qs & qe --> Starting and ending indexes of query range */
int getSumUtil(int *st, int ss, int se, int qs, int qe, int index)
{
// If segment of this node is a part of given range, then return the
// sum of the segment
if (qs <= ss && qe >= se)
return st[index];
// If segment of this node is outside the given range

if (se < qs || ss > qe)
return 0;
// If a part of this segment overlaps with the given range

int mid = getMid(ss, se);
return getSumUtil(st, ss, mid, qs, qe, 2*index+1) +
getSumUtil(st, mid+1, se, qs, qe, 2*index+2);
}
/* A recursive function to update the nodes which have the given index in
their range. The following are parameters
st, index, ss and se are same as getSumUtil()
i --> index of the element to be updated. This index is in input array.
diff --> Value to be added to all nodes which have i in range */
void updateValueUtil(int *st, int ss, int se, int i, int diff, int index)
{
// Base Case: If the input index lies outside the range of this segment
if (i < ss || i > se)
return;
// If the input index is in range of this node, then update the value
// of the node and its children
st[index] = st[index] + diff;
if (se != ss)
{
updateValueUtil(st, ss, mid, i, diff, 2*index + 1);
updateValueUtil(st, mid+1, se, i, diff, 2*index + 2);
}
}
// The function to update a value in input array and segment tree.

// It uses updateValueUtil() to update the value in segment tree
void updateValue(int arr[], int *st, int n, int i, int new_val)
{
// Check for erroneous input index
if (i < 0 || i > n-1)
{
return;
}
// Get the difference between new value and old value

int diff = new_val - arr[i];
// Update the value in array

arr[i] = new_val;
// Update the values of nodes in segment tree

updateValueUtil(st, 0, n-1, i, diff, 0);
}
// Return sum of elements in range from index qs (quey start) to

// qe (query end). It mainly uses getSumUtil()
int getSum(int *st, int n, int qs, int qe)
{
// Check for erroneous input values
if (qs < 0 || qe > n-1 || qs > qe)
{
return -1;
}
return getSumUtil(st, 0, n-1, qs, qe, 0);

}
}
// A recursive function that constructs Segment Tree for array[ss..se].

// si is index of current node in segment tree st
int constructSTUtil(int arr[], int ss, int se, int *st, int si)
{
// If there is one element in array, store it in current node of
// segment tree and return
if (ss == se)
{
st[si] = arr[ss];
return arr[ss];
}
// If there are more than one elements, then recur for left and
// right subtrees and store the sum of values in this node
st[si] = constructSTUtil(arr, ss, mid, st, si*2+1) +
constructSTUtil(arr, mid+1, se, st, si*2+2);
return st[si];
}
/* Function to construct segment tree from given array. This function

allocates memory for segment tree and calls constructSTUtil() to
fill the allocated memory */
int *constructST(int arr[], int n)
{
// Allocate memory for segment tree
int x = (int)(ceil(log2(n))); //Height of segment tree
int max_size = 2*(int)pow(2, x) - 1; //Maximum size of segment tree
int *st = new int[max_size];
// Fill the allocated memory st

constructSTUtil(arr, 0, n-1, st, 0);
// Return the constructed segment tree

return st;
}

int main()
{
int arr[] = {1, 3, 5, 7, 9, 11};
// Build segment tree from given array

int *st = constructST(arr, n);
// Print sum of values in array from index 1 to 3

printf("Sum of values in given range = %d\n", getSum(st, n, 1, 3));
// Update: set arr[1] = 10 and update corresponding segment

// tree nodes
updateValue(arr, st, n, 1, 10);
// Find sum after the value is updated

printf("Updated sum of values in given range = %d\n",
getSum(st, n, 1, 3));
return 0;
}

Output:

Sum of values in given range = 15
Updated sum of values in given range = 22

Time Complexity:
Time Complexity for tree construction is O(n). There are total 2n-1 nodes, and value of every node is
calculated only once in tree construction.
Time complexity to query is O(Logn). To query a sum, we process at most four nodes at every level and
number of levels is O(Logn).
The time complexity of update is also O(Logn). To update a leaf value, we process one node at every level and
number of levels is O(Logn).
Segment Tree | Set 2 (Range Minimum Query)
References:
http://www.cse.iitk.ac.in/users/aca/lop12/slides/06.pdf
discussed above.
Segment Tree | Set 2 (Range Minimum Query)
We have introduced segment tree with a simple example in the previous post. In this post, Range Minimum
Query problem is discussed as another example where Segment Tree can be used. Following is problem
statement.
We have an array arr[0 . . . n-1]. We should be able to efficiently find the minimum value from index
qs
(query start) to qe (query end) where 0 . The array is static (elements are not deleted and inserted during
the series of queries).
A simple solution is to run a loop from qs to qe and find minimum element in given range. This solution
takes O(n) time in worst case.
Another solution is to create a 2D array where an entry [i, j] stores the minimum value in range arr[i..j].
Minimum of a given range can now be calculated in O(1) time, but preprocessing takes O(n^2) time. Also,
this approach needs O(n^2) extra space which may become huge for large input arrays.
Segment tree can be used to do preprocessing and query in moderate time. With segment tree,
preprocessing time is O(n) and time to for range minimum query is O(Logn). The extra space required is
O(n) to store the segment tree.
Representation of Segment trees

1. Leaf Nodes are the elements of the input array.
2. Each internal node represents minimum of all leaves under it.
An array representation of tree is used to represent Segment Trees. For each node at index i, the left child is
at index 2*i+1, right child at 2*i+2 and the parent is at
Construction of Segment Tree from given array

We start with a segment arr[0 . . . n-1]. and every time we divide the current segment into two halves(if it has
not yet become a segment of length 1), and then call the same procedure on both halves, and for each such
segment, we store the minimum value in a segment tree node.
All levels of the constructed segment tree will be completely filled except the last level. Also, the tree will be a
Full Binary Tree because we always divide segments in two halves at every level. Since the constructed tree is
always full binary tree with n leaves, there will be n-1 internal nodes. So total number of nodes will be 2*n –
1.
Height of the segment tree will be
. Since the tree is represented using array and relation between parent and child indexes must be
maintained, size of memory allocated for segment tree will be
Query for minimum value of given range

Once the tree is constructed, how to do range minimum query using the constructed segment tree. Following
is algorithm to get the minimum.
// qs --> query start index, qe --> query end index

int RMQ(node, qs, qe)
{
if range of node is within qs and qe
return value in node
else if range of node is completely outside qs and qe
return INFINITE
else
return min( RMQ(node's left child, qs, qe), RMQ(node's right child, qs, qe) )
}

Implementation:
// Program for range minimum query using segment tree

#include <stdio.h>
#include <math.h>
#include <limits.h>
// A utility function to get minimum of two numbers

int minVal(int x, int y) { return (x < y)? x: y; }

int getMid(int s, int e) { return s + (e -s)/2; }
/* A recursive function to get the minimum value in a given range of array

indexes. The following are parameters for this function.

int RMQUtil(int *st, int ss, int se, int qs, int qe, int index)
{
// min of the segment
return st[index];

return INT_MAX;

return minVal(RMQUtil(st, ss, mid, qs, qe, 2*index+1),
RMQUtil(st, mid+1, se, qs, qe, 2*index+2));
}
// Return minimum of elements in range from index qs (quey start) to

// qe (query end). It mainly uses RMQUtil()
int RMQ(int *st, int n, int qs, int qe)
{
if (qs < 0 || qe > n-1 || qs > qe)
{
return -1;
}
return RMQUtil(st, 0, n-1, qs, qe, 0);

}

int constructSTUtil(int arr[], int ss, int se, int *st, int si)
{
if (ss == se)
{
st[si] = arr[ss];
return arr[ss];
}
// right subtrees and store the minimum of two values in this node
st[si] = minVal(constructSTUtil(arr, ss, mid, st, si*2+1),
constructSTUtil(arr, mid+1, se, st, si*2+2));
return st[si];
}

{

constructSTUtil(arr, 0, n-1, st, 0);

return st;
}

int main()
{
int arr[] = {1, 3, 2, 7, 9, 11};

int qs = 1; // Starting index of query range

int qe = 5; // Ending index of query range
// Print minimum value in arr[qs..qe]

printf("Minimum of values in range [%d, %d] is = %d\n",
qs, qe, RMQ(st, n, qs, qe));
return 0;
}

Output:

Minimum of values in range [1, 5] is = 2

Time Complexity:
Time Complexity for tree construction is O(n). There are total 2n-1 nodes, and value of every node is
calculated only once in tree construction.
Time complexity to query is O(Logn). To query a range minimum, we process at most two nodes at every
level and number of levels is O(Logn).
Please refer following links for more solutions to range minimum query problem.
http://community.topcoder.com/tc?
module=Static&d1=tutorials&d2=lowestCommonAncestor#Range_Minimum_Query_(RMQ)
http://wcipeg.com/wiki/Range_minimum_query
discussed above.
The Ubiquitous Binary Search | Set 1
We all aware of binary search algorithm. Binary search is easiest difficult algorithm to get it right. I present
some interesting problems that I collected on binary search. There were some requests on binary search.
I request you to honor the code, “I sincerely attempt to solve the problem and ensure there
are no corner cases”. After reading each problem minimize the browser and try solving it.
Problem Statement: Given a sorted array of N distinct elements. Find a key in the array using least
number of comparisons. (Do you think binary search is optimal to search a key in sorted array?)
Without much theory, here is typical binary search algorithm.
// Returns location of key, or -1 if not found

int BinarySearch(int A[], int l, int r, int key)
{
int m;
while( l <= r )
{
m = l + (r-l)/2;
if( A[m] == key ) // first comparison

return m;
if( A[m] < key ) // second comparison

l = m + 1;
else
r = m - 1;
}
return -1;
}

Theoretically we need log N + 1 comparisons in worst case. If we observe, we are using two comparisons per
iteration except during final successful match, if any. In practice, comparison would be costly operation, it
won’t be just primitive type comparison. It is more economical to minimize comparisons as that of
theoretical limit.
See below figure on initialize of indices in the next implementation.
The following implementation uses fewer number of comparisons.

// Invariant: A[l] <= key and A[r] > key

// Boundary: |r - l| = 1
// Input: A[l .... r-1]
int BinarySearch(int A[], int l, int r, int key)
{
int m;
while( r - l > 1 )
{
m = l + (r-l)/2;
if( A[m] <= key )

l = m;
else
r = m;
}
if( A[l] == key )

return l;
else
return -1;
}

In the while loop we are depending only on one comparison. The search space converges to place l and r
point two different consecutive elements. We need one more comparison to trace search status.
You can see sample test case http://ideone.com/76bad0. (C++11 code)
Problem Statement: Given an array of N distinct integers, find floor value of input ‘key’. Say, A = {-1, 2, 3,
5, 6, 8, 9, 10} and key = 7, we should return 6 as outcome.
We can use the above optimized implementation to find floor value of key. We keep moving the left pointer
to right most as long as the invariant holds. Eventually left pointer points an element less than or equal to
key (by definition floor value). The following are possible corner cases,
—> If all elements in the array are smaller than key, left pointer moves till last element.
—> If all elements in the array are greater than key, it is an error condition.
—> If all elements in the array equal and <= key, it is worst case input to our implementation.
Here is implementation,

// largest value <= key

// Boundary: |r - l| = 1
// Input: A[l .... r-1]
// Precondition: A[l] <= key <= A[r]
int Floor(int A[], int l, int r, int key)
{
int m;
while( r - l > 1 )
{
m = l + (r - l)/2;
if( A[m] <= key )

l = m;
else
r = m;
}
return A[l];
}
// Initial call
int Floor(int A[], int size, int key)
{
// Add error checking if key < A[0]
if( key < A[0] )
return -1;
// Observe boundaries
return Floor(A, 0, size, key);
}

You can see some test cases http://ideone.com/z0Kx4a.
Problem Statement: Given a sorted array with possible duplicate elements. Find number
of occurrences of input ‘key’ in log N time.
The idea here is finding left and right most occurrences of key in the array using binary search. We can
modify floor function to trace right most occurrence and left most occurrence. Here is implementation,

// Input: Indices Range [l ... r)

int GetRightPosition(int A[], int l, int r, int key)
{
int m;
while( r - l > 1 )
{
m = l + (r - l)/2;
if( A[m] <= key )

l = m;
else
r = m;
}
return l;
}
// Input: Indices Range (l ... r]

// Invariant: A[r] >= key and A[l] > key
int GetLeftPosition(int A[], int l, int r, int key)
{
int m;
while( r - l > 1 )
{
m = l + (r - l)/2;
if( A[m] >= key )

r = m;
else
l = m;
}
return r;
}
int CountOccurances(int A[], int size, int key)

{
// Observe boundary conditions
int left = GetLeftPosition(A, -1, size-1, key);
int right = GetRightPosition(A, 0, size, key);
// What if the element doesn't exists in the array?

// The checks helps to trace that element exists
return (A[left] == key && key == A[right])?
(right - left + 1) : 0;
}

Sample code http://ideone.com/zn6R6a.
Problem Statement: Given a sorted array of distinct elements, and the array is rotated at an unknown
position. Find minimum element in the array.
We can see pictorial representation of sample input array in the below figure.
We converge the search space till l and r points single element. If the middle location falls in the first pulse,
the condition A[m] < A[r] doesn’t satisfy, we exclude the range A[m+1 … r]. If the middle location falls in the
second pulse, the condition A[m] < A[r] satisfied, we converge our search space to A[m+1 … r]. At every
iteration we check for search space size, if it is 1, we are done.
Given below is implementation of algorithm. Can you come up with different implementation?

int BinarySearchIndexOfMinimumRotatedArray(int A[], int l, int r)

{
// extreme condition, size zero or size two
int m;
// Precondition: A[l] > A[r]

if( A[l] <= A[r] )
return l;
while( l <= r )
{
// Termination condition (l will eventually falls on r, and r always
// point minimum possible value)
if( l == r )
return l;
m = l + (r-l)/2; // 'm' can fall in first pulse,

// second pulse or exactly in the middle
if( A[m] < A[r] )

// min can't be in the range
// (m < i <= r), we can exclude A[m+1 ... r]
r = m;
else
// min must be in the range (m < i <= r),
// we must search in A[m+1 ... r]
l = m+1;
}
return -1;
}
int BinarySearchIndexOfMinimumRotatedArray(int A[], int size)

{
return BinarySearchIndexOfMinimumRotatedArray(A, 0, size-1);
}
See sample test cases http://ideone.com/KbwDrk.
Exercises:
1. A function called signum(x, y) is defined as,

signum(x, y) = -1 if x < y
= 0 if x = y
= 1 if x > y

Did you come across any instruction set in which a comparison behaves like signum function? Can it make
first implementation of binary search optimal?
2. Implement ceil function replica of floor function.
3. Discuss with your friends on “Is binary search optimal (results in least number of comparisons)? Why not
ternary search or interpolation search on sorted array? When do you prefer ternary or interpolation search
over binary search?”
4. Draw a tree representation of binary search (believe me, it helps you a lot to understand many internals of
binary search).
Stay tuned, I will cover few more interesting problems using binary search in upcoming
articles. I welcome your comments.
Design an efficient data structure for given operations
Design a Data Structure for the following operations. The data structure should be efficient enough to
accommodate the operations according to their frequency.
1) findMin() : Returns the minimum item.

Frequency: Most frequent
2) findMax() : Returns the maximum item.

Frequency: Most frequent
3) deleteMin() : Delete the minimum item.

Frequency: Moderate frequent
4) deleteMax() : Delete the maximum item.

Frequency: Moderate frequent
5) Insert() : Inserts an item.

Frequency: Least frequent
6) Delete() : Deletes an item.

Frequency: Least frequent.

A simple solution is to maintain a sorted array where smallest element is at first position and largest
element is at last. The time complexity of findMin(), findMAx() and deleteMax() is O(1). But time
complexities of deleteMin(), insert() and delete() will be O(n).
Can we do the most frequent two operations in O(1) and other operations in O(Logn) time? .
The idea is to use two binary heaps (one max and one min heap). The main challenge is, while deleting an
item, we need to delete from both min-heap and max-heap. So, we need some kind of mutual data structure.
In the following design, we have used doubly linked list as a mutual data structure. The doubly linked list
contains all input items and indexes of corresponding min and max heap nodes. The nodes of min and max
heaps store addresses of nodes of doubly linked list. The root node of min heap stores the address of
minimum item in doubly linked list. Similarly, root of max heap stores address of maximum item in doubly
linked list. Following are the details of operations.
1) findMax(): We get the address of maximum value node from root of Max Heap. So this is a O(1)
operation.
1) findMin(): We get the address of minimum value node from root of Min Heap. So this is a O(1)
operation.
3) deleteMin(): We get the address of minimum value node from root of Min Heap. We use this address to
find the node in doubly linked list. From the doubly linked list, we get node of Max Heap. We delete node
from all three. We can delete a node from doubly linked list in O(1) time. delete() operations for max and
min heaps take O(Logn) time.
4) deleteMax(): is similar to deleteMin()
5) Insert() We always insert at the beginning of linked list in O(1) time. Inserting the address in Max and
Min Heaps take O(Logn) time. So overall complexity is O(Logn)
6) Delete() We first search the item in Linked List. Once the item is found in O(n) time, we delete it from
linked list. Then using the indexes stored in linked list, we delete it from Min Heap and Max Heaps in
O(Logn) time. So overall complexity of this operation is O(n). The Delete operation can be optimized to
O(Logn) by using a balanced binary search tree instead of doubly linked list as a mutual data structure.
Use of balanced binary search will not effect time complexity of other operations as it will act as a mutual
data structure like doubly Linked List.
Following is C implementation of the above data structure.
// C program for efficient data structure

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
// A node of doubly linked list

struct LNode
{
int data;
int minHeapIndex;
int maxHeapIndex;
struct LNode *next, *prev;
};
// Structure for a doubly linked list

struct List
{
struct LNode *head;
};
// Structure for min heap

struct MinHeap
{
int size;
int capacity;
struct LNode* *array;
};
// Structure for max heap

struct MaxHeap
{
int size;
int capacity;
int capacity;
struct LNode* *array;
};
// The required data structure

struct MyDS
{
struct MinHeap* minHeap;
struct MaxHeap* maxHeap;
struct List* list;
};
// Function to swap two integers

void swapData(int* a, int* b)
{ int t = *a; *a = *b; *b = t; }
// Function to swap two List nodes

void swapLNode(struct LNode** a, struct LNode** b)
{ struct LNode* t = *a; *a = *b; *b = t; }
// A utility function to create a new List node

struct LNode* newLNode(int data)
{
struct LNode* node =
(struct LNode*) malloc(sizeof(struct LNode));
node->minHeapIndex = node->maxHeapIndex = -1;
node->data = data;
node->prev = node->next = NULL;
return node;
}
// Utility function to create a max heap of given capacity

struct MaxHeap* createMaxHeap(int capacity)
{
struct MaxHeap* maxHeap =
(struct MaxHeap*) malloc(sizeof(struct MaxHeap));
maxHeap->size = 0;
maxHeap->capacity = capacity;
maxHeap->array =
(struct LNode**) malloc(maxHeap->capacity * sizeof(struct LNode*));
return maxHeap;
}
// Utility function to create a min heap of given capacity

{
minHeap->size = 0;
minHeap->array =
(struct LNode**) malloc(minHeap->capacity * sizeof(struct LNode*));
return minHeap;
}
// Utility function to create a List

struct List* createList()
{
struct List* list =
(struct List*) malloc(sizeof(struct List));
list->head = NULL;
return list;
}
// Utility function to create the main data structure

// Utility function to create the main data structure
// with given capacity
struct MyDS* createMyDS(int capacity)
{
struct MyDS* myDS =
(struct MyDS*) malloc(sizeof(struct MyDS));
myDS->minHeap = createMinHeap(capacity);
myDS->maxHeap = createMaxHeap(capacity);
myDS->list = createList();
return myDS;
}
// Some basic operations for heaps and List

int isMaxHeapEmpty(struct MaxHeap* heap)
{ return (heap->size == 0); }
int isMinHeapEmpty(struct MinHeap* heap)

{ return heap->size == 0; }
int isMaxHeapFull(struct MaxHeap* heap)

{ return heap->size == heap->capacity; }
int isMinHeapFull(struct MinHeap* heap)

{ return heap->size == heap->capacity; }
int isListEmpty(struct List* list)

{ return !list->head; }
int hasOnlyOneLNode(struct List* list)

{ return !list->head->next && !list->head->prev; }
// The standard minheapify function. The only thing it does extra

// is swapping indexes of heaps inside the List
void minHeapify(struct MinHeap* minHeap, int index)
{
smallest = index;
left = 2 * index + 1;
right = 2 * index + 2;
if ( minHeap->array[left] &&
left < minHeap->size &&
minHeap->array[left]->data < minHeap->array[smallest]->data
)
smallest = left;
if ( minHeap->array[right] &&
right < minHeap->size &&
minHeap->array[right]->data < minHeap->array[smallest]->data
)
smallest = right;
if (smallest != index)
{
// First swap indexes inside the List using address
// of List nodes
swapData(&(minHeap->array[smallest]->minHeapIndex),
&(minHeap->array[index]->minHeapIndex));
// Now swap pointers to List nodes

swapLNode(&minHeap->array[smallest],
&minHeap->array[index]);
// Fix the heap downward

}
}
// The standard maxHeapify function. The only thing it does extra

// is swapping indexes of heaps inside the List
void maxHeapify(struct MaxHeap* maxHeap, int index)
{
int largest, left, right;
largest = index;
left = 2 * index + 1;
right = 2 * index + 2;
if ( maxHeap->array[left] &&
left < maxHeap->size &&
maxHeap->array[left]->data > maxHeap->array[largest]->data
)
largest = left;
if ( maxHeap->array[right] &&
right < maxHeap->size &&
maxHeap->array[right]->data > maxHeap->array[largest]->data
)
largest = right;
if (largest != index)
{
// First swap indexes inside the List using address
// of List nodes
swapData(&maxHeap->array[largest]->maxHeapIndex,
&maxHeap->array[index]->maxHeapIndex);
// Now swap pointers to List nodes

swapLNode(&maxHeap->array[largest],
&maxHeap->array[index]);

maxHeapify(maxHeap, largest);
}
}
// Standard function to insert an item in Min Heap

void insertMinHeap(struct MinHeap* minHeap, struct LNode* temp)
{
if (isMinHeapFull(minHeap))
return;
++minHeap->size;
while (i && temp->data < minHeap->array[(i - 1) / 2]->data )
{
minHeap->array[i] = minHeap->array[(i - 1) / 2];
minHeap->array[i]->minHeapIndex = i;
i = (i - 1) / 2;
}
minHeap->array[i] = temp;
minHeap->array[i]->minHeapIndex = i;
}
// Standard function to insert an item in Max Heap

void insertMaxHeap(struct MaxHeap* maxHeap, struct LNode* temp)
{
if (isMaxHeapFull(maxHeap))
if (isMaxHeapFull(maxHeap))
return;
++maxHeap->size;
int i = maxHeap->size - 1;
while (i && temp->data > maxHeap->array[(i - 1) / 2]->data )
{
maxHeap->array[i] = maxHeap->array[(i - 1) / 2];
maxHeap->array[i]->maxHeapIndex = i;
i = (i - 1) / 2;
}
maxHeap->array[i] = temp;
maxHeap->array[i]->maxHeapIndex = i;
}
// Function to find minimum value stored in the main data structure

int findMin(struct MyDS* myDS)
{
if (isMinHeapEmpty(myDS->minHeap))
return INT_MAX;
return myDS->minHeap->array[0]->data;
}
// Function to find maximum value stored in the main data structure

int findMax(struct MyDS* myDS)
{
if (isMaxHeapEmpty(myDS->maxHeap))
return INT_MIN;
return myDS->maxHeap->array[0]->data;
}
// A utility function to remove an item from linked list

void removeLNode(struct List* list, struct LNode** temp)
{
if (hasOnlyOneLNode(list))
list->head = NULL;
else if (!(*temp)->prev) // first node

{
list->head = (*temp)->next;
(*temp)->next->prev = NULL;
}
// any other node including last
else
{
(*temp)->prev->next = (*temp)->next;
// last node
if ((*temp)->next)
(*temp)->next->prev = (*temp)->prev;
}
free(*temp);
*temp = NULL;
}
// Function to delete maximum value stored in the main data structure

void deleteMax(struct MyDS* myDS)
{
MinHeap *minHeap = myDS->minHeap;
MaxHeap *maxHeap = myDS->maxHeap;
if (isMaxHeapEmpty(maxHeap))
if (isMaxHeapEmpty(maxHeap))
return;
struct LNode* temp = maxHeap->array[0];
// delete the maximum item from maxHeap

maxHeap->array[0] =
maxHeap->array[maxHeap->size - 1];
--maxHeap->size;
maxHeap->array[0]->maxHeapIndex = 0;
maxHeapify(maxHeap, 0);
// remove the item from minHeap

minHeap->array[temp->minHeapIndex] = minHeap->array[minHeap->size - 1];
--minHeap->size;
minHeap->array[temp->minHeapIndex]->minHeapIndex = temp->minHeapIndex;
minHeapify(minHeap, temp->minHeapIndex);
// remove the node from List

removeLNode(myDS->list, &temp);
}
// Function to delete minimum value stored in the main data structure

void deleteMin(struct MyDS* myDS)
{
if (isMinHeapEmpty(minHeap))
return;
struct LNode* temp = minHeap->array[0];
// delete the minimum item from minHeap

minHeap->array[0] = minHeap->array[minHeap->size - 1];
--minHeap->size;
minHeap->array[0]->minHeapIndex = 0;
// remove the item from maxHeap

maxHeap->array[temp->maxHeapIndex] = maxHeap->array[maxHeap->size - 1];
--maxHeap->size;
maxHeap->array[temp->maxHeapIndex]->maxHeapIndex = temp->maxHeapIndex;
maxHeapify(maxHeap, temp->maxHeapIndex);
// remove the node from List

}
// Function to enList an item to List

void insertAtHead(struct List* list, struct LNode* temp)
{
if (isListEmpty(list))
list->head = temp;
else
{
temp->next = list->head;
list->head->prev = temp;
list->head = temp;
}
}
// Function to delete an item from List. The function also

// removes item from min and max heaps
void Delete(struct MyDS* myDS, int item)
{
if (isListEmpty(myDS->list))
return;
// search the node in List

struct LNode* temp = myDS->list->head;
while (temp && temp->data != item)
temp = temp->next;
// if item not found

if (!temp || temp && temp->data != item)
return;
// remove item from min heap

minHeap->array[temp->minHeapIndex] = minHeap->array[minHeap->size - 1];
--minHeap->size;
minHeap->array[temp->minHeapIndex]->minHeapIndex = temp->minHeapIndex;
minHeapify(minHeap, temp->minHeapIndex);
// remove item from max heap

maxHeap->array[temp->maxHeapIndex] = maxHeap->array[maxHeap->size - 1];
--maxHeap->size;
maxHeap->array[temp->maxHeapIndex]->maxHeapIndex = temp->maxHeapIndex;
maxHeapify(maxHeap, temp->maxHeapIndex);
// remove node from List

}
// insert operation for main data structure

void Insert(struct MyDS* myDS, int data)
{
struct LNode* temp = newLNode(data);
// insert the item in List

insertAtHead(myDS->list, temp);
// insert the item in min heap

insertMinHeap(myDS->minHeap, temp);
// insert the item in max heap

insertMaxHeap(myDS->maxHeap, temp);
}

int main()
{
struct MyDS *myDS = createMyDS(10);
// Test Case #1
/*Insert(myDS, 10);
Insert(myDS, 2);
Insert(myDS, 32);
Insert(myDS, 40);
Insert(myDS, 5);*/
// Test Case #2
Insert(myDS, 10);
Insert(myDS, 20);
Insert(myDS, 30);
Insert(myDS, 40);
Insert(myDS, 50);
printf("Maximum = %d \n", findMax(myDS));
printf("Minimum = %d \n\n", findMin(myDS));
deleteMax(myDS); // 50 is deleted
printf("After deleteMax()\n");
deleteMin(myDS); // 10 is deleted
printf("After deleteMin()\n");
Delete(myDS, 40); // 40 is deleted

printf("After Delete()\n");
printf("Minimum = %d \n", findMin(myDS));
return 0;
}

Output:

Maximum = 50
Minimum = 10
After deleteMax()
Maximum = 40
Minimum = 10
After deleteMin()
Maximum = 40
Minimum = 20
After Delete()
Maximum = 30
Minimum = 20

Find the first circular tour that visits all petrol pumps
Suppose there is a circle. There are n petrol pumps on that circle. You are given two sets of data.
1. The amount of petrol that petrol pump will give.

2. Distance from that petrol pump to the next petrol pump.
Calculate the first point from where a truck will be able to complete the circle (The truck will stop at each
petrol pump and it has infinite capacity). Expected time complexity is O(n). Assume for 1 litre petrol, the
truck can go 1 unit of distance.
For example, let there be 4 petrol pumps with amount of petrol and distance to next petrol pump value pairs
as {4, 6}, {6, 5}, {7, 3} and {4, 5}. The first point from where truck can make a circular tour is 2nd petrol
pump. Output should be “start = 1″ (index of 2nd petrol pump).
A Simple Solution is to consider every petrol pumps as starting point and see if there is a possible tour. If
we find a starting point with feasible solution, we return that starting point. The worst case time complexity
of this solution is O(n^2).
We can use a Queue to store the current tour. We first enqueue first petrol pump to the queue, we keep
enqueueing petrol pumps till we either complete the tour, or current amount of petrol becomes negative. If
the amount becomes negative, then we keep dequeueing petrol pumps till the current amount becomes
positive or queue becomes empty.
Instead of creating a separate queue, we use the given array itself as queue. We maintain two index variables
start and end that represent rear and front of queue.
// C program to find circular tour for a truck

#include <stdio.h>
// A petrol pump has petrol and distance to next petrol pump

struct petrolPump
{
int petrol;
int distance;
};
// The function returns starting point if there is a possible solution,

// otherwise returns -1
int printTour(struct petrolPump arr[], int n)
{
// Consider first petrol pump as a starting point
int start = 0;
int end = 1;
int curr_petrol = arr[start].petrol - arr[start].distance;
/* Run a loop while all petrol pumps are not visited.

And we have reached first petrol pump again with 0 or more petrol */
while (end != start || curr_petrol < 0)
{
// If curremt amount of petrol in truck becomes less than 0, then
// remove the starting petrol pump from tour
while (curr_petrol < 0 && start != end)
{
// Remove starting petrol pump. Change start
curr_petrol -= arr[start].petrol - arr[start].distance;
start = (start + 1)%n;
// If 0 is being considered as start again, then there is no
// possible solution
if (start == 0)
return -1;
}
// Add a petrol pump to current tour

curr_petrol += arr[end].petrol - arr[end].distance;
end = (end + 1)%n;

}
// Return starting point

return start;
}

int main()
{
struct petrolPump arr[] = {{6, 4}, {3, 6}, {7, 3}};
int start = printTour(arr, n);
(start == -1)? printf("No solution"): printf("Start = %d", start);
return 0;
}

Output:

start = 2

Time Complexity: Seems to be more than linear at first look. If we consider the items between start and
end as part of a circular queue, we can observe that every item is enqueued at most two times to the queue.
The total number of operations is proportional to total number of enqueue operations. Therefore the time
complexity is O(n).
discussed above
Count words in a given string
Given a string, count number of words in it. The words are separated by following characters: space (‘ ‘) or
new line (‘\n’) or tab (‘\t’) or a combination of these.
There can be many solutions to this problem. Following is a simple and interesting solution.
The idea is to maintain two states: IN and OUT. The state OUT indicates that a separator is seen. State IN
indicates that a word character is seen. We increment word count when previous state is OUT and next
character is a word character.
/* Program to count no of words from given input string. */

#include <stdio.h>
#define OUT 0
#define IN 1
// returns number of words in str

unsigned countWords(char *str)
{
int state = OUT;
unsigned wc = 0; // word count
// Scan all characters one by one

while (*str)
{
// If next character is a separator, set the state as OUT
if (*str == ' ' || *str == '\n' || *str == '\t')
state = OUT;
// If next character is not a word separator and state is OUT,

// then set the state as IN and increment word count
else if (state == OUT)
{
state = IN;
++wc;
}
// Move to next character

++str;
}
return wc;
}
// Driver program to tes above functions

int main(void)
{
char str[] = "One two three\n four\nfive ";
printf("No of words: %u\n", countWords(str));
return 0;
}

Output:

No of words: 5

Add two bit strings
Given two bit sequences as strings, write a function to return the addition of the two sequences. Bit strings
can be of different lengths also. For example, if string 1 is “1100011” and second string 2 is “10”, then the
function should return “1100101”.
Since sizes of two strings may be different, we first make the size of smaller string equal to that of bigger
string by adding leading 0s. After making sizes same, we one by one add bits from rightmost bit to leftmost
bit. In every iteration, we need to sum 3 bits: 2 bits of 2 given strings and carry. The sum bit will be 1 if,
either all of the 3 bits are set or one of them is set. So we can do XOR of all bits to find the sum bit. How to
find carry – carry will be 1 if any of the two bits is set. So we can find carry by taking OR of all pairs.
Following is step by step algorithm.
1. Make them equal sized by adding 0s at the begining of smaller string.

2. Perform bit addition
…..Boolean expression for adding 3 bits a, b, c
…..Sum = a XOR b XOR c
…..Carry = (a AND b) OR ( b AND c ) OR ( c AND a )
#include <iostream>
//adds the two bit strings and return the result

string addBitStrings( string first, string second );
// Helper method: given two unequal sized bit strings, converts them to
// same length by aadding leading 0s in the smaller string. Returns the
// the new length
int makeEqualLength(string &str1, string &str2)
{
int len1 = str1.size();
if (len1 < len2)
{
for (int i = 0 ; i < len2 - len1 ; i++)
str1 = '0' + str1;
return len2;
}
else if (len1 > len2)
{
str2 = '0' + str2;
}
return len1; // If len1 >= len2
}
// The main function that adds two bit sequences and returns the addition
string addBitStrings( string first, string second )
{
string result; // To store the sum bits
// make the lengths same before adding

int length = makeEqualLength(first, second);
int carry = 0; // Initialize carry
// Add all bits one by one

for (int i = length-1 ; i >= 0 ; i--)
{
int firstBit = first.at(i) - '0';
int secondBit = second.at(i) - '0';
// boolean expression for sum of 3 bits

int sum = (firstBit ^ secondBit ^ carry)+'0';
result = (char)sum + result;
// boolean expression for 3-bit addition

carry = (firstBit & secondBit) | (secondBit & carry) | (firstBit & carry);
}
// if overflow, then add a leading 1

if (carry)
result = '1' + result;
return result;
}

int main()
{
string str1 = "1100011";
string str2 = "10";
cout << "Sum is " << addBitStrings(str1, str2);

return 0;
}

Output:

Sum is 1100101

This article is compiled by Ravi Chandra Enaganti. Please write comments if you find anything incorrect,
Dynamic Programming | Set 26 (Largest Independent Set Problem)
Given a Binary Tree, find size of the L argest Independent Set(LIS) in it. A subset of all tree nodes is an
independent set if there is no edge between any two nodes of the subset.
For example, consider the following binary tree. The largest independent set(LIS) is {10, 40, 60, 70, 80} and
size of the LIS is 5.
A Dynamic Programming solution solves a given problem using solutions of subproblems in bottom up
manner. Can the given problem be solved using solutions to subproblems? If yes, then what are the
subproblems? Can we find largest independent set size (LISS) for a node X if we know LISS for all
descendants of X? If a node is considered as part of LIS, then its children cannot be part of LIS, but its
grandchildren can be. Following is optimal substructure property.
Let LISS(X) indicates size of largest independent set of a tree with root X.
LISS(X) = MAX { (1 + sum of LISS for all grandchildren of X),

(sum of LISS for all children of X) }

The idea is simple, there are two possibilities for every node X, either X is a member of the set or not a
member. If X is a member, then the value of LISS(X) is 1 plus LISS of all grandchildren. If X is not a member,
then the value is sum of LISS of all children.
// A naive recursive implementation of Largest Independent Set problem

#include <stdio.h>
#include <stdlib.h>
// A utility function to find max of two integers

int max(int x, int y) { return (x > y)? x: y; }
/* A binary tree node has data, pointer to left child and a pointer to
right child */
struct node
{
int data;
};
// The function returns size of the largest independent set in a given
// binary tree
int LISS(struct node *root)
{
if (root == NULL)
return 0;
// Caculate size excluding the current node

int size_excl = LISS(root->left) + LISS(root->right);
// Calculate size including the current node

int size_incl = 1;
if (root->left)
size_incl += LISS(root->left->left) + LISS(root->left->right);
if (root->right)
size_incl += LISS(root->right->left) + LISS(root->right->right);
// Return the maximum of two sizes

return max(size_incl, size_excl);
}

{
temp->data = data;
return temp;
}

int main()
{
printf ("Size of the Largest Independent Set is %d ", LISS(root));
return 0;
}

Output:

Size of the Largest Independent Set is 5

function computes the same subproblems again and again. For example, LISS of node with value 50 is
evaluated for node with values 10 and 20 as 50 is grandchild of 10 and child of 20.
Since same suproblems are called again, this problem has Overlapping Subprolems property. So LISS
problem has both properties (see this and this) of a dynamic programming problem. Like other typical
Dynamic Programming(DP) problems, recomputations of same subproblems can be avoided by storing the
solutions to subproblems and solving problems in bottom up manner.
Following is C implementation of Dynamic Programming based solution. In the following solution, an

additional field ‘liss’ is added to tree nodes. The initial value of ‘liss’ is set as 0 for all nodes. The recursive
function LISS() calculates ‘liss’ for a node only if it is not already set.
/* Dynamic programming based program for Largest Independent Set problem */

#include <stdio.h>
#include <stdlib.h>

int max(int x, int y) { return (x > y)? x: y; }
right child */
struct node
{
int data;
int liss;
};
// A memoization function returns size of the largest independent set in

// a given binary tree
int LISS(struct node *root)
{
if (root == NULL)
return 0;
if (root->liss)
return root->liss;
if (root->left == NULL && root->right == NULL)

return (root->liss = 1);
// Calculate size excluding the current node

int liss_excl = LISS(root->left) + LISS(root->right);
// Calculate size including the current node

int liss_incl = 1;
if (root->left)
liss_incl += LISS(root->left->left) + LISS(root->left->right);
if (root->right)
liss_incl += LISS(root->right->left) + LISS(root->right->right);
// Maximum of two sizes is LISS, store it for future uses.

root->liss = max(liss_incl, liss_excl);
return root->liss;
}

{
temp->data = data;
temp->liss = 0;
return temp;
return temp;
}

int main()
{
printf ("Size of the Largest Independent Set is %d ", LISS(root));
return 0;
}

Output

Size of the Largest Independent Set is 5

Time Complexity: O(n) where n is the number of nodes in given Binary tree.
Following extensions to above solution can be tried as an exercise.

1) Extend the above solution for n-ary tree.
2) The above solution modifies the given tree structure by adding an additional field ‘liss’ to tree nodes.
Extend the solution so that it doesn’t modify the tree structure.
3) The above solution only returns size of LIS, it doesn’t print elements of LIS. Extend the solution to print
all nodes that are part of LIS.
discussed above.
Arrange given numbers to form the biggest number
Given an array of numbers, arrange them in a way that yields the largest value. For example, if the given
numbers are {54, 546, 548, 60}, the arrangement 6054854654 gives the largest value. And if the given
numbers are {1, 34, 3, 98, 9, 76, 45, 4}, then the arrangement 998764543431 gives the largest value.
A simple solution that comes to our mind is to sort all numbers in descending order, but simply sorting
doesn’t work. For example, 548 is greater than 60, but in output 60 comes before 548. As a second example,
98 is greater than 9, but 9 comes before 98 in output.
So how do we go about it? The idea is to use any comparison based sorting algorithm. In the used sorting
algorithm, instead of using the default comparison, write a comparison function myCompare() and use it to
sort numbers. Given two numbers X and Y, how should myCompare() decide which number to put first – we
compare two numbers XY (Y appended at the end of X) and YX (X appended at the end of Y). If XY is larger,
then X should come before Y in output, else Y should come before. For example, let X and Y be 542 and 60.
To compare X and Y, we compare 54260 and 60542. Since 60542 is greater than 54260, we put Y first.
Following is C++ implementation of the above approach. To keep the code simple, numbers are considered
as strings, and vector is used instead of normal array.
// Given an array of numbers, program to arrange the numbers to form the

// largest number
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
// A comparison function which is used by sort() in printLargest()

int myCompare(string X, string Y)
{
// first append Y at the end of X
string XY = X.append(Y);
// then append X at the end of Y

string YX = Y.append(X);
// Now see which of the two formed numbers is greater

return XY.compare(YX) > 0 ? 1: 0;
}
// The main function that prints the arrangement with the largest value.
// The function accepts a vector of strings
void printLargest(vector<string> arr)
{
// Sort the numbers using library sort funtion. The function uses
// our comparison function myCompare() to compare two strings.
// See http://www.cplusplus.com/reference/algorithm/sort/ for details
sort(arr.begin(), arr.end(), myCompare);
for (int i=0; i < arr.size() ; i++ )

cout << arr[i];
}
// driverr program to test above functions

int main()
{
vector<string> arr;
//output should be 6054854654
arr.push_back("54");
printLargest(arr);
// output should be 777776

/*arr.push_back("7");
arr.push_back("7");
arr.push_back("7");*/
//output should be 998764543431

/*arr.push_back("1");
arr.push_back("3");
arr.push_back("9");
arr.push_back("4");
*/
return 0;
}

Output:

6054854654

Flatten a multilevel linked list
Given a linked list where in addition to the next pointer, each node has a child pointer, which may or may
not point to a separate list. These child lists may have one or more children of their own, and so on, to
produce a multilevel data structure, as shown in below figure.You are given the head of the first level of the
list. Flatten the list so that all the nodes appear in a single-level linked list. You need to flatten the list in way
that all nodes at first level should come first, then nodes of second level, and so on.
Each node is a C struct with the following definition.
struct list
{
int data;
struct list *next;
struct list *child;
};

The above list should be converted to 10->5->12->7->11->4->20->13->17->6->2->16->9->8-

>3->19->15
The problem clearly say that we need to flatten level by level. The idea of solution is, we start from first level,
process all nodes one by one, if a node has a child, then we append the child at the end of list, otherwise we
don’t do anything. After the first level is processed, all next level nodes will be appended after first level.
Same process is followed for the appended nodes.

1) Take "cur" pointer, which will point to head of the fist level of the list
2) Take "tail" pointer, which will point to end of the first level of the list
3) Repeat the below procedure while "curr" is not NULL.
I) if current node has a child then
a) append this new child list to the "tail"
tail->next = cur->child
b) find the last node of new child list and update "tail"
tmp = cur->child;
while (tmp->next != NULL)
tmp = tmp->next;
tail = tmp;
II) move to the next node. i.e. cur = cur->next

// Program to flatten list with next and child pointers

#include <stdio.h>
#include <stdlib.h>
// Macro to find number of elements in array

#define SIZE(arr) (sizeof(arr)/sizeof(arr[0]))
// A linked list node has data, next pointer and child pointer
struct node
{
int data;
struct node *next;
struct node *child;
};
// A utility function to create a linked list with n nodes. The data

// of nodes is taken from arr[]. All child pointers are set as NULL
struct node *createList(int *arr, int n)
{
struct node *p;
int i;
for (i = 0; i < n; ++i) {
if (head == NULL)
head = p = (struct node *)malloc(sizeof(*p));
else {
p->next = (struct node *)malloc(sizeof(*p));
p = p->next;
}
p->data = arr[i];
p->next = p->child = NULL;
}
return head;
}
// A utility function to print all nodes of a linked list

{
while (head != NULL) {
head = head->next;
head = head->next;
}
printf("\n");
}
// This function creates the input list. The created list is same
// as shown in the above figure
struct node *createList(void)
{
int arr1[] = {10, 5, 12, 7, 11};
int arr2[] = {4, 20, 13};
int arr3[] = {17, 6};
int arr4[] = {9, 8};
int arr5[] = {19, 15};
int arr6[] = {2};
int arr7[] = {16};
int arr8[] = {3};
/* create 8 linked lists */

struct node *head1 = createList(arr1, SIZE(arr1));
/* modify child pointers to create the list shown above */

head1->child = head2;
head1->next->next->next->child = head3;
head2->next->child = head6;
head2->next->next->child = head7;
/* Return head pointer of first linked list. Note that all nodes are
reachable from head1 */
return head1;
}
/* The main function that flattens a multilevel linked list */

void flattenList(struct node *head)
{
/*Base case*/
if (head == NULL)
return;
struct node *tmp;
/* Find tail node of first level linked list */

struct node *tail = head;
while (tail->next != NULL)
tail = tail->next;
// One by one traverse through all nodes of first level

// linked list till we reach the tail node
struct node *cur = head;
while (cur != tail)
{
// If current node has a child
if (cur->child)
if (cur->child)
{
// then append the child at the end of current list
tail->next = cur->child;
// and update the tail to new last node

tmp = cur->child;
while (tmp->next)
tmp = tmp->next;
tail = tmp;
}
// Change current node

cur = cur->next;
}
}
// A driver program to test above functions

int main(void)
{
head = createList();
flattenList(head);
printList(head);
return 0;
}

Output:

10 5 12 7 11 4 20 13 17 6 2 16 9 8 3 19 15

Time Complexity: Since every node is visited at most twice, the time complexity is O(n) where n is the
number of nodes in given linked list.
Iterative Postorder Traversal | Set 1 (Using Two Stacks)
We have discussed iterative inorder and iterative preorder traversals. In this post, iterative postorder
traversal is discussed which is more complex than the other two traversals (due to its nature of non-tail
recursion, there is an extra statement after the final recursive call to itself). The postorder traversal can
easily be done using two stacks though. The idea is to push reverse postorder traversal to a stack. Once we
have reverse postorder traversal in a stack, we can just pop all items one by one from the stack and print
them, this order of printing will be in postorder because of LIFO property of stacks. Now the question is, how
to get reverse post order elements in a stack – the other stack is used for this purpose. For example, in the
following tree, we need to get 1, 3, 7, 6, 2, 5, 4 in a stack. If take a closer look at this sequence, we can observe
that this sequence is very similar to preorder traversal. The only difference is right child is visited before left
child and therefore sequence is “root right left” instead of “root left right”. So we can do something like
iterative preorder traversal with following differences.
a) Instead of printing an item, we push it to a stack.
b) We push left subtree before right subtree.
Following is the complete algorithm. After step 2, we get reverse postorder traversal in second stack. We use
first stack to get this order.
1. Push root to first stack.

2. Loop while first stack is not empty
2.1 Pop a node from first stack and push it to second stack
2.2 Push left and right children of the popped node to first stack
3. Print contents of second stack

Let us consider the following tree
Following are the steps to print postorder traversal of the above tree using two stacks.

1. Push 1 to first stack.

First stack: 1
Second stack: Empty
2. Pop 1 from first stack and push it to second stack.

Push left and right children of 1 to first stack
First stack: 2, 3
Second stack: 1

First stack: 2, 6, 7
Second stack:1, 3

First stack: 2, 6
Second stack:1, 3, 7

First stack: 2
Second stack:1, 3, 7, 6

First stack: 4, 5
Second stack:1, 3, 7, 6, 2

First stack: 4
Second stack: 1, 3, 7, 6, 2, 5

First stack: Empty
Second stack: 1, 3, 7, 6, 2, 5, 4
The algorithm stops since there is no more item in first stack.

Observe that content of second stack is in postorder fashion. Print them.

Following is C implementation of iterative postorder traversal using two stacks.
#include <stdio.h>
#include <stdlib.h>
// Maximum stack size

#define MAX_SIZE 100
// A tree node
struct Node
{
int data;
};
// Stack type
struct Stack
{
int size;
int size;
int top;
struct Node* *array;
};

struct Node* newNode(int data)
{
struct Node* node = (struct Node*) malloc(sizeof(struct Node));
node->data = data;
node->left = node->right = NULL;
return node;
}
// A utility function to create a stack of given size

struct Stack* createStack(int size)
{
struct Stack* stack =
(struct Stack*) malloc(sizeof(struct Stack));
stack->size = size;
stack->top = -1;
stack->array =
(struct Node**) malloc(stack->size * sizeof(struct Node*));
return stack;
}
// BASIC OPERATIONS OF STACK

int isFull(struct Stack* stack)
{ return stack->top - 1 == stack->size; }
int isEmpty(struct Stack* stack)

{ return stack->top == -1; }
void push(struct Stack* stack, struct Node* node)

{
if (isFull(stack))
return;
stack->array[++stack->top] = node;
}
struct Node* pop(struct Stack* stack)

{
if (isEmpty(stack))
return NULL;
return stack->array[stack->top--];
}
// An iterative function to do post order traversal of a given binary tree

void postOrderIterative(struct Node* root)
{
// Create two stacks
struct Stack* s1 = createStack(MAX_SIZE);
// push root to first stack

push(s1, root);
struct Node* node;
// Run while first stack is not empty

{
// Pop an item from s1 and push it to s2
node = pop(s1);
push(s2, node);
// Push left and right children of removed item to s1
if (node->left)
push(s1, node->left);
if (node->right)
push(s1, node->right);
}
// Print all elements of second stack

{
node = pop(s2);
}
}

int main()
{
// Let us construct the tree shown in above figure
struct Node* root = NULL;
root = newNode(1);
postOrderIterative(root);
return 0;
}

Output:

4 5 2 6 7 3 1

Following is overview of the above post.

Iterative preorder traversal can be easily implemented using two stacks. The first stack is used to get the
reverse postorder traversal in second stack. The steps to get reverse postorder are similar to iterative
preorder.
You may also like to see a method which uses only one stack.
want to share more information about the topic discussed above
Generate n-bit Gray Codes
Given a number n, generate bit patterns from 0 to 2^n-1 such that successive patterns differ by one bit.
Examples:
Following is 2-bit sequence (n = 2)

00 01 11 10
Following is 3-bit sequence (n = 3)
000 001 011 010 110 111 101 100
And Following is 4-bit sequence (n = 4)
0000 0001 0011 0010 0110 0111 0101 0100 1100 1101 1111
1110 1010 1011 1001 1000

The above sequences are Gray Codes of different widths. Following is an interesting pattern in Gray Codes.
n-bit Gray Codes can be generated from list of (n-1)-bit Gray codes using following steps.
1) Let the list of (n-1)-bit Gray codes be L1. Create another list L2 which is reverse of L1.
2) Modify the list L1 by prefixing a ‘0’ in all codes of L1.
3) Modify the list L2 by prefixing a ‘1’ in all codes of L2.
4) Concatenate L1 and L2. The concatenated list is required list of n-bit Gray codes.
For example, following are steps for generating the 3-bit Gray code list from the list of 2-bit Gray code list.
L1 = {00, 01, 11, 10} (List of 2-bit Gray Codes)
L2 = {10, 11, 01, 00} (Reverse of L1)
Prefix all entries of L1 with ‘0’, L1 becomes {000, 001, 011, 010}
Prefix all entries of L2 with ‘1’, L2 becomes {110, 111, 101, 100}
Concatenate L1 and L2, we get {000, 001, 011, 010, 110, 111, 101, 100}
To generate n-bit Gray codes, we start from list of 1 bit Gray codes. The list of 1 bit Gray code is {0, 1}. We
repeat above steps to generate 2 bit Gray codes from 1 bit Gray codes, then 3-bit Gray codes from 2-bit Gray
codes till the number of bits becomes equal to n. Following is C++ implementation of this approach.

// C++ program to generate n-bit Gray codes

#include <iostream>
#include <string>
#include <vector>
// This function generates all n bit Gray codes and prints the
// generated codes
void generateGrayarr(int n)
{
// base case
if (n <= 0)
return;
// 'arr' will store all generated codes

vector<string> arr;
// start with one-bit pattern

arr.push_back("0");
arr.push_back("1");
// Every iteration of this loop generates 2*i codes from previously

// generated i codes.
int i, j;
for (i = 2; i < (1<<n); i = i<<1)
{
// Enter the prviously generated codes again in arr[] in reverse
// order. Nor arr[] has double number of codes.
for (j = i-1 ; j >= 0 ; j--)
arr.push_back(arr[j]);
// append 0 to the first half

for (j = 0 ; j < i ; j++)
arr[j] = "0" + arr[j];
// append 1 to the second half

for (j = i ; j < 2*i ; j++)
arr[j] = "1" + arr[j];
}
// print contents of arr[]

for (i = 0 ; i < arr.size() ; i++ )
cout << arr[i] << endl;
}

int main()
{
generateGrayarr(4);
return 0;
}

Output

000
001
011
010
110
111
101
100

Iterative Postorder Traversal | Set 2 (Using One Stack)
We have discussed a simple iterative postorder traversal using two stacks in the previous post. In this post,
an approach with only one stack is discussed.
The idea is to move down to leftmost node using left pointer. While moving down, push root and root’s right
child to stack. Once we reach leftmost node, print it if it doesn’t have a right child. If it has a right child, then
change root so that the right child is processed before.
Following is detailed algorithm.

1.1 Create an empty stack
2.1 Do following while root is not NULL
a) Push root's right child and then root to stack.
b) Set root as root's left child.
2.2 Pop an item from stack and set it as root.
a) If the popped item has a right child and the right child
is at top of stack, then remove the right child from stack,
push the root back and set root as root's right child.
b) Else print root's data and set root as NULL.
2.3 Repeat steps 2.1 and 2.2 while stack is not empty.

Let us consider the following tree
Following are the steps to print postorder traversal of the above tree using one stack.

1. Right child of 1 exists.

Push 3 to stack. Push 1 to stack. Move to left child.
Stack: 3, 1
2. Right child of 2 exists.

Push 5 to stack. Push 2 to stack. Move to left child.
Stack: 3, 1, 5, 2
3. Right child of 4 doesn't exist. '

Push 4 to stack. Move to left child.
Stack: 3, 1, 5, 2, 4
4. Current node is NULL.

Pop 4 from stack. Right child of 4 doesn't exist.
Print 4. Set current node to NULL.
Stack: 3, 1, 5, 2
5. Current node is NULL.

Pop 2 from stack. Since right child of 2 equals stack top element,
pop 5 from stack. Now push 2 to stack.
Move current node to right child of 2 i.e. 5
Stack: 3, 1, 2
6. Right child of 5 doesn't exist. Push 5 to stack. Move to left child.

Stack: 3, 1, 2, 5
7. Current node is NULL. Pop 5 from stack. Right child of 5 doesn't exist.
Stack: 3, 1, 2
8. Current node is NULL. Pop 2 from stack.

Right child of 2 is not equal to stack top element.
Stack: 3, 1
9. Current node is NULL. Pop 1 from stack.

Since right child of 1 equals stack top element, pop 3 from stack.
Now push 1 to stack. Move current node to right child of 1 i.e. 3
Stack: 1
10. Repeat the same as above steps and Print 6, 7 and 3.

Pop 1 and Print 1.

// C program for iterative postorder traversal using one stack

#include <stdio.h>
#include <stdlib.h>

// A tree node
struct Node
{
int data;
};
// Stack type
struct Stack
{
int size;
int top;
};

{
node->data = data;
return node;
}

{
struct Stack* stack = (struct Stack*) malloc(sizeof(struct Stack));
stack->size = size;
stack->top = -1;
stack->array = (struct Node**) malloc(stack->size * sizeof(struct Node*));
return stack;
}



{
if (isFull(stack))
return;
}

{
if (isEmpty(stack))
return NULL;
}
struct Node* peek(struct Stack* stack)

{
if (isEmpty(stack))
return NULL;
return stack->array[stack->top];
}
// An iterative function to do postorder traversal of a given binary tree

void postOrderIterative(struct Node* root)
{
// Check for empty tree
if (root == NULL)
return;

struct Stack* stack = createStack(MAX_SIZE);
do
do
{
// Move to leftmost node
while (root)
{
// Push root's right child and then root to stack.
if (root->right)
push(stack, root->right);
push(stack, root);
// Set root as root's left child

root = root->left;
}
// Pop an item from stack and set it as root

root = pop(stack);
// If the popped item has a right child and the right child is not
// processed yet, then make sure right child is processed before root
if (root->right && peek(stack) == root->right)
{
pop(stack); // remove right child from stack
push(stack, root); // push root back to stack
root = root->right; // change root so that the right
// child is processed next
}
else // Else print root's data and set root as NULL
{
root = NULL;
}
} while (!isEmpty(stack));
}

int main()
{
// Let us construct the tree shown in above figure
root = newNode(1);
postOrderIterative(root);
return 0;
}

Output:

4 5 2 6 7 3 1

Dynamic Programming | Set 27 (Maximum sum rectangle in a 2D matrix)
Given a 2D array, find the maximum sum subarray in it. For example, in the following 2D array, the
maximum sum subarray is highlighted with blue rectangle and sum of this subarray is 29.
This problem is mainly an extension of Largest Sum Contiguous Subarray for 1D array.
The naive solution for this problem is to check every possible rectangle in given 2D array. This solution
requires 4 nested loops and time complexity of this solution would be O(n^4).
Kadane’s algorithm for 1D array can be used to reduce the time complexity to O(n^3). The idea is to fix
the left and right columns one by one and find the maximum sum contiguous rows for every left and right
column pair. We basically find top and bottom row numbers (which have maximum sum) for every fixed left
and right column pair. To find the top and bottom row numbers, calculate sun of elements in every row from
left to right and store these sums in an array say temp[]. So temp[i] indicates sum of elements from left to
right in row i. If we apply Kadane’s 1D algorithm on temp[], and get the maximum sum subarray of temp,
this maximum sum would be the maximum possible sum with left and right as boundary columns. To get
the overall maximum sum, we compare this sum with the maximum sum so far.
// Program to find maximum sum subarray in a given 2D array

#include <stdio.h>
#include <string.h>
#include <limits.h>
#define ROW 4
#define COL 5
// Implementation of Kadane's algorithm for 1D array. The function returns the

// maximum sum and stores starting and ending indexes of the maximum sum subarray
// at addresses pointed by start and finish pointers respectively.
int kadane(int* arr, int* start, int* finish, int n)
{
// initialize sum, maxSum and
int sum = 0, maxSum = INT_MIN, i;
// Just some initial value to check for all negative values case
*finish = -1;
// local variable
int local_start = 0;
for (i = 0; i < n; ++i)

{
sum += arr[i];
if (sum < 0)
{
{
sum = 0;
local_start = i+1;
}
else if (sum > maxSum)
{
maxSum = sum;
*start = local_start;
*finish = i;
}
}
// There is at-least one non-negative number

if (*finish != -1)
return maxSum;
// Special Case: When all numbers in arr[] are negative

maxSum = arr[0];
*start = *finish = 0;
// Find the maximum element in array

for (i = 1; i < n; i++)
{
if (arr[i] > maxSum)
{
maxSum = arr[i];
*start = *finish = i;
}
}
return maxSum;
}
// The main function that finds maximum sum rectangle in M[][]

void findMaxSum(int M[][COL])
{
// Variables to store the final output
int maxSum = INT_MIN, finalLeft, finalRight, finalTop, finalBottom;
int left, right, i;

int temp[ROW], sum, start, finish;
// Set the left column

for (left = 0; left < COL; ++left)
{
// Initialize all elements of temp as 0
memset(temp, 0, sizeof(temp));
// Set the right column for the left column set by outer loop
for (right = left; right < COL; ++right)
{
// Calculate sum between current left and right for every row 'i'
for (i = 0; i < ROW; ++i)
temp[i] += M[i][right];
// Find the maximum sum subarray in temp[]. The kadane() function

// also sets values of start and finish. So 'sum' is sum of
// rectangle between (start, left) and (finish, right) which is the
// maximum sum with boundary columns strictly as left and right.
sum = kadane(temp, &start, &finish, ROW);
// Compare sum with maximum sum so far. If sum is more, then update
// maxSum and other output values
if (sum > maxSum)
{
maxSum = sum;
maxSum = sum;
finalLeft = left;
finalRight = right;
finalTop = start;
finalBottom = finish;
}
}
}
// Print final values

printf("(Top, Left) (%d, %d)\n", finalTop, finalLeft);
printf("(Bottom, Right) (%d, %d)\n", finalBottom, finalRight);
printf("Max sum is: %d\n", maxSum);
}

int main()
{
int M[ROW][COL] = {{1, 2, -1, -4, -20},
{-8, -3, 4, 2, 1},
{3, 8, 10, 1, 3},
{-4, -1, 1, 7, -6}
};
findMaxSum(M);
return 0;
}

Output:

(Top, Left) (1, 1)
(Bottom, Right) (3, 3)
Max sum is: 29

G-Fact 17
Storage class of a variable determines whether the item has a global or local lifetime. In C, typedef is
considered as a storage class like other storage classes (auto, register, static and extern), nevertheless the
purpose of typedef is to assign alternative names to existing types.
For example, the following program compiles and runs fime
#include <stdio.h>
int main()
{
typedef int points;
points x = 5;
printf("%d ", x);
return 0;
}

Output:
But the following program fails with compiler error.
#include <stdio.h>
int main()
{
typedef static int points;
points x;
return 0;
}

Output:

Compiler Error: multiple storage classes in declaration specifiers

See this quiz for practice on storage class and type specifiers. Please write comments if you find anything
incorrect, or you want to share more information about the topic discussed above.
Pancake sorting
Given an an unsorted array, sort the given array. You are allowed to do only following operation on array.
flip(arr, i): Reverse array from 0 to i

Unlike a traditional sorting algorithm, which attempts to sort with the fewest comparisons possible, the goal
is to sort the sequence in as few reversals as possible.
The idea is to do something similar to Selection Sort. We one by one place maximum element at the end and
reduce the size of current array by one.
Following are the detailed steps. Let given array be arr[] and size of array be n.
1) Start from current size equal to n and reduce current size by one while it’s greater than 1. Let the current
size be curr_size. Do following for every curr_size
……a) Find index of the maximum element in arr[0..curr_szie-1]. Let the index be ‘mi’
……b) Call flip(arr, mi)
……c) Call flip(arr, curr_size-1)
See following video for visualization of the above algorithm.
[iframe width=”340″ height=”252″ src=”http://www.youtube.com/embed/kk-_DDgoXfk”

frameborder=”0″]
/* A C++ program for Pancake Sorting */

#include <stdlib.h>
#include <stdio.h>
/* Reverses arr[0..i] */
void flip(int arr[], int i)
{
int temp, start = 0;
while (start < i)
{
temp = arr[start];
arr[start] = arr[i];
arr[i] = temp;
start++;
i--;
}
}
/* Returns index of the maximum element in arr[0..n-1] */

int findMax(int arr[], int n)
{
int mi, i;
for (mi = 0, i = 0; i < n; ++i)
if (arr[i] > arr[mi])
mi = i;
return mi;
}
// The main function that sorts given array using flip operations
int pancakeSort(int *arr, int n)
{
// Start from the complete array and one by one reduce current size by one
// Start from the complete array and one by one reduce current size by one
for (int curr_size = n; curr_size > 1; --curr_size)
{
// Find index of the maximum element in arr[0..curr_size-1]
int mi = findMax(arr, curr_size);
// Move the maximum element to end of current array if it's not

// already at the end
if (mi != curr_size-1)
{
// To move at the end, first move maximum number to beginning
flip(arr, mi);
// Now move the maximum number to end by reversing current array

flip(arr, curr_size-1);
}
}
}
/* A utility function to print an array of size n */

{
for (int i = 0; i < n; ++i)
}

int main()
{
int arr[] = {23, 10, 20, 11, 12, 6, 7};
pancakeSort(arr, n);
puts("Sorted Array ");

printArray(arr, n);
return 0;
}

Output:

Sorted Array
6 7 10 11 12 20 23

Total O(n) flip operations are performed in above code. The overall time complexity is O(n^2).
References:
http://en.wikipedia.org/wiki/Pancake_sorting
discussed above.
A Pancake Sorting Problem
We have discussed Pancake Sorting in the previous post. Following is a problem based on Pancake Sorting.
Given an an unsorted array, sort the given array. You are allowed to do only following operation on array.
flip(arr, i): Reverse array from 0 to i

Imagine a hypothetical machine where flip(i) always takes O(1) time . Write an efficient
program for sorting a given array in O(nLogn) time on the given machine. If we apply the same
algorithm here, the time taken will be O(n^2) because the algorithm calls findMax() in a loop and find
findMax() takes O(n) time even on this hypothetical machine.
We can use insertion sort that uses binary search. The idea is to run a loop from second element to last
element (from i = 1 to n-1), and one by one insert arr[i] in arr[0..i-1] (like standard insertion sort algorithm).
When we insert an element arr[i], we can use binary search to find position of arr[i] in O(Logi) time. Once we
have the position, we can use some flip operations to put arr[i] at its new place. Following are abstract steps.
// Standard Insertion Sort Loop that starts from second element

for (i=1; i O(n)
{
int key = arr[i];
// Find index of ceiling of arr[i] in arr[0..i-1] using binary search

j = celiSearch(arr, key, 0, i-1); ----> O(logn) (See this)

// Apply some flip operations to put arr[i] at correct place
}

Since flip operation takes O(1) on given hypothetical machine, total running time of above algorithm is
O(nlogn). Thanks to Kumar for suggesting above problem and algorithm.
Let us see how does the above algorithm work. ceilSearch() actually returns the index of the smallest element
which is greater than arr[i] in arr[0..i-1]. If there is no such element, it returns -1. Let the returned value be j.
If j is -1, then we don’t need to do anything as arr[i] is already the greatest element among arr[0..i].
Otherwise we need to put arr[i] just before arr[j].
So how to apply flip operations to put arr[i] just before arr[j] using values of i and j. Let us take an example to
understand this. Let i be 6 and current array be {12, 15, 18, 30, 35, 40, 20, 6, 90, 80}. To put 20 at its new
place, the array should be changed to {12, 15, 18, 20, 30, 35, 40, 6, 90, 80}. We apply following steps to put
20 at its new place.
1) Find j using ceilSearch (In the above example j is 3).

2) flip(arr, j-1) (array becomes {18, 15, 12, 30, 35, 40, 20, 6, 90, 80})
3) flip(arr, i-1); (array becomes {40, 35, 30, 12, 15, 18, 20, 6, 90, 80})
4) flip(arr, i); (array becomes {20, 18, 15, 12, 30, 35, 40, 6, 90, 80})
5) flip(arr, j); (array becomes {12, 15, 18, 20, 30, 35, 40, 6, 90, 80})

#include <stdlib.h>
#include <stdio.h>
/* A Binary Search based function to get index of ceiling of x in

arr[low..high] */
{
int mid;
/* If x is smaller than or equal to the first element,

if(x <= arr[low])
return low;
/* If x is greater than the last element, then return -1 */

if(x > arr[high])
return -1;
/* get the index of middle element of arr[low..high]*/

mid = (low + high)/2; /* low + (high – low)/2 */

if(arr[mid] == x)
return mid;

is ceiling of x, or ceiling lies in arr[mid+1...high] */
if(arr[mid] < x)
{
if(mid + 1 <= high && x <= arr[mid+1])
return mid + 1;
else
return ceilSearch(arr, mid+1, high, x);
}
/* If x is smaller than arr[mid], then either arr[mid]

is ceiling of x or ceiling lies in arr[mid-1...high] */
if (mid - 1 >= low && x > arr[mid-1])
return mid;
else
return ceilSearch(arr, low, mid - 1, x);
}
/* Reverses arr[0..i] */
void flip(int arr[], int i)
{
int temp, start = 0;
while (start < i)
{
temp = arr[start];
arr[start] = arr[i];
arr[i] = temp;
start++;
i--;
}
}
/* Function to sort an array using insertion sort, binary search and flip */
void insertionSort(int arr[], int size)
{
int i, j;
// Start from the second element and one by one insert arr[i]
// in already sorted arr[0..i-1]
{
// Find the smallest element in arr[0..i-1] which is also greater than
// or equal to arr[i]
int j = ceilSearch(arr, 0, i-1, arr[i]);
// Check if there was no element greater than arr[i]

if (j != -1)
{
// Put arr[i] before arr[j] using following four flip operations
flip(arr, j-1);
flip(arr, i-1);
flip(arr, i);
flip(arr, j);
}
}
}
/* A utility function to print an array of size n */

{
int i;
for (i = 0; i < n; ++i)
}
/* Driver program to test insertion sort */

int main()
{
int arr[] = {18, 40, 35, 12, 30, 35, 20, 6, 90, 80};
insertionSort(arr, n);
printArray(arr, n);
return 0;
}

Output:

6 12 18 20 30 35 35 40 80 90

discussed above.
Swap all odd and even bits
Given an unsigned integer, swap all odd bits with even bits. For example, if the given number is 23
(00010111), it should be converted to 43 (00101011). Every even position bit is swapped with adjacent bit
on right side (even position bits are highlighted in binary representation of 23), and every odd position bit is
swapped with adjacent on left side.
If we take a closer look at the example, we can observe that we basically need to right shift (>>) all even bits
(In the above example, even bits of 23 are highlighted) by 1 so that they become odd bits (highlighted in 43),
and left shift ( // C program to swap even and odd bits of a given number #include <stdio.h> unsigned int
swapBits(unsigned int x) { // Get all even bits of x unsigned int even_bits = x & 0xAAAAAAAA; // Get all odd
bits of x unsigned int odd_bits = x & 0x55555555; even_bits >>= 1; // Right shift even bits odd_bits <<= 1;
// Left shift odd bits return (even_bits | odd_bits); // Combine even and odd bits } // Driver program to test
above function int main() { unsigned int x = 23; // 00010111 // Output is 43 (00101011) printf("%u ",
swapBits(x)); return 0; }
Output:

43

discussed above.
Find if there is a triplet in a Balanced BST that adds to zero
Given a Balanced Binary Search Tree (BST), write a function isTripletPresent() that returns true if there is a
triplet in given BST with sum equals to 0, otherwise returns false. Expected time complexity is O(n^2) and
only O(Logn) extra space can be used. You can modify given Binary Search Tree. Note that height of a
Balanced BST is always O(Logn)
For example, isTripletPresent() should return true for following BST because there is a triplet with sum 0,
the triplet is {-13, 6, 7}.
The Brute Force Solution is to consider each triplet in BST and check whether the sum adds upto zero.
The time complexity of this solution will be O(n^3).
A Better Solution is to create an auxiliary array and store Inorder traversal of BST in the array. The array
will be sorted as Inorder traversal of BST always produces sorted data. Once we have the Inorder traversal,
we can use method 2 of this post to find the triplet with sum equals to 0. This solution works in O(n^2) time,
but requires O(n) auxiliary space.
Following is the solution that works in O(n^2) time and uses O(Logn) extra space :
1) Convert given BST to Doubly Linked List (DLL)
2) Now iterate through every node of DLL and if the key of node is negative, then find a pair in DLL with
sum equal to key of current node multiplied by -1. To find the pair, we can use the approach used in
hasArrayTwoCandidates() in method 1 of this post.
// A C++ program to check if there is a triplet with sum equal to 0 in

// a given BST
#include<stdio.h>
// A BST node has key, and left and right pointers

struct node
{
int key;
struct node *left;
struct node *right;
};
// A function to convert given BST to Doubly Linked List. left pointer is used
// as previous pointer and right pointer is used as next pointer. The function
// sets *head to point to first and *tail to point to last node of converted DLL
void convertBSTtoDLL(node* root, node** head, node** tail)
{
// Base case
if (root == NULL)
return;
// First convert the left subtree

if (root->left)
convertBSTtoDLL(root->left, head, tail);
// Then change left of current root as last node of left subtree

root->left = *tail;
// If tail is not NULL, then set right of tail as root, else current
// node is head
if (*tail)
(*tail)->right = root;
else
*head = root;
// Update tail
*tail = root;
// Finally, convert right subtree

if (root->right)
convertBSTtoDLL(root->right, head, tail);
}
// This function returns true if there is pair in DLL with sum equal
// to given sum. The algorithm is similar to hasArrayTwoCandidates()
// in method 1 of http://tinyurl.com/dy6palr
bool isPresentInDLL(node* head, node* tail, int sum)
{
while (head != tail)
{
int curr = head->key + tail->key;
if (curr == sum)
return true;
else if (curr > sum)
tail = tail->left;
else
head = head->right;
}
return false;
}
// The main function that returns true if there is a 0 sum triplet in

// BST otherwise returns false
bool isTripletPresent(node *root)
{
// Check if the given BST is empty
if (root == NULL)
return false;
// Convert given BST to doubly linked list. head and tail store the
// pointers to first and last nodes in DLLL
node* head = NULL;
node* tail = NULL;
convertBSTtoDLL(root, &head, &tail);
// Now iterate through every node and find if there is a pair with sum
// equal to -1 * heaf->key where head is current node
while ((head->right != tail) && (head->key < 0))
{
// If there is a pair with sum equal to -1*head->key, then return
// true else move forward
if (isPresentInDLL(head->right, tail, -1*head->key))
return true;
else
head = head->right;
}
// If we reach here, then there was no 0 sum triplet

return false;
}
// A utility function to create a new BST node with key as given num
node* newNode(int num)
{
node* temp = new node;
temp->key = num;
return temp;
}
// A utility function to insert a given key to BST

node* insert(node* root, int key)
{
if (root == NULL)
return newNode(key);
if (root->key > key)
root->left = insert(root->left, key);
else
root->right = insert(root->right, key);
return root;
}

int main()
{
node* root = NULL;
if (isTripletPresent(root))
printf("Present");
else
printf("Not Present");
return 0;
}

Output:

Present

Note that the above solution modifies given BST.
Time Complexity: Time taken to convert BST to DLL is O(n) and time taken to find triplet in DLL is O(n^2).
Auxiliary Space: The auxiliary space is needed only for function call stack in recursive function
convertBSTtoDLL(). Since given tree is balanced (height is O(Logn)), the number of functions in call stack
will never be more than O(Logn).
We can also find triplet in same time and extra space without modifying the tree. See next post. The code
discussed there can be used to find triplet also.
This article is compiled by Ashish Anand and reviewed by GeeksforGeeks team. Please write comments if
Find a pair with given sum in a Balanced BST
Given a Balanced Binary Search Tree and a target sum, write a function that returns true if there is a pair
with sum equals to target sum, otherwise return false. Expected time complexity is O(n) and only O(Logn)
extra space can be used. Any modification to Binary Search Tree is not allowed. Note that height of a
Balanced BST is always O(Logn).
This problem is mainly extension of the previous post. Here we are not allowed to modify the BST.
The Brute Force Solution is to consider each pair in BST and check whether the sum equals to X. The
time complexity of this solution will be O(n^2).
A Better Solution is to create an auxiliary array and store Inorder traversal of BST in the array. The array
will be sorted as Inorder traversal of BST always produces sorted data. Once we have the Inorder traversal,
we can pair in O(n) time (See this for details). This solution works in O(n) time, but requires O(n) auxiliary
space.
A space optimized solution is discussed in previous post. The idea was to first in-place convert BST to
Doubly Linked List (DLL), then find pair in sorted DLL in O(n) time. This solution takes O(n) time and
O(Logn) extra space, but it modifies the given BST.
The solution discussed below takes O(n) time, O(Logn) space and doesn’t modify BST . The idea
is same as finding the pair in sorted array (See method 1 of this for details). We traverse BST in Normal
Inorder and Reverse Inorder simultaneously. In reverse inorder, we start from the rightmost node which is
the maximum value node. In normal inorder, we start from the left most node which is minimum value
node. We add sum of current nodes in both traversals and compare this sum with given target sum. If the
sum is same as target sum, we return true. If the sum is more than target sum, we move to next node in
reverse inorder traversal, otherwise we move to next node in normal inorder traversal. If any of the
traversals is finished without finding a pair, we return false. Following is C++ implementation of this
approach.
/* In a balanced binary search tree isPairPresent two element which sums to

a given value time O(n) space O(logn) */
#include <stdio.h>
#include <stdlib.h>
// A BST node
struct node
{
int val;
};
// Stack type
struct Stack
{
int size;
int top;
struct node* *array;
};

{
stack->size = size;
stack->top = -1;
stack->array =
(struct node**) malloc(stack->size * sizeof(struct node*));
return stack;
}


void push(struct Stack* stack, struct node* node)

{
if (isFull(stack))
return;
}
struct node* pop(struct Stack* stack)

{
if (isEmpty(stack))
return NULL;
}
// Returns true if a pair with target sum exists in BST, otherwise false
bool isPairPresent(struct node *root, int target)
{
// Create two stacks. s1 is used for normal inorder traversal
// and s2 is used for reverse inorder traversal
// Note the sizes of stacks is MAX_SIZE, we can find the tree size and
// fix stack size as O(Logn) for balanced trees like AVL and Red Black
// tree. We have used MAX_SIZE to keep the code simple
// done1, val1 and curr1 are used for normal inorder traversal using s1
// done2, val2 and curr2 are used for reverse inorder traversal using s2
bool done1 = false, done2 = false;
int val1 = 0, val2 = 0;
struct node *curr1 = root, *curr2 = root;
// The loop will break when we either find a pair or one of the two
// traversals is complete
while (1)
{
// Find next node in normal Inorder traversal. See following post
// http://www.geeksforgeeks.org/inorder-tree-traversal-without-recursion/
while (done1 == false)
{
if (curr1 != NULL)
{
push(s1, curr1);
curr1 = curr1->left;
}
else
{
if (isEmpty(s1))
done1 = 1;
else
{
curr1 = pop(s1);
val1 = curr1->val;
curr1 = curr1->right;
done1 = 1;
}
}
}
// Find next node in REVERSE Inorder traversal. The only

// difference between above and below loop is, in below loop
// right subtree is traversed before left subtree
while (done2 == false)
{
if (curr2 != NULL)
{
push(s2, curr2);
curr2 = curr2->right;
}
else
{
if (isEmpty(s2))
done2 = 1;
else
{
curr2 = pop(s2);
val2 = curr2->val;
curr2 = curr2->left;
done2 = 1;
}
}
}
// If we find a pair, then print the pair and return. The first
// condition makes sure that two same values are not added
if ((val1 != val2) && (val1 + val2) == target)
{
printf("\n Pair Found: %d + %d = %d\n", val1, val2, target);
return true;
}
// If sum of current values is smaller, then move to next node in

// normal inorder traversal
else if ((val1 + val2) < target)
done1 = false;
// If sum of current values is greater, then move to next node in

// reverse inorder traversal
else if ((val1 + val2) > target)
done2 = false;
// If any of the inorder traversals is over, then there is no pair

// If any of the inorder traversals is over, then there is no pair
// so return false
if (val1 >= val2)
return false;
}
}
// A utility function to create BST node

struct node * NewNode(int val)
{
struct node *tmp = (struct node *)malloc(sizeof(struct node));
tmp->val = val;
tmp->right = tmp->left =NULL;
return tmp;
}

int main()
{
/*
15
/ \
10 20
/ \ / \
8 12 16 25 */
struct node *root = NewNode(15);
root->left = NewNode(10);
root->right = NewNode(20);
root->left->left = NewNode(8);
root->left->right = NewNode(12);
root->right->left = NewNode(16);
root->right->right = NewNode(25);
int target = 33;

if (isPairPresent(root, target) == false)
printf("\n No such values are found\n");
getchar();
return 0;
}

Output:

Pair Found: 8 + 25 = 33

This article is compiled by Kumar and reviewed by GeeksforGeeks team. Please write comments if you find
Reverse Level Order Traversal
We have discussed level order traversal of a post in previous post. The idea is to print last level first, then
second last level, and so on. Like Level order traversal, every level is printed from left to right.
Example Tree
Reverse Level order traversal of the above tree is “4 5 2 3 1″.
Both methods for normal level order traversal can be easily modified to do reverse level order traversal.
METHOD 1 (Recursive function to print a given level)

We can easily modify the method 1 of the normal level order traversal. In method 1, we have a method
printGivenLevel() which prints a given level number. The only thing we need to change is, instead of calling
printGivenLevel() from first level to last level, we call it from last level to first level.
// A recursive C program to print REVERSE level order traversal

#include <stdio.h>
#include <stdlib.h>
/* A binary tree node has data, pointer to left and right child */
struct node
{
int data;
struct node* left;
struct node* right;
};
void printGivenLevel(struct node* root, int level);
/* Function to print REVERSE level order traversal a tree*/

void reverseLevelOrder(struct node* root)
{
int i;
for (i=h; i>=1; i--) //THE ONLY LINE DIFFERENT FROM NORMAL LEVEL ORDER
printGivenLevel(root, i);
}

void printGivenLevel(struct node* root, int level)
{
if (root == NULL)
return;
if (level == 1)
else if (level > 1)
{
{
printGivenLevel(root->left, level-1);
printGivenLevel(root->right, level-1);
}
}

{
if (node==NULL)
return 0;
else
{

return(lheight+1);
}
}

{
node->data = data;
node->left = NULL;
node->right = NULL;
return(node);
}

int main()
{

reverseLevelOrder(root);
return 0;
}

Output:

Level Order traversal of binary tree is
4 5 2 3 1

Time Complexity: The worst case time complexity of this method is O(n^2). For a skewed tree,
printGivenLevel() takes O(n) time where n is the number of nodes in the skewed tree. So time complexity of
printLevelOrder() is O(n) + O(n-1) + O(n-2) + .. + O(1) which is O(n^2).
METHOD 2 (Using Queue and Stack)

The method 2 of normal level order traversal can also be easily modified to print level order traversal in
reverse order. The idea is to use a stack to get the reverse level order. If we do normal level order traversal
and instead of printing a node, push the node to a stack and then print contents of stack, we get “5 4 3 2 1″
for above example tree, but output should be “4 5 2 3 1″. So to get the correct sequence (left to right at every
level), we process children of a node in reverse order, we first push the right subtree to stack, then left
subtree.
// A C++ program to print REVERSE level order traversal using stack and queue
// This approach is adopted from following link
// http://tech-queries.blogspot.in/2008/12/level-order-tree-traversal-in-reverse.html
#include <iostream>
#include <stack>
#include <queue>
/* A binary tree node has data, pointer to left and right children */
struct node
{
int data;
struct node* left;
struct node* right;
};
/* Given a binary tree, print its nodes in reverse level order */

void reverseLevelOrder(node* root)
{
stack <node *> S;
queue <node *> Q;
Q.push(root);
// Do something like normal level order traversal order. Following are the
// differences with normal level order traversal
// 1) Instead of printing a node, we push the node to stack
// 2) Right subtree is visited before left subtree
while (Q.empty() == false)
{
/* Dequeue node and make it root */
root = Q.front();
Q.pop();
S.push(root);
/* Enqueue right child */

if (root->right)
Q.push(root->right); // NOTE: RIGHT CHILD IS ENQUEUED BEFORE LEFT
/* Enqueue left child */

if (root->left)
Q.push(root->left);
}
// Now pop all items from stack one by one and print them
while (S.empty() == false)
{
root = S.top();
S.pop();
}
}

node* newNode(int data)
{
temp->data = data;
temp->left = NULL;
temp->right = NULL;
return (temp);
}

int main()
{
cout << "Level Order traversal of binary tree is \n";

reverseLevelOrder(root);
return 0;
}

Output:

Level Order traversal of binary tree is
4 5 6 7 2 3 1

Time Complexity: O(n) where n is number of nodes in the binary tree.
same problem.
Tug of War
Given a set of n integers, divide the set in two subsets of n/2 sizes each such that the difference of the sum of
two subsets is as minimum as possible. If n is even, then sizes of two subsets must be strictly n/2 and if n is
odd, then size of one subset must be (n-1)/2 and size of other subset must be (n+1)/2.
For example, let given set be {3, 4, 5, -3, 100, 1, 89, 54, 23, 20}, the size of set is 10. Output for this set should
be {4, 100, 1, 23, 20} and {3, 5, -3, 89, 54}. Both output subsets are of size 5 and sum of elements in both
subsets is same (148 and 148).
Let us consider another example where n is odd. Let given set be {23, 45, -34, 12, 0, 98, -99, 4, 189, -1, 4}.
The output subsets should be {45, -34, 12, 98, -1} and {23, 0, -99, 4, 189, 4}. The sums of elements in two
subsets are 120 and 121 respectively.
The following solution tries every possible subset of half size. If one subset of half size is formed, the
remaining elements form the other subset. We initialize current set as empty and one by one build it. There
are two possibilities for every element, either it is part of current set, or it is part of the remaining elements
(other subset). We consider both possibilities for every element. When the size of current set becomes n/2,
we check whether this solutions is better than the best solution available so far. If it is, then we update the
best solution.
Following is C++ implementation for Tug of War problem. It prints the required arrays.
#include <iostream>
#include <stdlib.h>
#include <limits.h>
// function that tries every possible solution by calling itself recursively

void TOWUtil(int* arr, int n, bool* curr_elements, int no_of_selected_elements,
bool* soln, int* min_diff, int sum, int curr_sum, int curr_position)
{
// checks whether the it is going out of bound
if (curr_position == n)
return;
// checks that the numbers of elements left are not less than the
// number of elements required to form the solution
if ((n/2 - no_of_selected_elements) > (n - curr_position))
return;
// consider the cases when current element is not included in the solution
TOWUtil(arr, n, curr_elements, no_of_selected_elements,
soln, min_diff, sum, curr_sum, curr_position+1);
// add the current element to the solution

no_of_selected_elements++;
curr_sum = curr_sum + arr[curr_position];
curr_elements[curr_position] = true;
// checks if a solution is formed

if (no_of_selected_elements == n/2)
{
// checks if the solution formed is better than the best solution so far
if (abs(sum/2 - curr_sum) < *min_diff)
{
*min_diff = abs(sum/2 - curr_sum);
soln[i] = curr_elements[i];
}
}
}
else
{
// consider the cases where current element is included in the solution
TOWUtil(arr, n, curr_elements, no_of_selected_elements, soln,
min_diff, sum, curr_sum, curr_position+1);
}
// removes current element before returning to the caller of this function

curr_elements[curr_position] = false;
}
// main function that generate an arr

void tugOfWar(int *arr, int n)
{
// the boolen array that contains the inclusion and exclusion of an element
// in current set. The number excluded automatically form the other set
bool* curr_elements = new bool[n];
// The inclusion/exclusion array for final solution

bool* soln = new bool[n];
int min_diff = INT_MAX;
int sum = 0;
for (int i=0; i<n; i++)
{
sum += arr[i];
curr_elements[i] = soln[i] = false;
}
// Find the solution using recursive function TOWUtil()

TOWUtil(arr, n, curr_elements, 0, soln, &min_diff, sum, 0, 0);

cout << "The first subset is: ";
{
if (soln[i] == true)
cout << arr[i] << " ";
}
cout << "\nThe second subset is: ";
{
if (soln[i] == false)
cout << arr[i] << " ";
}
}

int main()
{
int arr[] = {23, 45, -34, 12, 0, 98, -99, 4, 189, -1, 4};
tugOfWar(arr, n);
return 0;
}

Output:

The first subset is: 45 -34 12 98 -1
The second subset is: 23 0 -99 4 189 4

Interview Experiences at D. E. Shaw & Co.
I had three rounds:
My first round was telephonic interview and it lasted for about an hour and the questions covered entire
breadth of core CS subjects, there were questions on Operating Systems, questions on some SQL queries,
Computer Networks, Computer Organisation, Digital Design, some algorithms and there were some
questions based on the projects i did (that was specified in Resume) i was asked questions on Android since i
did a project on Android,and at last they asked me a puzzle on probability.
In The second round (which was face to face interview), the emphasis was mostly on designing algorithms
for some new problems, and they expected me to give optimal solutions, and they asked me to design web
server and what are the various challenges you will be facing.
The third round was the most critical one and the questions were mostly on C++ concepts and some
operating system design issues (e.g., spin locks, semaphores, etc.,) and there were even questions on storage
classes and how do you think they might be implemented, there were some questions on algorithms which
were simple but there were many in-depth analysis on those questions (e.g., In finding the loop in the
linked-list what happens when the fast pointer takes 3 steps instead of 2 does this algorithm does this
algorithm converges,what is the condition under which the algorithm converges), they asked me to code
some design patterns, and i was asked some puzzles to solve
I got placed in some of the dream companies, and in this journey i should say, http://geeksforgeeks.org/ has
a major role, i am following this site since my first day of graduation and i should say this one will give
complete picture of what are the various questions you might be asked in various companies,along with
great emphasis on core CS concepts.Thanks geeksforgeeks, i will say this is the one stop that will help you to
land into some of the prestigious firms
Geeks.
Print Matrix Diagonally
Given a 2D matrix, print all elements of the given matrix in diagonal order. For example, consider the
following 5 X 4 input matrix.
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 16
17 18 19 20

Diagonal printing of the above matrix is
1
5 2
9 6 3
13 10 7 4
17 14 11 8
18 15 12
19 16
20

Following is C++ code for diagonal printing.
The diagonal printing of a given matrix ‘matrix[ROW][COL]’ always has ‘ROW + COL – 1′ lines in output
#include <stdio.h>
#include <stdlib.h>
#define ROW 5
#define COL 4
// A utility function to find min of two integers

{ return (a < b)? a: b; }
// A utility function to find min of three integers

int min(int a, int b, int c)
{ return min(min(a, b), c);}

{ return (a > b)? a: b; }
// The main function that prints given matrix in diagonal order

void diagonalOrder(int matrix[][COL])
{
// There will be ROW+COL-1 lines in the output
for (int line=1; line<=(ROW + COL -1); line++)
{
/* Get column index of the first element in this line of output.
The index is 0 for first ROW lines and line - ROW for remaining
lines */
lines */
int start_col = max(0, line-ROW);
/* Get count of elements in this line. The count of elements is

equal to minimum of line number, COL-start_col and ROW */
int count = min(line, (COL-start_col), ROW);
/* Print elements of this line */

for (int j=0; j<count; j++)
printf("%5d ", matrix[min(ROW, line)-j-1][start_col+j]);
/* Ptint elements of next diagonal on next line */

printf("\n");
}
}
// Utility function to print a matrix

void printMatrix(int matrix[ROW][COL])
{
for (int i=0; i< ROW; i++)
{
for (int j=0; j<COL; j++)
printf("%5d ", matrix[i][j]);
printf("\n");
}
}

int main()
{
int M[ROW][COL] = {{1, 2, 3, 4},
{5, 6, 7, 8},
{9, 10, 11, 12},
{13, 14, 15, 16},
{17, 18, 19, 20},
};
printf ("Given matrix is \n");
printMatrix(M);
printf ("\nDiagonal printing of matrix is \n");

diagonalOrder(M);
return 0;
}

Output:

Given matrix is
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 16
17 18 19 20
Diagonal printing of matrix is

1
5 2
9 6 3
13 10 7 4
17 14 11 8
18 15 12
19 16
20

Below is an Alternate Method to solve the above problem.
Matrix => 1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 16
17 18 19 20

Observe the sequence
1 / 2 / 3 / 4
/ 5 / 6 / 7 / 8
/ 9 / 10 / 11 / 12
/ 13 / 14 / 15 / 16
/ 17 / 18 / 19 / 20

#define R 5
#define C 4
bool isvalid(int i, int j)

{
if (i < 0 || i >= R || j >= C || j < 0) return false;
return true;
}
void diagonalOrder(int arr[][C])

{
/* through this for loop we choose each element of first column
as starting point and print diagonal starting at it.
arr[0][0], arr[1][0]....arr[R-1][0] are all starting points */
for (int k = 0; k < R; k++)
{
cout << arr[k][0] << " ";
int i = k-1; // set row index for next point in diagonal
int i = k-1; // set row index for next point in diagonal
int j = 1; // set column index for next point in diagonal
/* Print Diagonally upward */

while (isvalid(i,j))
{
cout << arr[i][j] << " ";
i--;
j++; // move in upright direction
}
cout << endl;
}
/* through this for loop we choose each element of last row

as starting point (except the [0][c-1] it has already been
processed in previous for loop) and print diagonal starting at it.
arr[R-1][0], arr[R-1][1]....arr[R-1][c-1] are all starting points */
//Note : we start from k = 1 to C-1;

for (int k = 1; k < C; k++)
{
cout << arr[R-1][k] << " ";
int i = R-2; // set row index for next point in diagonal
int j = k+1; // set column index for next point in diagonal
/* Print Diagonally upward */

while (isvalid(i,j))
{
cout << arr[i][j] << " ";
i--;
j++; // move in upright direction
}
cout << endl;
}
}
// Driver program to test above

int main()
{
int arr[][C] = {{1, 2, 3, 4},

{5, 6, 7, 8},
{9, 10, 11, 12},
{13, 14, 15, 16},
{17, 18, 19, 20},
};
diagonalOrder(arr);
return 0;
}

Output:

1
5 2
9 6 3
13 10 7 4
17 14 11 8
18 15 12
19 16
20

Thanks to Gaurav Ahirwar for suggesting this method.
Divide and Conquer | Set 3 (Maximum Subarray Sum)
You are given a one dimensional array that may contain both positive and negative integers, find the sum of
contiguous subarray of numbers which has the largest sum.
For example, if the given array is {-2, -5, 6, -2, -3, 1, 5, -6}, then the maximum subarray sum is 7 (see
highlighted elements).
The naive method is to run two loops. The outer loop picks the beginning element, the inner loop finds the
maximum possible sum with first element picked by outer loop and compares this maximum with the overall
maximum. Finally return the overall maximum. The time complexity of the Naive method is O(n^2).
Using Divide and Conquer approach, we can find the maximum subarray sum in O(nLogn) time.
Following is the Divide and Conquer algorithm.
1) Divide the given array in two halves

2) Return the maximum of following three
….a) Maximum subarray sum in left half (Make a recursive call)
….b) Maximum subarray sum in right half (Make a recursive call)
….c) Maximum subarray sum such that the subarray crosses the midpoint
The lines 2.a and 2.b are simple recursive calls. How to find maximum subarray sum such that the subarray
crosses the midpoint? We can easily find the crossing sum in linear time. The idea is simple, find the
maximum sum starting from mid point and ending at some point on left of mid, then find the maximum
sum starting from mid + 1 and ending with sum point on right of mid + 1. Finally, combine the two and
return.
// A Divide and Conquer based program for maximum subarray sum problem
#include <stdio.h>
#include <limits.h>
// A utility funtion to find maximum of two integers

// A utility funtion to find maximum of three integers

int max(int a, int b, int c) { return max(max(a, b), c); }
// Find the maximum possible sum in arr[] auch that arr[m] is part of it
int maxCrossingSum(int arr[], int l, int m, int h)
{
// Include elements on left of mid.
int sum = 0;
int left_sum = INT_MIN;
for (int i = m; i >= l; i--)
{
sum = sum + arr[i];
if (sum > left_sum)
left_sum = sum;
}
// Include elements on right of mid

sum = 0;
int right_sum = INT_MIN;
for (int i = m+1; i <= h; i++)
{
sum = sum + arr[i];
if (sum > right_sum)
right_sum = sum;
}
}
// Return sum of elements on left and right of mid

return left_sum + right_sum;
}
// Returns sum of maxium sum subarray in aa[l..h]

int maxSubArraySum(int arr[], int l, int h)
{
// Base Case: Only one element
if (l == h)
return arr[l];
// Find middle point

int m = (l + h)/2;
/* Return maximum of following three possible cases

a) Maximum subarray sum in left half
b) Maximum subarray sum in right half
c) Maximum subarray sum such that the subarray crosses the midpoint */
return max(maxSubArraySum(arr, l, m),
maxSubArraySum(arr, m+1, h),
maxCrossingSum(arr, l, m, h));
}
/*Driver program to test maxSubArraySum*/

int main()
{
int arr[] = {2, 3, 4, 5, 7};
int max_sum = maxSubArraySum(arr, 0, n-1);
getchar();
return 0;
}

Time Complexity: maxSubArraySum() is a recursive method and time complexity can be expressed as
following recurrence relation.
T(n) = 2T(n/2) + Θ(n)
The above recurrence is similar to Merge Sort and can be solved either using Recurrence Tree method or
Master method. It falls in case II of Master Method and solution of the recurrence is Θ(nLogn).
The Kadane’s Algorithm for this problem takes O(n) time. Therefore the Kadane’s algorithm is better
than the Divide and Conquer approach, but this problem can be considered as a good example to show
power of Divide and Conquer. The above simple approach where we divide the array in two halves, reduces
the time complexity from O(n^2) to O(nLogn).
References:
discussed above.
Skip List | Set 1 (Introduction)
Can we search in a sorted linked list in better than O(n) time?
The worst case search time for a sorted linked list is O(n) as we can only linearly traverse the list and cannot
skip nodes while searching. For a Balanced Binary Search Tree, we skip almost half of the nodes after one
comparison with root. For a sorted array, we have random access and we can apply Binary Search on arrays.
Can we augment sorted linked lists to make the search faster? The answer is Skip List. The idea is simple, we
create multiple layers so that we can skip some nodes. See the following example list with 16 nodes and two
layers. The upper layer works as an “express lane” which connects only main outer stations, and the lower
layer works as a “normal lane” which connects every station. Suppose we want to search for 50, we start from
first node of “express lane” and keep moving on “express lane” till we find a node whose next is greater than
50. Once we find such a node (30 is the node in following example) on “express lane”, we move to “normal
lane” using pointer from this node, and linearly search for 50 on “normal lane”. In following example, we
start from 30 on “normal lane” and with linear search, we find 50.
What is the time complexity with two layers? The worst case time complexity is number of nodes on
“express lane” plus number of nodes in a segment (A segment is number of “normal lane” nodes between two
“express lane” nodes) of “normal lane”. So if we have n nodes on “normal lane”, √n (square root of n) nodes
on “express lane” and we equally divide the “normal lane”, then there will be √n nodes in every segment of
“normal lane” . √n is actually optimal division with two layers. With this arrangement, the number of nodes
traversed for a search will be O(√n). Therefore, with O(√n) extra space, we are able to reduce the time
complexity to O(√n).
Can we do better?
The time complexity of skip lists can be reduced further by adding more layers. In fact, the time complexity
of search, insert and delete can become O(Logn) in average case. We will soon be publishing more posts on
Skip Lists.
References
MIT Video Lecture on Skip Lists
http://en.wikipedia.org/wiki/Skip_list
discussed above.
Counting Sort
Counting sort is a sorting technique based on keys between a specific range. It works by counting the
number of objects having distinct key values (kind of hashing). Then doing some arithmetic to calculate the
position of each object in the output sequence.
Let us understand it with the help of an example.
For simplicity, consider the data in the range 0 to 9.

Input data: 1, 4, 1, 2, 7, 5, 2
1) Take a count array to store the count of each unique object.
Index: 0 1 2 3 4 5 6 7 8 9
Count: 0 2 2 0 1 1 0 1 0 0
2) Modify the count array such that each element at each index
stores the sum of previous counts.
Index: 0 1 2 3 4 5 6 7 8 9
Count: 0 2 4 4 5 6 6 7 7 7
The modified count array indicates the position of each object in

the output sequence.

3) Output each object from the input sequence followed by
decreasing its count by 1.
Process the input data: 1, 4, 1, 2, 7, 5, 2. Position of 1 is 2.
Put data 1 at index 2 in output. Decrease count by 1 to place
next data 1 at an index 1 smaller than this index.

Following is C implementation of counting sort.

// C Program for counting sort

#include <stdio.h>
#include <string.h>
#define RANGE 255
// The main function that sort the given string str in alphabatical order
void countSort(char *str)
{
// The output character array that will have sorted str
char output[strlen(str)];
// Create a count array to store count of inidividul characters and

// initialize count array as 0
int count[RANGE + 1], i;
memset(count, 0, sizeof(count));
// Store count of each character

for(i = 0; str[i]; ++i)
++count[str[i]];
// Change count[i] so that count[i] now contains actual position of

// this character in output array
for (i = 1; i <= RANGE; ++i)
// Build the output character array

for (i = 0; str[i]; ++i)
{
output[count[str[i]]-1] = str[i];
--count[str[i]];
}
// Copy the output array to str, so that str now

// contains sorted characters
for (i = 0; str[i]; ++i)
str[i] = output[i];
}

int main()
{
char str[] = "geeksforgeeks";//"applepp";
countSort(str);
printf("Sorted string is %s\n", str);

return 0;
}

Output:

Sorted character array is eeeefggkkorss

Time Complexity: O(n+k) where n is the number of elements in input array and k is the range of input.
Auxiliary Space: O(n+k)
Points to be noted:
1. Counting sort is efficient if the range of input data is not significantly greater than the number of objects
to be sorted. Consider the situation where the input sequence is between range 1 to 10K and the data is 10, 5,
10K, 5K.
2. It is not a comparison based sorting. It running time complexity is O(n) with space proportional to the
range of data.
3. It is often used as a sub-routine to another sorting algorithm like radix sort.
4. Counting sort uses a partial hashing to count the occurrence of the data object in O(1).
5. Counting sort can be extended to work for negative inputs also.
Exercise:
1. Modify above code to sort the input data in the range from M to N.
2. Modify above code to sort negative input data.
3. Is counting sort stable and online?
4. Thoughts on parallelizing the counting sort algorithm.
Construct Complete Binary Tree from its Linked List Representation
Given Linked List Representation of Complete Binary Tree, construct the Binary tree. A complete binary tree
can be represented in an array in the following approach.
If root node is stored at index i, its left, and right children are stored at indices 2*i+1, 2*i+2 respectively.
Suppose tree is represented by a linked list in same way, how do we convert this into normal linked
representation of binary tree where every node has data, left and right pointers? In the linked list
representation, we cannot directly access the children of the current node unless we traverse the list.
We are mainly given level order traversal in sequential access form. We know head of linked list is always is
root of the tree. We take the first node as root and we also know that the next two nodes are left and right
children of root. So we know partial Binary Tree. The idea is to do Level order traversal of the partially built
Binary Tree using queue and traverse the linked list at the same time. At every step, we take the parent node
from queue, make next two nodes of linked list as children of the parent node, and enqueue the next two
nodes to queue.
1. Create an empty queue.

2. Make the first node of the list as root, and enqueue it to the queue.
3. Until we reach the end of the list, do the following.
………a. Dequeue one node from the queue. This is the current parent.
………b. Traverse two nodes in the list, add them as children of the current parent.
………c. Enqueue the two nodes into the queue.
Below is the code which implements the same in C++.
// C++ program to create a Complete Binary tree from its Linked List
// Representation
#include <iostream>
#include <string>
#include <queue>
// Linked list node

struct ListNode
{
int data;
ListNode* next;
};
// Binary tree node structure

struct BinaryTreeNode
{
int data;
int data;
BinaryTreeNode *left, *right;
};
// Function to insert a node at the beginning of the Linked List

void push(struct ListNode** head_ref, int new_data)
{
// allocate node and assign data
struct ListNode* new_node = new ListNode;
// link the old list off the new node

// move the head to point to the new node

}
// method to create a new binary tree node from the given data
BinaryTreeNode* newBinaryTreeNode(int data)
{
BinaryTreeNode *temp = new BinaryTreeNode;
temp->data = data;
return temp;
}
// converts a given linked list representing a complete binary tree into the
// linked representation of binary tree.
void convertList2Binary(ListNode *head, BinaryTreeNode* &root)
{
// queue to store the parent nodes
queue<BinaryTreeNode *> q;
// Base Case
if (head == NULL)
{
root = NULL; // Note that root is passed by reference
return;
}
// 1.) The first node is always the root node, and add it to the queue
root = newBinaryTreeNode(head->data);
q.push(root);
// advance the pointer to the next node

head = head->next;
// until the end of linked list is reached, do the following steps

while (head)
{
// 2.a) take the parent node from the q and remove it from q
BinaryTreeNode* parent = q.front();
q.pop();
// 2.c) take next two nodes from the linked list. We will add
// them as children of the current parent node in step 2.b. Push them
// into the queue so that they will be parents to the future nodes
BinaryTreeNode *leftChild = NULL, *rightChild = NULL;
leftChild = newBinaryTreeNode(head->data);
q.push(leftChild);
head = head->next;
if (head)
{
rightChild = newBinaryTreeNode(head->data);
rightChild = newBinaryTreeNode(head->data);
q.push(rightChild);
head = head->next;
}
// 2.b) assign the left and right children of parent

parent->left = leftChild;
parent->right = rightChild;
}
}
// Utility function to traverse the binary tree after conversion

void inorderTraversal(BinaryTreeNode* root)
{
if (root)
{
inorderTraversal( root->left );
inorderTraversal( root->right );
}
}

int main()
{
// create a linked list shown in above diagram
struct ListNode* head = NULL;
push(&head, 36); /* Last node of Linked List */
push(&head, 30);
push(&head, 25);
push(&head, 15);
push(&head, 12);
push(&head, 10); /* First node of Linked List */
BinaryTreeNode *root;
convertList2Binary(head, root);
cout << "Inorder Traversal of the constructed Binary Tree is: \n";
inorderTraversal(root);
return 0;
}

Output:

Inorder Traversal of the constructed Binary Tree is:
25 12 30 10 36 15

Time Complexity: Time complexity of the above solution is O(n) where n is the number of nodes.
Merge Overlapping Intervals
Given a set of time intervals in any order, merge all overlapping intervals into one and output the result
which should have only mutually exclusive intervals. Let the intervals be represented as pairs of integers for
simplicity.
For example, let the given set of intervals be {{1,3}, {2,4}, {5,7}, {6,8} }. The intervals {1,3} and {2,4} overlap
with each other, so they should be merged and become {1, 4}. Similarly {5, 7} and {6, 8} should be merged
and become {5, 8}
Write a function which produces the set of merged intervals for the given set of intervals.
A simple approach is to start from the first interval and compare it with all other intervals for
overlapping, if it overlaps with any other interval, then remove the other interval from list and merge the
other into the first interval. Repeat the same steps for remaining intervals after first. This approach cannot
be implemented in better than O(n^2) time.
An efficient approach is to first sort the intervals according to starting time. Once we have the sorted
intervals, we can combine all intervals in a linear traversal. The idea is, in sorted array of intervals, if
interval[i] doesn’t overlap with interval[i-1], then interval[i+1] cannot overlap with interval[i-1] because
starting time of interval[i+1] must be greater than or equal to interval[i]. Following is the detailed step by
step algorithm.
1. Sort the intervals based on increasing order of starting time.

2. Push the first interval on to a stack.
3. For each interval do the following
……..a. If the current interval does not overlap with the stack top, push it.
……..b. If the current interval overlaps with stack top and ending time of current interval is more than that of
stack top, update stack top with the ending time of current interval.
4. At the end stack contains the merged intervals.
Below is a C++ implementation of the above approach.
// A C++ program for merging overlapping intervals

#include <iostream>
#include <vector>
#include <stack>
// An interval has start time and end time

struct Interval
{
int start;
int end;
};
// Compares two intervals according to their staring time.

// This is needed for sorting the intervals using library
// function std::sort(). See http://goo.gl/iGspV
bool compareInterval(Interval i1, Interval i2)
{ return (i1.start < i2.start)? true: false; }
// The main function that takes a set of intervals, merges

// overlapping intervals and prints the result
void mergeIntervals(vector<Interval>& intervals)
{
// Test if the given set has at least one interval
if (intervals.size() <= 0)
if (intervals.size() <= 0)
return;
// Create an empty stack of intervals

stack<Interval> s;
// sort the intervals based on start time

sort(intervals.begin(), intervals.end(), compareInterval);
// push the first interval to stack

s.push(intervals[0]);
// Start from the next interval and merge if necessary

for (int i = 1 ; i < intervals.size(); i++)
{
// get interval from stack top
Interval top = s.top();
// if current interval is not overlapping with stack top,

// push it to the stack
if (top.end < intervals[i].start)
{
s.push( intervals[i] );
}
// Otherwise update the ending time of top if ending of current
// interval is more
else if (top.end < intervals[i].end)
{
top.end = intervals[i].end;
s.pop();
s.push(top);
}
}
// Print contents of stack

cout << "\n The Merged Intervals are: ";
while (!s.empty())
{
Interval t = s.top();
cout << "[" << t.start << "," << t.end << "]" << " ";
s.pop();
}
return;
}
// Functions to run test cases

void TestCase1()
{
// Create a set of intervals
Interval intvls[] = { {6,8}, {1,9}, {2,4}, {4,7} };
vector<Interval> intervals(intvls, intvls+4);
// Merge overlapping inervals and print result

mergeIntervals(intervals);
}
void TestCase2()
{
Interval intvls[] = { {6,8},{1,3},{2,4},{4,7} };

}
void TestCase3()
{
Interval intvls[] = { {1,3},{7,9},{4,6},{10,13} };

}

int main()
{
TestCase1();
TestCase2();
TestCase3();
return 0;
}

Output:
The Merged Intervals are: [1,9]

The Merged Intervals are: [1,8]
The Merged Intervals are: [10,13] [7,9] [4,6] [1,3]

Time complexity of the method is O(nLogn) which is for sorting. Once the array of intervals is sorted,
merging takes linear time.
This article is compiled by Ravi Chandra Enaganti. Please write comments if you find anything incorrect, or
Find the maximum repeating number in O(n) time and O(1) extra space
Given an array of size n, the array contains numbers in range from 0 to k-1 where k is a positive integer and k
Find the maximum repeating number in this array. For example, let k be 10 the given array be arr[] = {1,
2, 2, 2, 0, 2, 0, 2, 3, 8, 0, 9, 2, 3}, the maximum repeating number would be 2. Expected time complexity is
O(n) and extra space allowed is O(1). Modifications to array are allowed.
The naive approach is to run two loops, the outer loop picks an element one by one, the inner loop counts
number of occurrences of the picked element. Finally return the element with maximum count. Time
complexity of this approach is O(n^2).
A better approach is to create a count array of size k and initialize all elements of
count[] as 0. Iterate
through all elements of input array, and for every element arr[i], increment count[arr[i]]. Finally, iterate
through count[] and return the index with maximum value. This approach takes O(n) time, but requires
O(k) space.
Following is the O(n) time and O(1) extra space approach. Let us understand the approach with a
simple example where arr[] = {2, 3, 3, 5, 3, 4, 1, 7}, k = 8, n = 8 (number of elements in arr[]).
1) Iterate though input array arr[], for every element arr[i], increment arr[arr[i]%k] by k (arr[] becomes {2,
11, 11, 29, 11, 12, 1, 15 })
2) Find the maximum value in the modified array (maximum value is 29). Index of the maximum value is
the maximum repeating element (index of 29 is 3).
3) If we want to get the original array back, we can iterate through the array one more time and do
arr[i] =
arr[i] % k where i varies from 0 to n-1.
How does the above algorithm work? Since we use arr[i]%k as index and add value k at the index arr[i]%k,
the index which is equal to maximum repeating element will have the maximum value in the end. Note that
k is added maximum number of times at the index equal to maximum repeating element and all array
elements are smaller than k.

#include<iostream>
// Returns maximum repeating element in arr[0..n-1].

// The array elements are in range from 0 to k-1
int maxRepeating(int* arr, int n, int k)
{
// Iterate though input array, for every element
// arr[i], increment arr[arr[i]%k] by k
for (int i = 0; i< n; i++)
arr[arr[i]%k] += k;
// Find index of the maximum repeating element

int max = arr[0], result = 0;
for (int i = 1; i < n; i++)
{
if (arr[i] > max)
{
max = arr[i];
result = i;
}
}
/* Uncomment this code to get the original array back

for (int i = 0; i< n; i++)
arr[i] = arr[i]%k; */
// Return index of the maximum element

return result;
}

int main()
{
int arr[] = {2, 3, 3, 5, 3, 4, 1, 7};
int k = 8;
cout << "The maximum repeating number is " <<

maxRepeating(arr, n, k) << endl;
return 0;
}

Output:

The maximum repeating number is 3

Exercise:
The above solution prints only one repeating element and doesn’t work if we want to print all maximum
repeating elements. For example, if the input array is {2, 3, 2, 3}, the above solution will print only 3. What
if we need to print both of 2 and 3 as both of them occur maximum number of times. Write a O(n) time and
O(1) extra space function that prints all maximum repeating elements. (Hint: We can use maximum
quotient arr[i]/n instead of maximum value in step 2).
Note that the above solutions may cause overflow if adding k repeatedly makes the value more than
INT_MAX.
Intersection of n sets
Given n sets of integers of different sizes. Each set may contain duplicates also. How to find the intersection
of all the sets. If an element is present multiple times in all the sets, it should be added that many times in
the result.
For example, consider there are three sets {1,2,2,3,4} {2,2,3,5,6} {1,3,2,2,6}. The intersection of the given
sets should be {2,2,3}
The following is an efficient approach to solve this problem.
1. Sort all the sets.

2. Take the smallest set, and insert all the elements, and their frequencies into a map.
3. For each element in the map do the following
…..a. If the element is not present in any set, ignore it
…..b. Find the frequency of the element in each set (using binary search). If it less than the frequency in the
map, update the frequency
…..c. If the element is found in all the sets, add it to the result.
Here is the C++ implementation of the above approach.
// C++ program to find intersection of n sets

#include <iostream>
#include <vector>
#include <map>
// The main function that receives a set of sets as parameter and

// returns a set containing intersection of all sets
vector <int> getIntersection(vector < vector <int> > &sets)
{
vector <int> result; // To store the reaultant set
int smallSetInd = 0; // Initialize index of smallest set
int minSize = sets[0].size(); // Initialize size of smallest set
// sort all the sets, and also find the smallest set
for (int i = 1 ; i < sets.size() ; i++)
{
// sort this set
sort(sets[i].begin(), sets[i].end());
// update minSize, if needed

if (minSize > sets[i].size())
{
minSize = sets[i].size();
smallSetInd = i;
}
}
map<int,int> elementsMap;
// Add all the elements of smallest set to a map, if already present,

// update the frequency
for (int i = 0; i < sets[smallSetInd].size(); i++)
{
if (elementsMap.find( sets[smallSetInd][i] ) == elementsMap.end())
elementsMap[ sets[smallSetInd][i] ] = 1;
else
elementsMap[ sets[smallSetInd][i] ]++;
elementsMap[ sets[smallSetInd][i] ]++;
}
// iterate through the map elements to see if they are present in

// remaining sets
map<int,int>::iterator it;
for (it = elementsMap.begin(); it != elementsMap.end(); ++it)
{
int elem = it->first;
int freq = it->second;
bool bFound = true;
// Iterate through all sets

for (int j = 0 ; j < sets.size() ; j++)
{
// If this set is not the smallest set, then do binary search in it
if (j != smallSetInd)
{
// If the element is found in this set, then find its frequency
if (binary_search( sets[j].begin(), sets[j].end(), elem ))
{
int lInd = lower_bound(sets[j].begin(), sets[j].end(), elem)
- sets[j].begin();
int rInd = upper_bound(sets[j].begin(), sets[j].end(), elem)
- sets[j].begin();
// Update the minimum frequency, if needed

if ((rInd - lInd) < freq)
freq = rInd - lInd;
}
// If the element is not present in any set, then no need
// to proceed for this element.
else
{
bFound = false;
break;
}
}
}
// If element was found in all sets, then add it to result 'freq' times
if (bFound)
{
for (int k = 0; k < freq; k++)
result.push_back(elem);
}
}
return result;
}
// A utility function to print a set of elements

void printset(vector <int> set)
{
for (int i = 0 ; i < set.size() ; i++)
cout<<set[i]<<" ";
}
// Test case
void TestCase1()
{
vector < vector <int> > sets;
vector <int> set1;
set1.push_back(1);
set1.push_back(1);
set1.push_back(1);
set1.push_back(2);
set1.push_back(2);
set1.push_back(5);
sets.push_back(set1);
vector <int> set2;

set2.push_back(1);
set2.push_back(1);
set2.push_back(4);
set2.push_back(3);
set2.push_back(5);
set2.push_back(9);
vector <int> set3;

set3.push_back(1);
set3.push_back(1);
set3.push_back(2);
set3.push_back(3);
set3.push_back(5);
set3.push_back(6);
vector <int> r = getIntersection(sets);
printset(r);

int main()
{
TestCase1();
return 0;
}

Output:

1 1 5

Time Complexity: Let there be ‘n’ lists, and average size of lists be ‘m’. Sorting phase takes O( n* m *log
m) time (Sorting n lists with average length m). Searching phase takes O( m * n * log m) time . ( for each
element in a list, we are searching n lists with log m time). So the overall time complexity is O( n*m*log m ).
Auxiliary Space: O(m) space for storing the map.
Remove BST keys outside the given range
Given a Binary Search Tree (BST) and a range [min, max], remove all keys which are outside the given range.
The modified tree should also be BST. For example, consider the following BST and range [-10, 13].
The given tree should be changed to following. Note that all keys outside the range [-10, 13] are removed and
modified tree is BST.
There are two possible cases for every node.

1) Node’s key is outside the given range. This case has two sub-cases.
…….a) Node’s key is smaller than the min value.
…….b) Node’s key is greater that the max value.
2) Node’s key is in range.
We don’t need to do anything for case 2. In case 1, we need to remove the node and change root of sub-tree
rooted with this node.
The idea is to fix the tree in Postorder fashion. When we visit a node, we make sure that its left and right sub-
trees are already fixed. In case 1.a), we simply remove root and return right sub-tree as new root. In case
1.b), we remove root and return left sub-tree as new root.
Following is C++ implementation of the above approach.
// A C++ program to remove BST keys outside the given range

#include<stdio.h>
#include <iostream>
// A BST node has key, and left and right pointers

struct node
{
int key;
struct node *left;
struct node *right;
};
// Resmoves all nodes having value outside the given range and returns the root
// of modified tree
node* removeOutsideRange(node *root, int min, int max)
{
// Base Case
if (root == NULL)
return NULL;
// First fix the left and right subtrees of root

root->left = removeOutsideRange(root->left, min, max);
root->right = removeOutsideRange(root->right, min, max);
// Now fix the root. There are 2 possible cases for toot
// 1.a) Root's key is smaller than min value (root is not in range)
if (root->key < min)
{
node *rChild = root->right;
delete root;
return rChild;
}
// 1.b) Root's key is greater than max value (root is not in range)
if (root->key > max)
{
node *lChild = root->left;
delete root;
return lChild;
}
// 2. Root is in range
return root;
}
// A utility function to create a new BST node with key as given num
node* newNode(int num)
{
temp->key = num;
return temp;
}
// A utility function to insert a given key to BST

node* insert(node* root, int key)
{
if (root == NULL)
else
return root;
}
// Utility function to traverse the binary tree after conversion

void inorderTraversal(node* root)
{
if (root)
{
inorderTraversal( root->left );
cout << root->key << " ";
inorderTraversal( root->right );
}
}

int main()
{
node* root = NULL;
cout << "Inorder traversal of the given tree is: ";

root = removeOutsideRange(root, -10, 13);
cout << "\nInorder traversal of the modified tree is: ";

return 0;
}

Output:

Inorder traversal of the given tree is: -13 -8 6 7 13 14 15
Inorder traversal of the modified tree is: -8 6 7 13

Time Complexity: O(n) where n is the number of nodes in given BST.
discussed above.
Find position of the only set bit
Given a number having only one ‘1’ and all other ’0’s in its binary representation, find position of the only set
bit. Source: Microsoft Interview | 18
The idea is to start from rightmost bit and one by one check value of every bit. Following is detailed
algorithm.
1) If number is power of two then and then only its binary representation contains only one ‘1’. That’s why
check whether given number is power of 2 or not. If given number is not power of 2, then print error
message and exit.
2) Initialize two variables; i = 1 (for looping) and pos = 1 (to find position of set bit)
3) Inside loop, do bitwise AND of i and number ‘N’. If value of this operation is true, then “pos” bit is set, so
break the loop and return position. Otherwise, increment “pos” by 1 and left shift i by 1 and repeat the
procedure.

// C program to find position of only set bit in a given number

#include <stdio.h>
// A utility function to check whether n is power of 2 or not. See http://goo.gl/17Arj

int isPowerOfTwo(unsigned n)
{ return n && (! (n & (n-1)) ); }
// Returns position of the only set bit in 'n'

int findPosition(unsigned n)
{
if (!isPowerOfTwo(n))
return -1;
unsigned i = 1, pos = 1;
// Iterate through bits of n till we find a set bit

// i&n will be non-zero only when 'i' and 'n' have a set bit
// at same position
while (!(i & n))
{
// Unset current bit and set the next bit in 'i'
i = i << 1;
// increment position
++pos;
}
return pos;
}

int main(void)
{
int n = 16;
int pos = findPosition(n);
(pos == -1)? printf("n = %d, Invalid number\n", n):
printf("n = %d, Position %d \n", n, pos);
n = 12;
pos = findPosition(n);
n = 128;
return 0;
}

Output:

n = 16, Position 5
n = 12, Invalid number
n = 128, Position 8

Following is another method for this problem. The idea is to one by one right shift the set bit of given
number ‘n’ until ‘n’ becomes 0. Count how many times we shifted to make ‘n’ zero. The final count is position
of the set bit.
// C program to find position of only set bit in a given number

#include <stdio.h>
// A utility function to check whether n is power of 2 or not

{ return n && (! (n & (n-1)) ); }
// Returns position of the only set bit in 'n'

{
return -1;
unsigned count = 0;
// One by one move the only set bit to right till it reaches end
while (n)
{
n = n >> 1;
// increment count of shifts

++count;
}
return count;
}

int main(void)
{
int n = 0;
n = 12;
n = 128;
return 0;
}

Output:

n = 128, Position 8

We can also use log base 2 to find the position . Thanks to Arunkumar for suggesting this solution.
#include <stdio.h>
unsigned int Log2n(unsigned int n)

{
return (n > 1)? 1 + Log2n(n/2): 0;
}
{
return n && (! (n & (n-1)) );
}
{
return -1;
return Log2n(n) + 1;
}

int main(void)
{
int n = 0;
n = 12;
n = 128;
return 0;
}

Output:

n = 128, Position 8

Stock Buy Sell to Maximize Profit
The cost of a stock on each day is given in an array, find the max profit that you can make by buying and
selling in those days. For example, if the given array is {100, 180, 260, 310, 40, 535, 695}, the maximum
profit can earned by buying on day 0, selling on day 3. Again buy on day 4 and sell on day 6. If the given
array of prices is sorted in decreasing order, then profit cannot be earned at all.
If we are allowed to buy and sell only once, then we can use following algorithm. Maximum difference
between two elements. Here we are allowed to buy and sell multiple times. Following is algorithm for this
problem.
1. Find the local minima and store it as starting index. If not exists, return.
2. Find the local maxima. and store it as ending index. If we reach the end, set the end as ending index.
3. Update the solution (Increment count of buy sell pairs)
4. Repeat the above steps if end is not reached.
// Program to find best buying and selling days

#include <stdio.h>
// solution structure
struct Interval
{
int buy;
int sell;
};
// This function finds the buy sell schedule for maximum profit
void stockBuySell(int price[], int n)
{
// Prices must be given for at least two days
if (n == 1)
return;
int count = 0; // count of solution pairs
// solution vector
Interval sol[n/2 + 1];
// Traverse through given price array

int i = 0;
while (i < n-1)
{
// Find Local Minima. Note that the limit is (n-2) as we are
// comparing present element to the next element.
while ((i < n-1) && (price[i+1] <= price[i]))
i++;
// If we reached the end, break as no further solution possible

if (i == n-1)
break;
// Store the index of minima

sol[count].buy = i++;
// Find Local Maxima. Note that the limit is (n-1) as we are

// comparing to previous element
while ((i < n) && (price[i] >= price[i-1]))
i++;
// Store the index of maxima

sol[count].sell = i-1;
// Increment count of buy/sell pairs

count++;
}
// print solution
if (count == 0)
printf("There is no day when buying the stock will make profit\n");
else
{
for (int i = 0; i < count; i++)
printf("Buy on day: %d\t Sell on day: %d\n", sol[i].buy, sol[i].sell);
}
return;
}

int main()
{
// stock prices on consecutive days
int price[] = {100, 180, 260, 310, 40, 535, 695};
// fucntion call
stockBuySell(price, n);
return 0;
}

Output:

Buy on day : 0 Sell on day: 3
Buy on day : 4 Sell on day: 6

Time Complexity: The outer loop runs till i becomes n-1. The inner two loops increment value of i in every
iteration. So overall time complexity is O(n)
Convert a given Binary Tree to Doubly Linked List | Set 1
Given a Binary Tree (Bt), convert it to a Doubly Linked List(DLL). The left and right pointers in nodes are to
be used as previous and next pointers respectively in converted DLL. The order of nodes in DLL must be
same as Inorder of the given Binary Tree. The first node of Inorder traversal (left most node in BT) must be
head node of the DLL.
I came across this interview during one of my interviews. A similar problem is discussed in this post. The
problem here is simpler as we don’t need to create circular DLL, but a simple DLL. The idea behind its
solution is quite simple and straight.
1. If left subtree exists, process the left subtree

…..1.a) Recursively convert the left subtree to DLL.
…..1.b) Then find inorder predecessor of root in left subtree (inorder predecessor is rightmost node in left
subtree).
…..1.c) Make inorder predecessor as previous of root and root as next of inorder predecessor.
2. If right subtree exists, process the right subtree (Below 3 steps are similar to left subtree).
…..2.a) Recursively convert the right subtree to DLL.
…..2.b) Then find inorder successor of root in right subtree (inorder successor is leftmost node in right
subtree).
…..2.c) Make inorder successor as next of root and root as previous of inorder successor.
3. Find the leftmost node and return it (the leftmost node is always head of converted DLL).
Below is the source code for above algorithm.
// A C++ program for in-place conversion of Binary Tree to DLL

#include <stdio.h>
/* A binary tree node has data, and left and right pointers */
struct node
{
int data;
node* left;
node* right;
};
/* This is the core function to convert Tree to list. This function follows
steps 1 and 2 of the above algorithm */
node* bintree2listUtil(node* root)
{
// Base case
if (root == NULL)
return root;
// Convert the left subtree and link to root

if (root->left != NULL)
{
// Convert the left subtree
node* left = bintree2listUtil(root->left);
// Find inorder predecessor. After this loop, left

// will point to the inorder predecessor
for (; left->right!=NULL; left=left->right);
// Make root as next of the predecessor

left->right = root;
// Make predecssor as previous of root

root->left = left;
}
// Convert the right subtree and link to root

if (root->right!=NULL)
{
// Convert the right subtree
node* right = bintree2listUtil(root->right);
// Find inorder successor. After this loop, right

// will point to the inorder successor
for (; right->left!=NULL; right = right->left);
// Make root as previous of successor

right->left = root;
// Make successor as next of root

root->right = right;
}
return root;
}
// The main function that first calls bintree2listUtil(), then follows step 3
// of the above algorithm
node* bintree2list(node *root)
{
// Base case
if (root == NULL)
return root;
// Convert to DLL using bintree2listUtil()

root = bintree2listUtil(root);
// bintree2listUtil() returns root node of the converted

// DLL. We need pointer to the leftmost node which is
// head of the constructed DLL, so move to the leftmost node
while (root->left != NULL)
root = root->left;
return (root);
}

{
node* new_node = new node;
new_node->left = new_node->right = NULL;
return (new_node);
}
/* Function to print nodes in a given doubly linked list */

void printList(node *node)
{
while (node!=NULL)
{
node = node->right;
}
}

int main()
{
// Let us create the tree shown in above diagram
// Convert to DLL
node *head = bintree2list(root);
// Print the converted list

printList(head);
return 0;
}

Output:

25 12 30 10 36 15

This article is compiled by Ashish Mangla and reviewed by GeeksforGeeks team. Please write comments if
You may also like to see Convert a given Binary Tree to Doubly Linked List | Set 2 for another simple and
efficient solution.
Static and Dynamic Libraries | Set 1
When a C program is compiled, the compiler generates object code. After generating the object code, the
compiler also invokes linker. One of the main tasks for linker is to make code of library functions (eg
printf(), scanf(), sqrt(), ..etc) available to your program. A linker can accomplish this task in two ways, by
copying the code of library function to your object code, or by making some arrangements so that the
complete code of library functions is not copied, but made available at run-time.
Static Linking and Static Libraries is the result of the linker making copy of all used library functions to
the executable file. Static Linking creates larger binary files, and need more space on disk and main
memory. Examples of static libraries (libraries which are statically linked) are, .a files in Linux and .lib files
in Windows.
Steps to create a static library Let us create and use a Static Library in UNIX or UNIX like OS.
1. Create a C file that contains functions in your library.
/* Filename: lib_mylib.c */
#include <stdio.h>
void fun(void)
{
printf("fun() called from a static library");
}

We have created only one file for simplicity. We can also create multiple files in a library.
2. Create a header file for the library
/* Filename: lib_mylib.h */
void fun(void);

3. Compile library files.

gcc -c lib_mylib.c -o lib_mylib.o

4. Create static library. This step is to bundle multiple object files in one static library (see ar for details).
The output of this step is static library.

ar rcs lib_mylib.a lib_mylib.o

5. Now our static library is ready to use. At this point we could just copy lib_hello_static.a somewhere else
to use it. For demo purposes, let us keep the library in the current directory.
Let us create a driver program that uses above created static library .
1. Create a C file with main function

/* filename: driver.c */
#include "lib_mylib.h"
void main()
{
fun();
}

2. Compile the driver program.

gcc -c driver.c -o driver.o

3. Link the compiled driver program to the static library. Note that -L. is used to tell that the static library is
in current folder (See this for details of -L and -l options).

gcc -o driver driver.o -L. -l_mylib

4. Run the driver program

./driver
fun() called from a static library

Following are some important points about static libraries.

1. For a static library, the actual code is extracted from the library by the linker and used to build the final
executable at the point you compile/build your application.
2. Each process gets its own copy of the code and data. Where as in case of dynamic libraries it is only code
shared, data is specific to each process. For static libraries memory footprints are larger. For example, if all
the window system tools were statically linked, several tens of megabytes of RAM would be wasted for a
typical user, and the user would be slowed down by a lot of paging.
3. Since library code is connected at compile time, the final executable has no dependencies on the the
library at run time i.e. no additional run-time loading costs, it means that you don’t need to carry along a
copy of the library that is being used and you have everything under your control and there is no
dependency.
4. In static libraries, once everything is bundled into your application, you don’t have to worry that the client
will have the right library (and version) available on their system.
5. One drawback of static libraries is, for any change(up-gradation) in the static libraries, you have to
recompile the main program every time.
6. One major advantage of static libraries being preferred even now “is speed”. There will be no dynamic
querying of symbols in static libraries. Many production line software use static libraries even today.
Dynamic linking and Dynamic Libraries Dynamic Linking doesn’t require the code to be copied, it is
done by just placing name of the library in the binary file. The actual linking happens when the program is
run, when both the binary file and the library are in memory. Examples of Dynamic libraries (libraries which
are linked at run-time) are, .so in Linux and .dll in Windows.
We will soon be covering more points on Dynamic Libraries and steps to create them.
This article is compiled by Abhijit Saha and reviewed by GeeksforGeeks team. Please write comments if
Check if a number is Palindrome
Given an integer, write a function that returns true if the given number is palindrome, else false. For
example, 12321 is palindrome, but 1451 is not palindrome.
Let the given number be num. A simple method for this problem is to first reverse digits of num, then
compare the reverse of num with num. If both are same, then return true, else false.
Following is an interesting method inspired from method#2 of this post. The idea is to create a copy of num
and recursively pass the copy by reference, and pass num by value. In the recursive calls, divide num by 10
while moving down the recursion tree. While moving up the recursion tree, divide the copy by 10. When they
meet in a function for which all child calls are over, the last digit of num will be ith digit from the beginning
and the last digit of copy will be ith digit from the end.
// A recursive C++ program to check whether a given number is

// palindrome or not
#include <stdio.h>
// A function that reurns true only if num contains one digit

int oneDigit(int num)
{
// comparison operation is faster than division operation.
// So using following instead of "return num / 10 == 0;"
return (num >= 0 && num < 10);
}
// A recursive function to find out whether num is palindrome

// or not. Initially, dupNum contains address of a copy of num.
bool isPalUtil(int num, int* dupNum)
{
// Base case (needed for recursion termination): This statement
// mainly compares the first digit with the last digit
if (oneDigit(num))
return (num == (*dupNum) % 10);
// This is the key line in this method. Note that all recursive
// calls have a separate copy of num, but they all share same copy
// of *dupNum. We divide num while moving up the recursion tree
if (!isPalUtil(num/10, dupNum))
return false;
// The following statements are executed when we move up the

// recursion call tree
*dupNum /= 10;
// At this point, if num%10 contains i'th digit from beiginning,

// then (*dupNum)%10 contains i'th digit from end
return (num % 10 == (*dupNum) % 10);
}
// The main function that uses recursive function isPalUtil() to

// find out whether num is palindrome or not
int isPal(int num)
{
// If num is negative, make it positive
if (num < 0)
num = -num;
// Create a separate copy of num, so that modifications made

// to address dupNum don't change the input number.
// to address dupNum don't change the input number.
int *dupNum = new int(num); // *dupNum = num
return isPalUtil(num, dupNum);

}

int main()
{
int n = 12321;
isPal(n)? printf("Yes\n"): printf("No\n");
n = 12;
n = 88;
n = 8999;
return 0;
}

Output:

Yes
No
Yes
No

Largest Rectangular Area in a Histogram | Set 1
Find the largest rectangular area possible in a given histogram where the largest rectangle can be made of a
number of contiguous bars. For simplicity, assume that all bars have same width and the width is 1 unit.
For example, consider the following histogram with 7 bars of heights {6, 2, 5, 4, 5, 2, 6}. The largest possible
rectangle possible is 12 (see the below figure, the max area rectangle is highlighted in red)
A simple solution is to one by one consider all bars as starting points and calculate area of all rectangles
starting with every bar. Finally return maximum of all possible areas. Time complexity of this solution would
be O(n^2).
We can use Divide and Conquer to solve this in O(nLogn) time. The idea is to find the minimum value in
the given array. Once we have index of the minimum value, the max area is maximum of following three
values.
a) Maximum area in left side of minimum value (Not including the min value)
b) Maximum area in right side of minimum value (Not including the min value)
c) Number of bars multiplied by minimum value.
The areas in left and right of minimum value bar can be calculated recursively. If we use linear search to find
the minimum value, then the worst case time complexity of this algorithm becomes O(n^2). In worst case,
we always have (n-1) elements in one side and 0 elements in other side and if the finding minimum takes
O(n) time, we get the recurrence similar to worst case of Quick Sort.
How to find the minimum efficiently? Range Minimum Query using Segment Tree can be used for this. We
build segment tree of the given histogram heights. Once the segment tree is built, all range minimum queries
take O(Logn) time. So over all complexity of the algorithm becomes.
Overall Time = Time to build Segment Tree + Time to recursively find maximum area
Time to build segment tree is O(n). Let the time to recursively find max area be T(n). It can be written as
following.
T(n) = O(Logn) + T(n-1)
The solution of above recurrence is O(nLogn). So overall time is O(n) + O(nLogn) which is O(nLogn).
// A Divide and Conquer Program to find maximum rectangular area in a histogram

#include <math.h>
#include <limits.h>
#include <iostream>
// A utility function to find minimum of three integers

int max(int x, int y, int z)
{ return max(max(x, y), z); }
// A utility function to get minimum of two numbers in hist[]

int minVal(int *hist, int i, int j)
{
if (i == -1) return j;
if (j == -1) return i;
return (hist[i] < hist[j])? i : j;
}

int getMid(int s, int e)
{ return s + (e -s)/2; }
/* A recursive function to get the index of minimum value in a given range of

indexes. The following are parameters for this function.
hist --> Input array for which segment tree is built

int RMQUtil(int *hist, int *st, int ss, int se, int qs, int qe, int index)
{
// min of the segment
return st[index];

return -1;

return minVal(hist, RMQUtil(hist, st, ss, mid, qs, qe, 2*index+1),
RMQUtil(hist, st, mid+1, se, qs, qe, 2*index+2));
}
// Return index of minimum element in range from index qs (quey start) to

int RMQ(int *hist, int *st, int n, int qs, int qe)
{
if (qs < 0 || qe > n-1 || qs > qe)
{
cout << "Invalid Input";
return -1;
}
return RMQUtil(hist, st, 0, n-1, qs, qe, 0);

}
// A recursive function that constructs Segment Tree for hist[ss..se].

int constructSTUtil(int hist[], int ss, int se, int *st, int si)
int constructSTUtil(int hist[], int ss, int se, int *st, int si)
{
if (ss == se)
return (st[si] = ss);
st[si] = minVal(hist, constructSTUtil(hist, ss, mid, st, si*2+1),
constructSTUtil(hist, mid+1, se, st, si*2+2));
return st[si];
}

int *constructST(int hist[], int n)
{

constructSTUtil(hist, 0, n-1, st, 0);

return st;
}
// A recursive function to find the maximum rectangular area.

// It uses segment tree 'st' to find the minimum value in hist[l..r]
int getMaxAreaRec(int *hist, int *st, int n, int l, int r)
{
// Base cases
if (l > r) return INT_MIN;
if (l == r) return hist[l];
// Find index of the minimum value in given range

// This takes O(Logn)time
int m = RMQ(hist, st, n, l, r);
/* Return maximum of following three possible cases

a) Maximum area in Left of min value (not including the min)
a) Maximum area in right of min value (not including the min)
c) Maximum area including min */
return max(getMaxAreaRec(hist, st, n, l, m-1),
getMaxAreaRec(hist, st, n, m+1, r),
(r-l+1)*(hist[m]) );
}
// The main function to find max area

int getMaxArea(int hist[], int n)
{
// Build segment tree from given array. This takes
// O(n) time
int *st = constructST(hist, n);
// Use recursive utility function to find the

// maximum area
return getMaxAreaRec(hist, st, n, 0, n-1);
}
int main()
{
int hist[] = {6, 1, 5, 4, 5, 2, 6};
int n = sizeof(hist)/sizeof(hist[0]);
cout << "Maximum area is " << getMaxArea(hist, n);
return 0;
}

Output:

Maximum area is 12

This problem can be solved in linear time. See below set 2 for linear time solution.
Linear time solution for Largest Rectangular Area in a Histogram
discussed above.
Largest Rectangular Area in a Histogram | Set 2
Find the largest rectangular area possible in a given histogram where the largest rectangle can be made of a
number of contiguous bars. For simplicity, assume that all bars have same width and the width is 1 unit.
For example, consider the following histogram with 7 bars of heights {6, 2, 5, 4, 5, 2, 6}. The largest possible
rectangle possible is 12 (see the below figure, the max area rectangle is highlighted in red)
We have discussed a Divide and Conquer based O(nLogn) solution for this problem. In this post, O(n) time
solution is discussed. Like the previous post, width of all bars is assumed to be 1 for simplicity. For every bar
‘x’, we calculate the area with ‘x’ as the smallest bar in the rectangle. If we calculate such area for every bar ‘x’
and find the maximum of all areas, our task is done. How to calculate area with ‘x’ as smallest bar? We need
to know index of the first smaller (smaller than ‘x’) bar on left of ‘x’ and index of first smaller bar on right of
‘x’. Let us call these indexes as ‘left index’ and ‘right index’ respectively.
We traverse all bars from left to right, maintain a stack of bars. Every bar is pushed to stack once. A bar is
popped from stack when a bar of smaller height is seen. When a bar is popped, we calculate the area with the
popped bar as smallest bar. How do we get left and right indexes of the popped bar – the current index tells
us the ‘right index’ and index of previous item in stack is the ‘left index’. Following is the complete
algorithm.
1) Create an empty stack.
2) Start from first bar, and do following for every bar ‘hist[i]’ where ‘i’ varies from 0 to n-1.
……a) If stack is empty or hist[i] is higher than the bar at top of stack, then push ‘i’ to stack.
……b) If this bar is smaller than the top of stack, then keep removing the top of stack while top of the stack is
greater. Let the removed bar be hist[tp]. Calculate area of rectangle with hist[tp] as smallest bar. For hist[tp],
the ‘left index’ is previous (previous to tp) item in stack and ‘right index’ is ‘i’ (current index).
3) If the stack is not empty, then one by one remove all bars from stack and do step 2.b for every removed
bar.
// C++ program to find maximum rectangular area in linear time

#include<iostream>
#include<stack>
// The main function to find the maximum rectangular area under given
// histogram with n bars
int getMaxArea(int hist[], int n)
{
// Create an empty stack. The stack holds indexes of hist[] array
// The bars stored in stack are always in increasing order of their
// heights.
stack<int> s;
int max_area = 0; // Initalize max area

int tp; // To store top of stack
int area_with_top; // To store area with top bar as the smallest bar
// Run through all bars of given histogram

int i = 0;
while (i < n)
{
// If this bar is higher than the bar on top stack, push it to stack
if (s.empty() || hist[s.top()] <= hist[i])
s.push(i++);
// If this bar is lower than top of stack, then calculate area of rectangle
// with stack top as the smallest (or minimum height) bar. 'i' is
// 'right index' for the top and element before top in stack is 'left index'
else
{
tp = s.top(); // store the top index
s.pop(); // pop the top
// Calculate the area with hist[tp] stack as smallest bar

area_with_top = hist[tp] * (s.empty() ? i : i - s.top() - 1);
// update max area, if needed

if (max_area < area_with_top)
max_area = area_with_top;
}
}
// Now pop the remaining bars from stack and calculate area with every
// popped bar as the smallest bar
while (s.empty() == false)
{
tp = s.top();
s.pop();
area_with_top = hist[tp] * (s.empty() ? i : i - s.top() - 1);
if (max_area < area_with_top)

max_area = area_with_top;
}
return max_area;
}

int main()
{
int hist[] = {6, 2, 5, 4, 5, 1, 6};
int n = sizeof(hist)/sizeof(hist[0]);
cout << "Maximum area is " << getMaxArea(hist, n);
return 0;
}

Output:

Maximum area is 12

Time Complexity: Since every bar is pushed and popped only once, the time complexity of this method is
O(n).
References
http://www.informatik.uni-ulm.de/acm/Locals/2003/html/histogram.html
http://www.informatik.uni-ulm.de/acm/Locals/2003/html/judge.html
Thanks to Ashish Anand for suggesting initial solution. Please write comments if you find anything
String matching where one string contains wildcard characters
Given two strings where first string may contain wild card characters and second string is a normal string.
Write a function that returns true if the two strings match. The following are allowed wild card characters in
first string.
* --> Matches with 0 or more instances of any character or set of characters.

? --> Matches with any one character.

For example, “g*ks” matches with “geeks” match. And string “ge?ks*” matches with “geeksforgeeks” (note ‘*’
at the end of first string). But “g*k” doesn’t match with “gee” as character ‘k’ is not present in second string.

// A C program to match wild card characters

#include <stdio.h>
// The main function that checks if two given strings match. The first
// string may contain wildcard characters
bool match(char *first, char * second)
{
// If we reach at the end of both strings, we are done
if (*first == '\0' && *second == '\0')
return true;
// Make sure that the characters after '*' are present in second string.
// This function assumes that the first string will not contain two
// consecutive '*'
if (*first == '*' && *(first+1) != '\0' && *second == '\0')
return false;
// If the first string contains '?', or current characters of both

// strings match
if (*first == '?' || *first == *second)
return match(first+1, second+1);
// If there is *, then there are two possibilities

// a) We consider current character of second string
// b) We ignore current character of second string.
if (*first == '*')
return match(first+1, second) || match(first, second+1);
return false;
}
// A function to run test cases

void test(char *first, char *second)
{ match(first, second)? puts("Yes"): puts("No"); }

int main()
{
test("g*ks", "geeks"); // Yes
test("ge?ks*", "geeksforgeeks"); // Yes
test("g*k", "gee"); // No because 'k' is not in second
test("*pqrs", "pqrst"); // No because 't' is not in first
test("abc*bcd", "abcdhghgbcd"); // Yes
test("abc*c?d", "abcd"); // No because second must have 2 instances of 'c'
test("*c*d", "abcd"); // Yes
test("*?c*d", "abcd"); // Yes
return 0;
}

Output:

Yes
Yes
No
No
Yes
No
Yes
Yes

Exercise
1) In the above solution, all non-wild characters of first string must be there is second string and all
characters of second string must match with either a normal character or wildcard character of first string.
Extend the above solution to work like other pattern searching solutions where the first string is pattern and
second string is text and we should print all occurrences of first string in second.
2) Write a pattern searching function where the meaning of ‘?’ is same, but ‘*’ means 0 or more occurrences
of the character just before ‘*’. For example, if first string is ‘a*b’, then it matches with ‘aaab’, but doesn’t
match with ‘abb’.
This article is compiled by Vishal Chaudhary and reviewed by GeeksforGeeks team. Please write comments if
Rearrange positive and negative numbers in O(n) time and O(1) extra space
An array contains both positive and negative numbers in random order. Rearrange the array elements so
that positive and negative numbers are placed alternatively. Number of positive and negative numbers need
not be equal. If there are more positive numbers they appear at the end of the array. If there are more
negative numbers, they too appear in the end of the array.
For example, if the input array is [-1, 2, -3, 4, 5, 6, -7, 8, 9], then the output should be [9, -7, 8, -3, 5, -1, 2, 4,
6]
The solution is to first separate positive and negative numbers using partition process of QuickSort. In the
partition process, consider 0 as value of pivot element so that all negative numbers are placed before positive
numbers. Once negative and positive numbers are separated, we start from the first negative number and
first positive number, and swap every alternate negative number with next positive number.
// A C++ program to put positive numbers at even indexes (0, 2, 4,..)

// and negative numbers at odd indexes (1, 3, 5, ..)
#include <stdio.h>
// prototype for swap

// The main function that rearranges elements of given array. It puts

// positive elements at even indexes (0, 2, ..) and negative numbers at
// odd indexes (1, 3, ..).
void rearrange(int arr[], int n)
{
// The following few lines are similar to partition process
// of QuickSort. The idea is to consider 0 as pivot and
// divide the array around it.
int i = -1;
for (int j = 0; j < n; j++)
{
if (arr[j] < 0)
{
i++;
}
}
// Now all positive numbers are at end and negative numbers at

// the beginning of array. Initialize indexes for starting point
// of positive and negative numbers to be swapped
int pos = i+1, neg = 0;
// Increment the negative index by 2 and positive index by 1, i.e.,

// swap every alternate negative number with next positive number
while (pos < n && neg < pos && arr[neg] < 0)
{
swap(&arr[neg], &arr[pos]);
pos++;
neg += 2;
}
}

{
int temp = *a;
*a = *b;
*a = *b;
*b = temp;
}

{
for (int i = 0; i < n; i++)
printf("%4d ", arr[i]);
}

int main()
{
int arr[] = {-1, 2, -3, 4, 5, 6, -7, 8, 9};
rearrange(arr, n);
printArray(arr, n);
return 0;
}

Output:

4 -3 5 -1 6 -7 2 8 9

Time Complexity: O(n) where n is number of elements in given array.

Note that the partition process changes relative order of elements.
This article is compiled by Abhay Rathi. Please write comments if you find anything incorrect, or you want
to share more information about the topic discussed above.
Geeks.
Write your own atoi()
The atoi() function takes a string (which represents an integer) as an argument and returns its value.
Following is a simple implementation. We initialize result as 0. We start from the first character and update
result for every character.
// A simple C++ program for implementation of atoi

#include <stdio.h>
// A simple atoi() function

int myAtoi(char *str)
{
int res = 0; // Initialize result
// Iterate through all characters of input string and update result

for (int i = 0; str[i] != '\0'; ++i)
res = res*10 + str[i] - '0';
// return result.
return res;
}

int main()
{
char str[] = "89789";
int val = myAtoi(str);
printf ("%d ", val);
return 0;
}

Output:

89789

The above function doesn’t handle negative numbers. Following is a simple extension to handle
negative numbers.

// A C++ program for implementation of atoi

#include <stdio.h>
// A simple atoi() function

{
int sign = 1; // Initialize sign as positive
int i = 0; // Initialize index of first digit

// If number is negative, then update sign
if (str[0] == '-')
{
sign = -1;
i++; // Also update index of first digit
}

// Iterate through all digits and update the result
for (; str[i] != '\0'; ++i)
res = res*10 + str[i] - '0';

// Return result with sign
return sign*res;
}

int main()
{
char str[] = "-123";
printf ("%d ", val);
return 0;
}

Output:

-123

The above implementation doesn’t handle errors. What if str is NULL or str contains non-numeric
characters. Following implementation handles errors .

// A simple C++ program for implementation of atoi
#include <stdio.h>
// A utility function to check whether x is numeric

bool isNumericChar(char x)
{
return (x >= '0' && x <= '9')? true: false;
}
// A simple atoi() function. If the given string contains

// any invalid character, then this function returns 0
{
if (*str == NULL)
return 0;

int sign = 1; // Initialize sign as positive
int i = 0; // Initialize index of first digit
// If number is negative, then update sign

if (str[0] == '-')
{
sign = -1;
i++; // Also update index of first digit
}
// Iterate through all digits of input string and update result

for (; str[i] != '\0'; ++i)
{
if (isNumericChar(str[i]) == false)
return 0; // You may add some lines to write error message
// to error stream
res = res*10 + str[i] - '0';
}
// Return result with sign

return sign*res;
}

int main()
{
char str[] = "-134";
printf("%d ", val);
return 0;
}

Time Complexity: O(n) where n is the number of characters in input string.
Exercise
Write your won atof() that takes a string (which represents an floating point value) as an argument and
returns its value as double.
Geeks.
Divide and Conquer | Set 4 (Karatsuba algorithm for fast multiplication)
Given two binary strings that represent value of two integers, find the product of two strings. For example, if
the first bit string is “1100” and second bit string is “1010”, output should be 120.
For simplicity, let the length of two strings be same and be n.
A Naive Approach is to follow the process we study in school. One by one take all bits of second number
and multiply it with all bits of first number. Finally add all multiplications. This algorithm takes O(n^2)
time.
Using Divide and Conquer, we can multiply two integers in less time complexity. We divide the given
numbers in two halves. Let the given numbers be X and Y.
For simplicity let us assume that n is even

X = Xl*2n/2 + Xr [Xl and Xr contain leftmost and rightmost n/2 bits of X]
Y = Yl*2n/2 + Yr [Yl and Yr contain leftmost and rightmost n/2 bits of Y]

The product XY can be written as following.

XY = (Xl*2n/2 + Xr)(Yl*2n/2 + Yr)
= 2n XlYl + 2n/2(XlYr + XrYl) + XrYr

If we take a look at the above formula, there are four multiplications of size n/2, so we basically divided the
problem of size n into for sub-problems of size n/2. But that doesn’t help because solution of recurrence T(n)
= 4T(n/2) + O(n) is O(n^2). The tricky part of this algorithm is to change the middle two terms to some
other form so that only one extra multiplication would be sufficient. The following is tricky expression for
middle two terms.

XlYr + XrYl = (Xl + Xr)(Yl + Yr) - XlYl- XrYr

So the final value of XY becomes

XY = 2n XlYl + 2n/2 * [(Xl + Xr)(Yl + Yr) - XlYl - XrYr] + XrYr

With above trick, the recurrence becomes T(n) = 3T(n/2) + O(n) and solution of this recurrence is O(n1.59).
What if the lengths of input strings are different and are not even? To handle the different length case, we
append 0’s in the beginning. To handle odd length, we put floor(n/2) bits in left half and ceil(n/2) bits in
right half. So the expression for XY changes to following.

XY = 22ceil(n/2) XlYl + 2ceil(n/2) * [(Xl + Xr)(Yl + Yr) - XlYl - XrYr] + XrYr

The above algorithm is called Karatsuba algorithm and it can be used for any base.
Following is C++ implementation of above algorithm.
// C++ implementation of Karatsuba algorithm for bit string multiplication.

#include<iostream>
#include<stdio.h>
// FOLLOWING TWO FUNCTIONS ARE COPIED FROM http://goo.gl/q0OhZ

// Helper method: given two unequal sized bit strings, converts them to
// same length by adding leading 0s in the smaller string. Returns the
// the new length
int makeEqualLength(string &str1, string &str2)
{
if (len1 < len2)
{
str1 = '0' + str1;
return len2;
}
else if (len1 > len2)
{
str2 = '0' + str2;
}
return len1; // If len1 >= len2
}
// The main function that adds two bit sequences and returns the addition
string addBitStrings( string first, string second )
{
string result; // To store the sum bits
// make the lengths same before adding

int length = makeEqualLength(first, second);

for (int i = length-1 ; i >= 0 ; i--)
{
int firstBit = first.at(i) - '0';
int secondBit = second.at(i) - '0';
// boolean expression for sum of 3 bits

int sum = (firstBit ^ secondBit ^ carry)+'0';
result = (char)sum + result;

carry = (firstBit&secondBit) | (secondBit&carry) | (firstBit&carry);
}
// if overflow, then add a leading 1

if (carry) result = '1' + result;
return result;
}
// A utility function to multiply single bits of strings a and b

int multiplyiSingleBit(string a, string b)
{ return (a[0] - '0')*(b[0] - '0'); }
// The main function that multiplies two bit strings X and Y and returns
// result as long integer
long int multiply(string X, string Y)
{
// Find the maximum of lengths of x and Y and make length
// of smaller string same as that of larger string
int n = makeEqualLength(X, Y);
// Base cases
if (n == 0) return 0;
if (n == 1) return multiplyiSingleBit(X, Y);
int fh = n/2; // First half of string, floor(n/2)

int sh = (n-fh); // Second half of string, ceil(n/2)
// Find the first half and second half of first string.

// Refer http://goo.gl/lLmgn for substr method
string Xl = X.substr(0, fh);
string Xr = X.substr(fh, sh);
// Find the first half and second half of second string

string Yl = Y.substr(0, fh);
string Yr = Y.substr(fh, sh);
// Recursively calculate the three products of inputs of size n/2

long int P1 = multiply(Xl, Yl);
long int P2 = multiply(Xr, Yr);
long int P3 = multiply(addBitStrings(Xl, Xr), addBitStrings(Yl, Yr));
// Combine the three products to get the final result.

return P1*(1<<(2*sh)) + (P3 - P1 - P2)*(1<<sh) + P2;
}
// Driver program to test aboev functions

int main()
{
printf ("%ld\n", multiply("1100", "1010"));
}

Output:

120
60
30
10
0
49
9

Time Complexity: Time complexity of the above solution is O(n1.59).
Time complexity of multiplication can be further improved using another Divide and Conquer algorithm,
fast Fourier transform. We will soon be discussing fast Fourier transform as a separate post.
Exercise
The above program returns a long int value and will not work for big strings. Extend the above program to
return a string instead of a long int value.
References:
Wikipedia page for Karatsuba algorithm
Algorithms 1st Edition by Sanjoy Dasgupta, Christos Papadimitriou and Umesh Vazirani
http://courses.csail.mit.edu/6.006/spring11/exams/notes3-karatsuba
http://www.cc.gatech.edu/~ninamf/Algos11/lectures/lect0131.pdf
discussed above.
B-Tree | Set 1 (Introduction)
B-Tree is a self-balancing search tree. In most of the other self-balancing search trees (like AVL and Red
Black Trees), it is assumed that everything is in main memory. To understand use of B-Trees, we must think
of huge amount of data that cannot fit in main memory. When the number of keys is high, the data is read
from disk in the form of blocks. Disk access time is very high compared to main memory access time. The
main idea of using B-Trees is to reduce the number of disk accesses. Most of the tree operations (search,
insert, delete, max, min, ..etc ) require O(h) disk accesses where h is height of the tree. B-tree is a fat tree.
Height of B-Trees is kept low by putting maximum possible keys in a B-Tree node. Generally, a B-Tree node
size is kept equal to the disk block size. Since h is low for B-Tree, total disk accesses for most of the
operations are reduced significantly compared to balanced Binary Search Trees like AVL Tree, Red Black
Tree, ..etc.
Properties of B-Tree
1) All leaves are at same level.
2) A B-Tree is defined by the term minimum degree ‘t’. The value of t depends upon disk block size.
3) Every node except root must contain at least t-1 keys. Root may contain minimum 1 key.
4) All nodes (including root) may contain at most 2t – 1 keys.
5) Number of children of a node is equal to the number of keys in it plus 1.
6) All keys of a node are sorted in increasing order. The child between two keys k1 and k2 contains all keys
in range from k1 and k2.
7) B-Tree grows and shrinks from root which is unlike Binary Search Tree. Binary Search Trees grow
downward and also shrink from downward.
8) Like other balanced Binary Search Trees, time complexity to search, insert and delete is O(Logn).
Following is an example B-Tree of minimum degree 3. Note that in practical B-Trees, the value of minimum
degree is much more than 3.
Search
Search is similar to search in Binary Search Tree. Let the key to be searched be k. We start from root and
recursively traverse down. For every visited non-leaf node, if the node has key, we simply return the node.
Otherwise we recur down to the appropriate child (The child which is just before the first greater key) of the
node. If we reach a leaf node and don’t find k in the leaf node, we return NULL.
Traverse
Traversal is also similar to Inorder traversal of Binary Tree. We start from the leftmost child, recursively
print the leftmost child, then repeat the same process for remaining children and keys. In the end,
recursively print the rightmost child.
// C++ implemntation of search() and traverse() methods

#include<iostream>
// A BTree node
class BTreeNode
{
int *keys; // An array of keys
int t; // Minimum degree (defines the range for number of keys)
BTreeNode **C; // An array of child pointers
int n; // Current number of keys
bool leaf; // Is true when node is leaf. Otherwise false
public:
BTreeNode(int _t, bool _leaf); // Constructor
// A function to traverse all nodes in a subtree rooted with this node

void traverse();
// A function to search a key in subtree rooted with this node.

BTreeNode *search(int k); // returns NULL if k is not present.
// Make BTree friend of this so that we can access private members of this
// class in BTree functions
friend class BTree;
};
// A BTree
class BTree
{
BTreeNode *root; // Pointer to root node
int t; // Minimum degree
public:
// Constructor (Initializes tree as empty)
BTree(int _t)
{ root = NULL; t = _t; }
// function to traverse the tree

void traverse()
{ if (root != NULL) root->traverse(); }
// function to search a key in this tree

BTreeNode* search(int k)
{ return (root == NULL)? NULL : root->search(k); }
};
// Constructor for BTreeNode class

BTreeNode::BTreeNode(int _t, bool _leaf)
{
// Copy the given minimum degree and leaf property
t = _t;
leaf = _leaf;
// Allocate memory for maximum number of possible keys

// and child pointers
keys = new int[2*t-1];
C = new BTreeNode *[2*t];
// Initialize the number of keys as 0

n = 0;
}
// Function to traverse all nodes in a subtree rooted with this node

void BTreeNode::traverse()
{
// There are n keys and n+1 children, travers through n keys
// and first n children
int i;
for (i = 0; i < n; i++)
{
{
// If this is not leaf, then before printing key[i],
// traverse the subtree rooted with child C[i].
if (leaf == false)
C[i]->traverse();
cout << " " << keys[i];
}
// Print the subtree rooted with last child

if (leaf == false)
C[i]->traverse();
}
// Function to search key k in subtree rooted with this node

BTreeNode *BTreeNode::search(int k)
{
// Find the first key greater than or equal to k
int i = 0;
while (i < n && k > keys[i])
i++;
// If the found key is equal to k, return this node

if (keys[i] == k)
return this;
// If key is not found here and this is a leaf node

if (leaf == true)
return NULL;
// Go to the appropriate child

return C[i]->search(k);
}

The above code doesn’t contain driver program. We will be covering the complete program in our next post
on B-Tree Insertion.
There are two conventions to define a B-Tree, one is to define by minimum degree (followed in
Cormen
book), second is define by order. We have followed the minimum degree convention and will be following
same in coming posts on B-Tree. The variable names used in the above program are also kept same as
Cormen book for better readability.
Insertion and Deletion

B-Trer Insertion
B-Tree Deletion
References:
Introduction to Algorithms 3rd Edition by Clifford Stein, Thomas H. Cormen, Charles E. Leiserson, Ronald
L. Rivest
discussed above.
Check whether a given graph is Bipartite or not
A Bipartite Graph is a graph whose vertices can be divided into two independent sets, U and V such that
every edge (u, v) either connects a vertex from U to V or a vertex from V to U. In other words, for every edge
(u, v), either u belongs to U and v to V, or u belongs to V and v to U. We can also say that there is no edge
that connects vertices of same set.
A bipartite graph is possible if the graph coloring is possible using two colors such that vertices in a set are
colored with the same color. Note that it is possible to color a cycle graph with even cycle using two colors.
For example, see the following graph.
It is not possible to color a cycle graph with odd cycle using two colors.
Algorithm to check if a graph is Bipartite:

One approach is to check whether the graph is 2-colorable or not using backtracking algorithm m coloring
problem.
Following is a simple algorithm to find out whether a given graph is Birpartite or not using Breadth First
Search (BFS).
1. Assign RED color to the source vertex (putting into set U).
2. Color all the neighbors with BLUE color (putting into set V).
3. Color all neighbor’s neighbor with RED color (putting into set U).
4. This way, assign color to all vertices such that it satisfies all the constraints of m way coloring problem
where m = 2.
5. While assigning colors, if we find a neighbor which is colored with same color as current vertex, then the
graph cannot be colored with 2 vertices (or graph is not Bipartite)
// C++ program to find out whether a given graph is Bipartite or not

#include <iostream>
#include <iostream>
#include <queue>
#define V 4
// This function returns true if graph G[V][V] is Bipartite, else false

bool isBipartite(int G[][V], int src)
{
// Create a color array to store colors assigned to all veritces. Vertex
// number is used as index in this array. The value '-1' of colorArr[i]
// is used to indicate that no color is assigned to vertex 'i'. The value
// 1 is used to indicate first color is assigned and value 0 indicates
// second color is assigned.
int colorArr[V];
for (int i = 0; i < V; ++i)
colorArr[i] = -1;
// Assign first color to source

colorArr[src] = 1;
// Create a queue (FIFO) of vertex numbers and enqueue source vertex

// for BFS traversal
queue <int> q;
q.push(src);
// Run while there are vertices in queue (Similar to BFS)

while (!q.empty())
{
// Dequeue a vertex from queue ( Refer http://goo.gl/35oz8 )
int u = q.front();
q.pop();
// Find all non-colored adjacent vertices

for (int v = 0; v < V; ++v)
{
// An edge from u to v exists and destination v is not colored
if (G[u][v] && colorArr[v] == -1)
{
// Assign alternate color to this adjacent v of u
colorArr[v] = 1 - colorArr[u];
q.push(v);
}
// An edge from u to v exists and destination v is colored with

// same color as u
else if (G[u][v] && colorArr[v] == colorArr[u])
return false;
}
}
// If we reach here, then all adjacent vertices can be colored with

// alternate color
return true;
}

int main()
{
int G[][V] = {{0, 1, 0, 1},
{1, 0, 1, 0},
{0, 1, 0, 1},
{1, 0, 1, 0}
};
isBipartite(G, 0) ? cout << "Yes" : cout << "No";

isBipartite(G, 0) ? cout << "Yes" : cout << "No";
return 0;
}

Output:

Yes

Refer this for C implementation of the same.
Time Complexity of the above approach is same as that Breadth First Search. In above implementation is
O(V^2) where V is number of vertices. If graph is represented using adjacency list, then the complexity
becomes O(V+E).
Exercise:
1. Can DFS algorithm be used to check the bipartite-ness of a graph? If yes, how?
2. The above algorithm works if the graph is strongly connected. Extend above code to work for graph with
more than one component.
References:
http://en.wikipedia.org/wiki/Graph_coloring
http://en.wikipedia.org/wiki/Bipartite_graph
B-Tree | Set 2 (Insert)
In the previous post, we introduced B-Tree. We also discussed search() and traverse() functions.
In this post, insert() operation is discussed. A new key is always inserted at leaf node. Let the key to be
inserted be k. Like BST, we start from root and traverse down till we reach a leaf node. Once we reach a leaf
node, we insert the key in that leaf node. Unlike BSTs, we have a predefined range on number of keys that a
node can contain. So before inserting a key to node, we make sure that the node has extra space.
How to make sure that a node has space available for key before the key is inserted? We use an operation
called splitChild() that is used to split a child of a node. See the following diagram to understand split. In the
following diagram, child y of x is being split into two nodes y and z. Note that the splitChild operation moves
a key up and this is the reason B-Trees grow up unlike BSTs which grow down.
As discussed above, to insert a new key, we go down from root to leaf. Before traversing down to a node, we
first check if the node is full. If the node is full, we split it to create space. Following is complete algorithm.
Insertion
1) Initialize x as root.
2) While x is not leaf, do following
..a) Find the child of x that is going to to be traversed next. Let the child be y.
..b) If y is not full, change x to point to y.
..c) If y is full, split it and change x to point to one of the two parts of y. If k is smaller than mid key in y, then
set x as first part of y. Else second part of y. When we split y, we move a key from y to its parent x.
3) The loop in step 2 stops when x is leaf. x must have space for 1 extra key as we have been splitting all
nodes in advance. So simply insert k to x.
Note that the algorithm follows the Cormen book. It is actually a proactive insertion algorithm where before
going down to a node, we split it if it is full. The advantage of splitting before is, we never traverse a node
twice. If we don’t split a node before going down to it and split it only if new key is inserted (reactive), we
may end up traversing all nodes again from leaf to root. This happens in cases when all nodes on the path
from root to leaf are full. So when we come to the leaf node, we split it and move a key up. Moving a key up
will cause a split in parent node (because parent was already full). This cascading effect never happens in
this proactive insertion algorithm. There is a disadvantage of this proactive insertion though, we may do
unnecessary splits.
Let us understand the algorithm with an example tree of minimum degree ‘t’ as 3 and a sequence of integers
10, 20, 30, 40, 50, 60, 70, 80 and 90 in an initially empty B-Tree.
Initially root is NULL. Let us first insert 10.
Let us now insert 20, 30, 40 and 50. They all will be inserted in root because maximum number of keys a
node can accommodate is 2*t – 1 which is 5.
Let us now insert 60. Since root node is full, it will first split into two, then 60 will be inserted into the
appropriate child.
Let us now insert 70 and 80. These new keys will be inserted into the appropriate leaf without any split.
Let us now insert 90. This insertion will cause a split. The middle key will go up to the parent.
See this for more examples.
Following is C++ implementation of the above proactive algorithm.
// C++ program for B-Tree insertion

#include<iostream>
// A BTree node
class BTreeNode
{
public:
// A utility function to insert a new key in the subtree rooted with

// this node. The assumption is, the node must be non-full when this
// function is called
void insertNonFull(int k);
// A utility function to split the child y of this node. i is index of y in

// child array C[]. The Child y must be full when this function is called
// child array C[]. The Child y must be full when this function is called
void splitChild(int i, BTreeNode *y);

void traverse();

// Make BTree friend of this so that we can access private members of this
// class in BTree functions
friend class BTree;
};
// A BTree
class BTree
{
public:
BTree(int _t)
{ root = NULL; t = _t; }
// function to traverse the tree

void traverse()
{ if (root != NULL) root->traverse(); }

{ return (root == NULL)? NULL : root->search(k); }
// The main function that inserts a new key in this B-Tree

void insert(int k);
};
// Constructor for BTreeNode class

BTreeNode::BTreeNode(int t1, bool leaf1)
{
t = t1;
leaf = leaf1;


n = 0;
}

{
int i;
for (i = 0; i < n; i++)
{
if (leaf == false)
C[i]->traverse();
cout << " " << keys[i];
cout << " " << keys[i];
}

if (leaf == false)
C[i]->traverse();
}

{
int i = 0;
i++;

if (keys[i] == k)
return this;

if (leaf == true)
return NULL;

}

void BTree::insert(int k)
{
// If tree is empty
if (root == NULL)
{
// Allocate memory for root
root = new BTreeNode(t, true);
root->keys[0] = k; // Insert key
root->n = 1; // Update number of keys in root
}
else // If tree is not empty
{
// If root is full, then tree grows in height
if (root->n == 2*t-1)
{
// Allocate memory for new root
BTreeNode *s = new BTreeNode(t, false);
// Make old root as child of new root

s->C[0] = root;
// Split the old root and move 1 key to the new root
s->splitChild(0, root);
// New root has two children now. Decide which of the

// two children is going to have new key
int i = 0;
if (s->keys[0] < k)
i++;
s->C[i]->insertNonFull(k);
// Change root
root = s;
}
else // If root is not full, call insertNonFull for root
root->insertNonFull(k);
}
}
// A utility function to insert a new key in this node

// The assumption is, the node must be non-full when this
void BTreeNode::insertNonFull(int k)
{
// Initialize index as index of rightmost element
int i = n-1;
// If this is a leaf node

if (leaf == true)
{
// The following loop does two things
// a) Finds the location of new key to be inserted
// b) Moves all greater keys to one place ahead
while (i >= 0 && keys[i] > k)
{
keys[i+1] = keys[i];
i--;
}
// Insert the new key at found location

keys[i+1] = k;
n = n+1;
}
else // If this node is not leaf
{
// Find the child which is going to have the new key
i--;
// See if the found child is full

if (C[i+1]->n == 2*t-1)
{
// If the child is full, then split it
splitChild(i+1, C[i+1]);
// After split, the middle key of C[i] goes up and

// C[i] is splitted into two. See which of the two
// is going to have the new key
if (keys[i+1] < k)
i++;
}
C[i+1]->insertNonFull(k);
}
}
// A utility function to split the child y of this node

// Note that y must be full when this function is called
void BTreeNode::splitChild(int i, BTreeNode *y)
{
// Create a new node which is going to store (t-1) keys
// of y
BTreeNode *z = new BTreeNode(y->t, y->leaf);
z->n = t - 1;
// Copy the last (t-1) keys of y to z

for (int j = 0; j < t-1; j++)
z->keys[j] = y->keys[j+t];
// Copy the last t children of y to z

if (y->leaf == false)
{
for (int j = 0; j < t; j++)
z->C[j] = y->C[j+t];
}
// Reduce the number of keys in y

y->n = t - 1;
// Since this node is going to have a new child,

// create space of new child
for (int j = n; j >= i+1; j--)
C[j+1] = C[j];
// Link the new child to this node

C[i+1] = z;
// A key of y will move to this node. Find location of

// new key and move all greater keys one space ahead
for (int j = n-1; j >= i; j--)
keys[j+1] = keys[j];
// Copy the middle key of y to this node

keys[i] = y->keys[t-1];
// Increment count of keys in this node

n = n + 1;
}

int main()
{
BTree t(3); // A B-Tree with minium degree 3
t.insert(10);
t.insert(20);
t.insert(5);
t.insert(6);
t.insert(12);
t.insert(30);
t.insert(7);
t.insert(17);
cout << "Traversal of the constucted tree is ";

t.traverse();
int k = 6;
(t.search(k) != NULL)? cout << "\nPresent" : cout << "\nNot Present";
k = 15;
(t.search(k) != NULL)? cout << "\nPresent" : cout << "\nNot Present";
return 0;
}

Output:

Traversal of the constucted tree is 5 6 7 10 12 17 20 30
Present
Not Present

References:
L. Rivest
http://www.cs.utexas.edu/users/djimenez/utsa/cs3343/lecture17.html
discussed above.
QuickSort on Doubly Linked List
Following is a typical recursive implementation of QuickSort for arrays. The implementation uses last
element as pivot.
/* A typical recursive implementation of Quicksort for array*/
/* This function takes last element as pivot, places the pivot element at its
correct position in sorted array, and places all smaller (smaller than
pivot) to left of pivot and all greater elements to right of pivot */
{
int x = arr[h];
int i = (l - 1);
for (int j = l; j <= h- 1; j++)

{
if (arr[j] <= x)
{
i++;
}
}
return (i + 1);
}
void quickSort(int A[], int l, int h)
{
if (l < h)
{
int p = partition(A, l, h); /* Partitioning index */
quickSort(A, l, p - 1);
quickSort(A, p + 1, h);
}
}

Can we use same algorithm for Linked List?

Following is C++ implementation for doubly linked list. The idea is simple, we first find out pointer to last
node. Once we have pointer to last node, we can recursively sort the linked list using pointers to first and last
nodes of linked list, similar to the above recursive function where we pass indexes of first and last array
elements. The partition function for linked list is also similar to partition for arrays. Instead of returning
index of the pivot element, it returns pointer to the pivot element. In the following implementation,
quickSort() is just a wrapper function, the main recursive function is _quickSort() which is similar to
quickSort() for array implementation.
// A C++ program to sort a linked list using Quicksort

#include <iostream>
#include <iostream>
#include <stdio.h>

struct node
{
int data;
struct node *next;
struct node *prev;
};
/* A utility function to swap two elements */

void swap ( int* a, int* b )
{ int t = *a; *a = *b; *b = t; }
// A utility function to find last node of linked list

struct node *lastNode(node *root)
{
while (root && root->next)
root = root->next;
return root;
}
/* Considers last element as pivot, places the pivot element at its

correct position in sorted array, and places all smaller (smaller than
pivot) to left of pivot and all greater elements to right of pivot */
node* partition(node *l, node *h)
{
// set pivot as h element
int x = h->data;
// similar to i = l-1 for array implementation

node *i = l->prev;
// Similar to "for (int j = l; j <= h- 1; j++)"

for (node *j = l; j != h; j = j->next)
{
if (j->data <= x)
{
// Similar to i++ for array
i = (i == NULL)? l : i->next;
swap(&(i->data), &(j->data));
}
}
i = (i == NULL)? l : i->next; // Similar to i++
swap(&(i->data), &(h->data));
return i;
}
/* A recursive implementation of quicksort for linked list */

void _quickSort(struct node* l, struct node *h)
{
if (h != NULL && l != h && l != h->next)
{
struct node *p = partition(l, h);
_quickSort(l, p->prev);
_quickSort(p->next, h);
}
}
// The main function to sort a linked list. It mainly calls _quickSort()

void quickSort(struct node *head)
{
{
// Find last node
struct node *h = lastNode(head);
// Call the recursive QuickSort

_quickSort(head, h);
}
// A utility function to print contents of arr

{
while (head)
{
head = head->next;
}
cout << endl;
}

{
struct node* new_node = new node; /* allocate node */
/* since we are adding at the begining, prev is always NULL */



if ((*head_ref) != NULL) (*head_ref)->prev = new_node ;

}

int main()
{
push(&a, 5);
push(&a, 20);
push(&a, 4);
push(&a, 3);
push(&a, 30);
cout << "Linked List before sorting \n";

printList(a);
quickSort(a);
cout << "Linked List after sorting \n";

printList(a);
return 0;
}

Output :

Linked List before sorting
30 3 4 20 5
Linked List after sorting
3 4 5 20 30

Time Complexity: Time complexity of the above implementation is same as time complexity of
QuickSort() for arrays. It takes O(n^2) time in worst case and O(nLogn) in average and best cases. The
worst case occurs when the linked list is already sorted.
Can we implement random quick sort for linked list?

Quicksort can be implemented for Linked List only when we can pick a fixed point as pivot (like last element
in above implementation). Random QuickSort cannot be efficiently implemented for Linked Lists by picking
random pivot.
Exercise:
The above implementation is for doubly linked list. Modify it for singly linked list. Note that we don’t have
prev pointer in singly linked list.
Refer QuickSort on Singly Linked List for solution.
discussed above
Longest prefix matching – A Trie based solution in Java
Given a dictionary of words and an input string, find the longest prefix of the string which is also a word in
dictionary.
Examples:
Let the dictionary contains the following words:

{are, area, base, cat, cater, children, basement}
Below are some input/output examples:

--------------------------------------
Input String Output
--------------------------------------
caterer cater
basemexy base
child

Solution
We build a Trie of all dictionary words. Once the Trie is built, traverse through it using characters of input
string. If prefix matches a dictionary word, store current length and look for a longer match. Finally, return
the longest match.
Following is Java implementation of the above solution based.

// Trie Node, which stores a character and the children in a HashMap
class TrieNode {
public TrieNode(char ch) {
value = ch;
children = new HashMap<>();
bIsEnd = false;
}
public HashMap<Character,TrieNode> getChildren() { return children; }
public char getValue() { return value; }
public void setIsEnd(boolean val) { bIsEnd = val; }
public boolean isEnd() { return bIsEnd; }

private char value;
private HashMap<Character,TrieNode> children;
private boolean bIsEnd;
}

// Implements the actual Trie
class Trie {
// Constructor
public Trie() { root = new TrieNode((char)0); }

// Method to insert a new word to Trie
public void insert(String word) {

// Find length of the given word
int length = word.length();
TrieNode crawl = root;

// Traverse through all characters of given word
// Traverse through all characters of given word
for( int level = 0; level < length; level++)
{
HashMap<Character,TrieNode> child = crawl.getChildren();
char ch = word.charAt(level);

// If there is already a child for current character of given word
if( child.containsKey(ch))
crawl = child.get(ch);
else // Else create a child
{
TrieNode temp = new TrieNode(ch);
child.put( ch, temp );
crawl = temp;
}
}

// Set bIsEnd true for last character
crawl.setIsEnd(true);
}

// The main method that finds out the longest string 'input'
public String getMatchingPrefix(String input) {
String result = ""; // Initialize resultant string
int length = input.length(); // Find length of the input string

// Initialize reference to traverse through Trie
TrieNode crawl = root;

// Iterate through all characters of input string 'str' and traverse
// down the Trie
int level, prevMatch = 0;
for( level = 0 ; level < length; level++ )
{
// Find current character of str
char ch = input.charAt(level);

// HashMap of current Trie node to traverse down
HashMap<Character,TrieNode> child = crawl.getChildren();

// See if there is a Trie edge for the current character
if( child.containsKey(ch) )
{
result += ch; //Update result
crawl = child.get(ch); //Update crawl to move down in Trie

// If this is end of a word, then update prevMatch
if( crawl.isEnd() )
prevMatch = level + 1;
}
else break;
}

// If the last processed character did not match end of a word,
// return the previously matching prefix
if( !crawl.isEnd() )
return result.substring(0, prevMatch);

else return result;
}

private TrieNode root;
}

// Testing class
public class Test {
Trie dict = new Trie();
dict.insert("are");
dict.insert("area");
dict.insert("base");
dict.insert("cat");
dict.insert("cater");
dict.insert("basement");

String input = "caterer";
System.out.print(input + ": ");
System.out.println(dict.getMatchingPrefix(input));
input = "basement";

input = "are";
input = "arex";
input = "basemexz";

input = "xyz";
}
}

Output:
caterer: cater
basement: basement
are: are
arex: are
basemexz: base
xyz:

Time Complexity: Time complexity of finding the longest prefix is O(n) where n is length of the input string.
Refer this for time complexity of building the Trie.
or you want to share more information about the topic discussed above
Dynamic Programming | Set 28 (Minimum insertions to form a
palindrome)
Given a string, find the minimum number of characters to be inserted to convert it to palindrome.
Before we go further, let us understand with few examples:

ab: Number of insertions required is 1. bab
aa: Number of insertions required is 0. aa
abcd: Number of insertions required is 3. dcbabcd
abcda: Number of insertions required is 2. adcbcda which is same as number of insertions in the substring
bcd(Why?).
abcde: Number of insertions required is 4. edcbabcde
Let the input string be str[l……h]. The problem can be broken down into three parts:
1. Find the minimum number of insertions in the substring str[l+1,…….h].
2. Find the minimum number of insertions in the substring str[l…….h-1].
3. Find the minimum number of insertions in the substring str[l+1……h-1].
Recursive Solution
The minimum number of insertions in the string str[l…..h] can be given as:
minInsertions(str[l+1…..h-1]) if str[l] is equal to str[h]
min(minInsertions(str[l…..h-1]), minInsertions(str[l+1…..h])) + 1 otherwise
// A Naive recursive program to find minimum number insertions

// needed to make a string palindrome
#include <stdio.h>
#include <limits.h>
#include <string.h>
// A utility function to find minimum of two numbers

// Recursive function to find minimum number of insersions

int findMinInsertions(char str[], int l, int h)
{
// Base Cases
if (l > h) return INT_MAX;
if (l == h) return 0;
if (l == h - 1) return (str[l] == str[h])? 0 : 1;
// Check if the first and last characters are same. On the basis of the
// comparison result, decide which subrpoblem(s) to call
return (str[l] == str[h])? findMinInsertions(str, l + 1, h - 1):
(min(findMinInsertions(str, l, h - 1),
findMinInsertions(str, l + 1, h)) + 1);
}

int main()
{
char str[] = "geeks";
printf("%d", findMinInsertions(str, 0, strlen(str)-1));
return 0;
}

Output:
Dynamic Programming based Solution

If we observe the above approach carefully, we can find that it exhibits overlapping subproblems.
Suppose we want to find the minimum number of insertions in string “abcde”:

abcde
/ | \
/ | \
bcde abcd bcd <- case 3 is discarded as str[l] != str[h]
/ | \ / | \
/ | \ / | \
cde bcd cd bcd abc bc
/ | \ / | \ /|\ / | \
de cd d cd bc c………………….

The substrings in bold show that the recursion to be terminated and the recursion tree cannot originate from
there. Substring in the same color indicates overlapping subproblems.
How to reuse solutions of subproblems?

We can create a table to store results of subproblems so that they can be used directly if same subproblem is
encountered again.
The below table represents the stored values for the string abcde.

a b c d e
----------
0 1 2 3 4
0 0 1 2 3
0 0 0 1 2
0 0 0 0 1
0 0 0 0 0

How to fill the table?

The table should be filled in diagonal fashion. For the string abcde, 0….4, the following should be order in
which the table is filled:

Gap = 1:
(0, 1) (1, 2) (2, 3) (3, 4)
Gap = 2:
(0, 2) (1, 3) (2, 4)
Gap = 3:
(0, 3) (1, 4)
Gap = 4:
(0, 4)

// A Dynamic Programming based program to find minimum number

// insertions needed to make a string palindrome
#include <stdio.h>
#include <string.h>
// A utility function to find minimum of two integers

// A DP function to find minimum number of insersions

int findMinInsertionsDP(char str[], int n)
{
// Create a table of size n*n. table[i][j] will store
// minumum number of insertions needed to convert str[i..j]
// to a palindrome.
int table[n][n], l, h, gap;
// Initialize all table entries as 0

// Fill the table

for (gap = 1; gap < n; ++gap)
for (l = 0, h = gap; h < n; ++l, ++h)
table[l][h] = (str[l] == str[h])? table[l+1][h-1] :
(min(table[l][h-1], table[l+1][h]) + 1);
// Return minimum number of insertions for str[0..n-1]

return table[0][n-1];
}

int main()
{
printf("%d", findMinInsertionsDP(str, strlen(str)));
return 0;
}

Output:

3

Time complexity: O(N^2)

Auxiliary Space: O(N^2)
Another Dynamic Programming Solution (Variation of Longest Common Subsequence

Problem)
The problem of finding minimum insertions can also be solved using Longest Common Subsequence (LCS)
Problem. If we find out LCS of string and its reverse, we know how many maximum characters can form a
palindrome. We need insert remaining characters. Following are the steps.
1) Find the length of LCS of input string and its reverse. Let the length be ‘l’.
2) The minimum number insertions needed is length of input string minus ‘l’.

// An LCS based program to find minimum number insertions needed to

// make a string palindrome
#include<stdio.h>
#include <string.h>

{ return (a > b)? a : b; }
/* Returns length of LCS for X[0..m-1], Y[0..n-1].

See http://goo.gl/bHQVP for details of this function */
{
int L[n+1][n+1];
int i, j;

for (i=0; i<=m; i++)
{
for (j=0; j<=n; j++)
{
if (i == 0 || j == 0)
L[i][j] = 0;
else if (X[i-1] == Y[j-1])

L[i][j] = L[i-1][j-1] + 1;
else
L[i][j] = max(L[i-1][j], L[i][j-1]);
}
}
/* L[m][n] contains length of LCS for X[0..n-1] and Y[0..m-1] */

return L[m][n];
}
// LCS based function to find minimum number of insersions

int findMinInsertionsLCS(char str[], int n)
{
// Creata another string to store reverse of 'str'
char rev[n+1];
strcpy(rev, str);
strrev(rev);
// The output is length of string minus length of lcs of

// str and it reverse
return (n - lcs(str, rev, n, n));
}

int main()
{
printf("%d", findMinInsertionsLCS(str, strlen(str)));
return 0;
}

Output:

3

Time complexity of this method is also O(n^2) and this method also requires O(n^2) extra space.
Dynamic Programming | Set 29 (Longest Common Substring)
Given two strings ‘X’ and ‘Y’, find the length of the longest common substring. For example, if the given
strings are “GeeksforGeeks” and “GeeksQuiz”, the output should be 5 as longest common substring is
“Geeks”
Let m and n be the lengths of first and second strings respectively.
A simple solution is to one by one consider all substrings of first string and for every substring check if it is
a substring in second string. Keep track of the maximum length substring. There will be O(m^2) substrings
and we can find whether a string is subsring on another string in O(n) time (See this). So overall time
complexity of this method would be O(n * m2)
Dynamic Programming can be used to find the longest common substring in O(m*n) time. The idea is to
find length of the longest common suffix for all substrings of both strings and store these lengths in a table.
The longest common suffix has following optimal substructure property

LCSuff(X, Y, m, n) = LCSuff(X, Y, m-1, n-1) + 1 if X[m-1] = Y[n-1]
0 Otherwise (if X[m-1] != Y[n-1])
The maximum length Longest Common Suffix is the longest common substring.
LCSubStr(X, Y, m, n) = Max(LCSuff(X, Y, i, j)) where 1
Following is C++ implementation of the above solution.

/* Dynamic Programming solution to find length of the longest common substring */
#include<iostream>
#include<string.h>

{ return (a > b)? a : b; }
/* Returns length of longest common substring of X[0..m-1] and Y[0..n-1] */

int LCSubStr(char *X, char *Y, int m, int n)
{
// Create a table to store lengths of longest common suffixes of
// substrings. Notethat LCSuff[i][j] contains length of longest
// common suffix of X[0..i-1] and Y[0..j-1]. The first row and
// first column entries have no logical meaning, they are used only
// for simplicity of program
int LCSuff[m+1][n+1];
int result = 0; // To store length of the longest common substring
/* Following steps build LCSuff[m+1][n+1] in bottom up fashion. */

for (int i=0; i<=m; i++)
{
for (int j=0; j<=n; j++)
{
if (i == 0 || j == 0)
LCSuff[i][j] = 0;
else if (X[i-1] == Y[j-1])

{
LCSuff[i][j] = LCSuff[i-1][j-1] + 1;
result = max(result, LCSuff[i][j]);
}
else LCSuff[i][j] = 0;
else LCSuff[i][j] = 0;
}
}
return result;
}

int main()
{
char X[] = "OldSite:GeeksforGeeks.org";
char Y[] = "NewSite:GeeksQuiz.com";
int m = strlen(X);
int n = strlen(Y);
cout << "Length of Longest Common Substring is " << LCSubStr(X, Y, m, n);
return 0;
}

Output:
Length of Longest Common Substring is 10
Time Complexity: O(m*n)
Auxiliary Space: O(m*n)
References: http://en.wikipedia.org/wiki/Longest_common_substring_problem
The longest substring can also be solved in O(n+m) time using Suffix Tree. We will be c
overing Suffix Tree based solution in a separate post.
Exercise: The above solution prints only length of the longest common substring. Extend
the solution to print the substring also.

Sort elements by frequency | Set 2
Given an array of integers, sort the array according to frequency of elements. For example, if the input array
is {2, 3, 2, 4, 5, 12, 2, 3, 3, 3, 12}, then modify the array to {3, 3, 3, 3, 2, 2, 2, 12, 12, 4, 5}.
In the previous post, we have discussed all methods for sorting according to frequency. In this post, method
2 is discussed in detail and C++ implementation for the same is provided.
Following is detailed algorithm.

1) Create a BST and while creating BST maintain the count i,e frequency of each coming element in same
BST. This step may take O(nLogn) time if a self balancing BST is used.
2) Do Inorder traversal of BST and store every element and count of each element in an auxiliary array. Let
us call the auxiliary array as ‘count[]’. Note that every element of this array is element and frequency pair.
This step takes O(n) time.
3) Sort ‘count[]’ according to frequency of the elements. This step takes O(nLohn) time if a O(nLogn) sorting
algorithm is used.
4) Traverse through the sorted array ‘count[]’. For each element x, print it ‘freq’ times where ‘freq’ is
frequency of x. This step takes O(n) time.
Overall time complexity of the algorithm can be minimum O(nLogn) if we use a O(nLogn) sorting algorithm
and use a self balancing BST with O(Logn) insert operation.
// Implementation of above algorithm in C++.

#include <iostream>
#include <stdlib.h>
/* A BST node has data, freq, left and right pointers */

struct BSTNode
{
struct BSTNode *left;
int data;
int freq;
struct BSTNode *right;
};
// A structure to store data and its frequency

struct dataFreq
{
int data;
int freq;
};
/* Function for qsort() implementation. Compare frequencies to

sort the array according to decreasing order of frequency */
int compare(const void *a, const void *b)
{
return ( (*(const dataFreq*)b).freq - (*(const dataFreq*)a).freq );
}
/* Helper function that allocates a new node with the given data,
frequency as 1 and NULL left and right pointers.*/
BSTNode* newNode(int data)
{
struct BSTNode* node = new BSTNode;
node->data = data;
node->left = NULL;
node->right = NULL;
node->right = NULL;
node->freq = 1;
return (node);
}
// A utility function to insert a given key to BST. If element

// is already present, then increases frequency
BSTNode *insert(BSTNode *root, int data)
{
if (root == NULL)
return newNode(data);
if (data == root->data) // If already present
root->freq += 1;
else if (data < root->data)
root->left = insert(root->left, data);
else
root->right = insert(root->right, data);
return root;
}
// Function to copy elements and their frequencies to count[].

void store(BSTNode *root, dataFreq count[], int *index)
{
// Base Case
if (root == NULL) return;
// Recur for left substree

store(root->left, count, index);
// Store item from root and increment index

count[(*index)].freq = root->freq;
count[(*index)].data = root->data;
(*index)++;
// Recur for right subtree

store(root->right, count, index);
}
// The main function that takes an input array as an argument

// and sorts the array items according to frequency
void sortByFrequency(int arr[], int n)
{
// Create an empty BST and insert all array items in BST
struct BSTNode *root = NULL;
for (int i = 0; i < n; ++i)
root = insert(root, arr[i]);
// Create an auxiliary array 'count[]' to store data and

// frequency pairs. The maximum size of this array would
// be n when all elements are different
dataFreq count[n];
int index = 0;
store(root, count, &index);
// Sort the count[] array according to frequency (or count)

qsort(count, index, sizeof(count[0]), compare);
// Finally, traverse the sorted count[] array and copy the

// i'th item 'freq' times to original array 'arr[]'
int j = 0;
for (int i = 0; i < index; i++)
{
for (int freq = count[i].freq; freq > 0; freq--)
arr[j++] = count[i].data;
}
}

{
for (int i = 0; i < n; i++)
cout << arr[i] << " ";
cout << endl;
}

int main()
{
int arr[] = {2, 3, 2, 4, 5, 12, 2, 3, 3, 3, 12};
sortByFrequency(arr, n);
printArray(arr, n);
return 0;
}

Output:

3 3 3 3 2 2 2 12 12 5 4

Exercise:
The above implementation doesn’t guarantee original order of elements with same frequency (for example, 4
comes before 5 in input, but 4 comes after 5 in output). Extend the implementation to maintain original
order. For example, if two elements have same frequency then print the one which came 1st in input array.
This article is compiled by Chandra Prakash. Please write comments if you find anything incorrect, or you
Swap Kth node from beginning with Kth node from end in a Linked List
Given a singly linked list, swap kth node from beginning with kth node from end. Swapping of data is not
allowed, only pointers should be changed. This requirement may be logical in many situations where
the linked list data part is huge (For example student details line Name, RollNo, Address, ..etc). The pointers
are always fixed (4 bytes for most of the compilers).
The problem seems simple at first look, but it has many interesting cases.
Let X be the kth node from beginning and Y be the kth node from end. Following are the interesting cases
that must be handled.
1) Y is next to X
2) X is next to Y
3) X and Y are same
4) X and Y don’t exist (k is more than number of nodes in linked list)
We strongly recommend you to try it yourself first, then see the below solution. It will be a good exercise of
pointers.
// A C++ program to swap Kth node from beginning with kth node from end
#include <iostream>
#include <stdlib.h>
// A Linked List node

struct node
{
int data;
struct node *next;
};
/* Utility function to insert a node at the beginning */

{
struct node *new_node = (struct node *) malloc(sizeof(struct node));
}
/* Utility function for displaying linked list */

{
{
cout << node->data << " ";
node = node->next;
}
cout << endl;
cout << endl;
}
/* Utility function for calculating length of linked list */

int countNodes(struct node *s)
{
int count = 0;
while (s != NULL)
{
count++;
s = s->next;
}
return count;
}
/* Function for swapping kth nodes from both ends of linked list */
void swapKth(struct node **head_ref, int k)
{
// Count nodes in linked list
int n = countNodes(*head_ref);
// Check if k is valid
if (n < k) return;
// If x (kth node from start) and y(kth node from end) are same
if (2*k - 1 == n) return;
// Find the kth node from beginning of linked list. We also find
// previous of kth node because we need to update next pointer of
// the previous.
node *x = *head_ref;
node *x_prev = NULL;
for (int i = 1; i < k; i++)
{
x_prev = x;
x = x->next;
}
// Similarly, find the kth node from end and its previous. kth node
// from end is (n-k+1)th node from beginning
node *y = *head_ref;
node *y_prev = NULL;
for (int i = 1; i < n-k+1; i++)
{
y_prev = y;
y = y->next;
}
// If x_prev exists, then new next of it will be y. Consider the case

// when y->next is x, in this case, x_prev and y are same. So the statement
// "x_prev->next = y" creates a self loop. This self loop will be broken
// when we change y->next.
if (x_prev)
x_prev->next = y;
// Same thing applies to y_prev

if (y_prev)
y_prev->next = x;
// Swap next pointers of x and y. These statements also break self

// loop if x->next is y or y->next is x
node *temp = x->next;
x->next = y->next;
y->next = temp;
// Change head pointers when k is 1 or n
if (k == 1)
*head_ref = y;
if (k == n)
*head_ref = x;
}

int main()
{
// Let us create the following linked list for testing
// 1->2->3->4->5->6->7->8
for (int i = 8; i >= 1; i--)
push(&head, i);
cout << "Original Linked List: ";

printList(head);
for (int k = 1; k < 10; k++)

{
swapKth(&head, k);
cout << "\nModified List for k = " << k << endl;
printList(head);
}
return 0;
}

Output:

Original Linked List: 1 2 3 4 5 6 7 8
Modified List for k = 1

8 2 3 4 5 6 7 1

8 7 3 4 5 6 2 1

8 7 6 4 5 3 2 1

8 7 6 5 4 3 2 1

8 7 6 4 5 3 2 1

8 7 3 4 5 6 2 1

8 2 3 4 5 6 7 1

1 2 3 4 5 6 7 8

1 2 3 4 5 6 7 8

Please note that the above code runs three separate loops to count nodes, find x and x prev, and to find y and
y_prev. These three things can be done in a single loop. The code uses three loops to keep things simple and
readable.
Thanks to Chandra Prakash for initial solution. Please write comments if you find anything incorrect, or you
Topological Sorting
Topological sorting for Directed Acyclic Graph (DAG) is a linear ordering of vertices such that for every
directed edge uv, vertex u comes before v in the ordering. Topological Sorting for a graph is not possible if
the graph is not a DAG.
For example, a topological sorting of the following graph is “5 4 2 3 1 0″. There can be more than one
topological sorting for a graph. For example, another topological sorting of the following graph is “4 5 2 3 1
0″. The first vertex in topological sorting is always a vertex with in-degree as 0 (a vertex with no in-coming
edges).
Topological Sorting vs Depth First Traversal (DFS) :

In DFS, we print a vertex and then recursively call DFS for its adjacent vertices. In topological sorting, we
need to print a vertex before its adjacent vertices. For example, in the given graph, the vertex ‘5’ should be
printed before vertex ‘0’, but unlike DFS, the vertex ‘4’ should also be printed before vertex ‘0’. So
Topological sorting is different from DFS. For example, a DFS of the above graph is “5 2 3 1 0 4″, but it is not
a topological sorting
Algorithm to find Topological Sorting:

We recommend to first see implementation of DFS here. We can modify DFS to find Topological Sorting of a
graph. In DFS, we start from a vertex, we first print it and then recursively call DFS for its adjacent vertices.
In topological sorting, we use a temporary stack. We don’t print the vertex immediately, we first recursively
call topological sorting for all its adjacent vertices, then push it to a stack. Finally, print contents of stack.
Note that a vertex is pushed to stack only when all of its adjacent vertices (and their adjacent vertices and so
on) are already in stack.
Following is C++ implementation of topological sorting. Please see the code for Depth First Traversal for a
disconnected Graph and note the differences between the second code given there and the below code.
// A C++ program to print topological sorting of a DAG

#include<iostream>
#include <list>
#include <stack>
// Class to represent a graph

class Graph
{
int V; // No. of vertices'
// Pointer to an array containing adjacency listsList

list<int> *adj;
// A function used by topologicalSort
void topologicalSortUtil(int v, bool visited[], stack<int> &Stack);
public:
// function to add an edge to graph

void addEdge(int v, int w);
// prints a Topological Sort of the complete graph

void topologicalSort();
};
Graph::Graph(int V)
{
this->V = V;
}

{
}
// A recursive function used by topologicalSort

void Graph::topologicalSortUtil(int v, bool visited[], stack<int> &Stack)
{
// Mark the current node as visited.
visited[v] = true;

for (i = adj[v].begin(); i != adj[v].end(); ++i)
if (!visited[*i])
topologicalSortUtil(*i, visited, Stack);
// Push current vertex to stack which stores result

Stack.push(v);
}
// The function to do Topological Sort. It uses recursive topologicalSortUtil()

void Graph::topologicalSort()
{
stack<int> Stack;

for (int i = 0; i < V; i++)
visited[i] = false;
// Call the recursive helper function to store Topological Sort

for (int i = 0; i < V; i++)
if (visited[i] == false)
topologicalSortUtil(i, visited, Stack);

while (Stack.empty() == false)
{
cout << Stack.top() << " ";
Stack.pop();
}
}

int main()
{
Graph g(6);
g.addEdge(5, 2);
g.addEdge(5, 0);
g.addEdge(4, 0);
g.addEdge(4, 1);
g.addEdge(2, 3);
g.addEdge(3, 1);
cout << "Following is a Topological Sort of the given graph \n";

g.topologicalSort();
return 0;
}

Output:

Following is a Topological Sort of the given graph
5 4 2 3 1 0

Time Complexity: The above algorithm is simply DFS with an extra stack. So time complexity is same as
DFS which is O(V+E).
Applications:
Topological Sorting is mainly used for scheduling jobs from the given dependencies among jobs. In
computer science, applications of this type arise in instruction scheduling, ordering of formula cell
evaluation when recomputing formula values in spreadsheets, logic synthesis, determining the order of
compilation tasks to perform in makefiles, data serialization, and resolving symbol dependencies in linkers
[2].
References:
http://www.personal.kent.edu/~rmuhamma/Algorithms/MyAlgorithms/GraphAlgor/topoSort.htm
http://en.wikipedia.org/wiki/Topological_sorting
discussed above
Shortest Path in Directed Acyclic Graph
Given a Weighted Directed Acyclic Graph and a source vertex in the graph, find the shortest paths from given
source to all other vertices.
For a general weighted graph, we can calculate single source shortest distances in O(VE) time using
Bellman–Ford Algorithm. For a graph with no negative weights, we can do better and calculate single source
shortest distances in O(E + VLogV) time using Dijkstra’s algorithm. Can we do even better for Directed
Acyclic Graph (DAG)? We can calculate single source shortest distances in O(V+E) time for DAGs. The idea
is to use Topological Sorting.
We initialize distances to all vertices as infinite and distance to source as 0, then we find a topological sorting
of the graph. Topological Sorting of a graph represents a linear ordering of the graph (See below, figure (b) is
a linear representation of figure (a) ). Once we have topological order (or linear representation), we one by
one process all vertices in topological order. For every vertex being processed, we update distances of its
adjacent using distance of current vertex.
Following figure is taken from this source. It shows step by step process of finding shortest paths.
Following is complete algorithm for finding shortest distances.

1) Initialize dist[] = {INF, INF, ….} and dist[s] = 0 where s is the source vertex.
2) Create a toplogical order of all vertices.
3) Do following for every vertex u in topological order.
………..Do following for every adjacent vertex v of u
………………if (dist[v] > dist[u] + weight(u, v))
………………………dist[v] = dist[u] + weight(u, v)
// A C++ program to find single source shortest paths for Directed Acyclic Graphs
#include<iostream>
#include <list>
#include <stack>
#include <limits.h>
#define INF INT_MAX
// Graph is represented using adjacency list. Every node of adjacency list

// contains vertex number of the vertex to which edge connects. It also
// contains weight of the edge
class AdjListNode
{
int v;
int weight;
public:
AdjListNode(int _v, int _w) { v = _v; weight = _w;}
int getV() { return v; }
int getWeight() { return weight; }
};
// Class to represent a graph using adjacency list representation

class Graph
{
// Pointer to an array containing adjacency lists

list<AdjListNode> *adj;
// A function used by shortestPath

public:

void addEdge(int u, int v, int weight);
// Finds shortest paths from given source vertex

void shortestPath(int s);
};
Graph::Graph(int V)
{
this->V = V;
adj = new list<AdjListNode>[V];
}
void Graph::addEdge(int u, int v, int weight)

{
AdjListNode node(v, weight);
adj[u].push_back(node); // Add v to u's list
}
// A recursive function used by shortestPath. See below link for details

// http://www.geeksforgeeks.org/topological-sorting/
{
// Mark the current node as visited
visited[v] = true;
list<AdjListNode>::iterator i;
{
AdjListNode node = *i;
if (!visited[node.getV()])
topologicalSortUtil(node.getV(), visited, Stack);
}
// Push current vertex to stack which stores topological sort

Stack.push(v);
}
// The function to find shortest paths from given vertex. It uses recursive
// topologicalSortUtil() to get topological sorting of given graph.
void Graph::shortestPath(int s)
{
stack<int> Stack;
int dist[V];

for (int i = 0; i < V; i++)
visited[i] = false;

for (int i = 0; i < V; i++)
// Initialize distances to all vertices as infinite and distance

// to source as 0
for (int i = 0; i < V; i++)
dist[i] = INF;
dist[s] = 0;
// Process vertices in topological order

{
// Get the next vertex from topological order
int u = Stack.top();
Stack.pop();
// Update distances of all adjacent vertices

list<AdjListNode>::iterator i;
if (dist[u] != INF)
{
for (i = adj[u].begin(); i != adj[u].end(); ++i)
if (dist[i->getV()] > dist[u] + i->getWeight())
dist[i->getV()] = dist[u] + i->getWeight();
}
}
// Print the calculated shortest distances

for (int i = 0; i < V; i++)
(dist[i] == INF)? cout << "INF ": cout << dist[i] << " ";
}

int main()
{
// Create a graph given in the above diagram. Here vertex numbers are
// Create a graph given in the above diagram. Here vertex numbers are
// 0, 1, 2, 3, 4, 5 with following mappings:
// 0=r, 1=s, 2=t, 3=x, 4=y, 5=z
Graph g(6);
g.addEdge(0, 1, 5);
g.addEdge(0, 2, 3);
g.addEdge(1, 3, 6);
g.addEdge(1, 2, 2);
g.addEdge(2, 4, 4);
g.addEdge(2, 5, 2);
g.addEdge(2, 3, 7);
g.addEdge(3, 4, -1);
g.addEdge(4, 5, -2);
int s = 1;
cout << "Following are shortest distances from source " << s <<" \n";
g.shortestPath(s);
return 0;
}

Output:

Following are shortest distances from source 1
INF 0 2 6 5 3

Time Complexity: Time complexity of topological sorting is O(V+E). After finding topological order, the
algorithm process all vertices and for every vertex, it runs a loop for all adjacent vertices. Total adjacent
vertices in a graph is O(E). So the inner loop runs O(V+E) times. Therefore, overall time complexity of this
algorithm is O(V+E).
References:
http://www.utdallas.edu/~sizheng/CS4349.d/l-notes.d/L17.pdf
discussed above
Tree Isomorphism Problem
Write a function to detect if two trees are isomorphic. Two trees are called isomorphic if one of them can be
obtained from other by a series of flips, i.e. by swapping left and right children of a number of nodes. Any
number of nodes at any level can have their children swapped. Two empty trees are isomorphic.
For example, following two trees are isomorphic with following sub-trees flipped: 2 and 3, NULL and 6, 7
and 8.
We simultaneously traverse both trees. Let the current internal nodes of two trees being traversed be n1 and
n2 respectively. There are following two conditions for subtrees rooted with n1 and n2 to be isomorphic.
1) Data of n1 and n2 is same.
2) One of the following two is true for children of n1 and n2
……a) Left child of n1 is isomorphic to left child of n2 and right child of n1 is isomorphic to right child of n2.
……b) Left child of n1 is isomorphic to right child of n2 and right child of n1 is isomorphic to left child of n2.
// A C++ program to check if two given trees are isomorphic

#include <iostream>
/* A binary tree node has data, pointer to left and right children */
struct node
{
int data;
struct node* left;
struct node* right;
};
/* Given a binary tree, print its nodes in reverse level order */

bool isIsomorphic(node* n1, node *n2)
{
// Both roots are NULL, trees isomorphic by definition
if (n1 == NULL && n2 == NULL)
return true;
// Exactly one of the n1 and n2 is NULL, trees not isomorphic

if (n1 == NULL || n2 == NULL)
return false;
if (n1->data != n2->data)
return false;
// There are two possible cases for n1 and n2 to be isomorphic

// Case 1: The subtrees rooted at these nodes have NOT been "Flipped".
// Both of these subtrees have to be isomorphic, hence the &&
// Case 2: The subtrees rooted at these nodes have been "Flipped"
return
(isIsomorphic(n1->left,n2->left) && isIsomorphic(n1->right,n2->right))||
(isIsomorphic(n1->left,n2->right) && isIsomorphic(n1->right,n2->left));
}

{
temp->data = data;
temp->left = NULL;
temp->right = NULL;
return (temp);
}

int main()
{
// Let us create trees shown in above diagram
struct node *n1 = newNode(1);
n1->left = newNode(2);
n1->right = newNode(3);
n1->left->left = newNode(4);
n1->left->right = newNode(5);
n1->right->left = newNode(6);
n1->left->right->left = newNode(7);
n1->left->right->right = newNode(8);
struct node *n2 = newNode(1);

n2->left = newNode(3);
n2->right = newNode(2);
n2->right->left = newNode(4);
n2->right->right = newNode(5);
n2->left->right = newNode(6);
n2->right->right->left = newNode(8);
n2->right->right->right = newNode(7);
if (isIsomorphic(n1, n2) == true)

cout << "Yes";
else
cout << "No";
return 0;
}

Output:

Yes

Time Complexity: The above solution does a traversal of both trees. So time complexity is O(m + n) where
m and n are number of nodes in given trees.
This article is contributed by Ciphe. Please write comments if you find anything incorrect, or you want to
Geeks.
Strongly Connected Components
A directed graph is strongly connected if there is a path between all pairs of vertices. A strongly connected
component (SCC) of a directed graph is a maximal strongly connected subgraph. For example, there are 3
SCCs in the following graph.
We can find all strongly connected components in O(V+E) time using Kosaraju’s algorithm. Following is
detailed Kosaraju’s algorithm.
1) Create an empty stack ‘S’ and do DFS traversal of a graph. In DFS traversal, after calling recursive DFS for
adjacent vertices of a vertex, push the vertex to stack.
2) Reverse directions of all arcs to obtain the transpose graph.
3) One by one pop a vertex from S while S is not empty. Let the popped vertex be ‘v’. Take v as source and do
DFS (call DFSUtil(v)). The DFS starting from v prints strongly connected component of v.
How does this work?

The above algorithm is DFS based. It does DFS two times. DFS of a graph produces a single tree if all vertices
are reachable from the DFS starting point. Otherwise DFS produces a forest. So DFS of a graph with only one
SCC always produces a tree. The important point to note is DFS may produce a tree or a forest when there
are more than one SCCs depending upon the chosen starting point. For example, in the above diagram, if we
start DFS from vertices 0 or 1 or 2, we get a tree as output. And if we start from 3 or 4, we get a forest. To find
and print all SCCs, we would want to start DFS from vertex 4 (which is a sink vertex), then move to 3 which
is sink in the remaining set (set excluding 4) and finally any of the remaining vertices (0, 1, 2). So how do we
find this sequence of picking vertices as starting points of DFS? Unfortunately, there is no direct way for
getting this sequence. However, if we do a DFS of graph and store vertices according to their finish times, we
make sure that the finish time of a vertex that connects to other SCCs (other that its own SCC), will always be
greater than finish time of vertices in the other SCC (See this for proof). For example, in DFS of above
example graph, finish time of 0 is always greater than 3 and 4 (irrespective of the sequence of vertices
considered for DFS). And finish time of 3 is always greater than 4. DFS doesn’t guarantee about other
vertices, for example finish times of 1 and 2 may be smaller or greater than 3 and 4 depending upon the
sequence of vertices considered for DFS. So to use this property, we do DFS traversal of complete graph and
push every finished vertex to a stack. In stack, 3 always appears after 4, and 0 appear after both 3 and 4.
In the next step, we reverse the graph. Consider the graph of SCCs. In the reversed graph, the edges that
connect two components are reversed. So the SCC {0, 1, 2} becomes sink and the SCC {4} becomes source. As
discussed above, in stack, we always have 0 before 3 and 4. So if we do a DFS of the reversed graph using
sequence of vertices in stack, we process vertices from sink to source. That is what we wanted to achieve and
that is all needed to print SCCs one by one.
Following is C++ implementation of Kosaraju’s algorithm.
// Implementation of Kosaraju's algorithm to print all SCCs

#include <iostream>
#include <list>
#include <stack>
class Graph
{
list<int> *adj; // An array of adjacency lists
// Fills Stack with vertices (in increasing order of finishing times)

// The top element of stack has the maximum finishing time
void fillOrder(int v, bool visited[], stack<int> &Stack);
// A recursive function to print DFS starting from v

void DFSUtil(int v, bool visited[]);
public:
Graph(int V);
// The main function that finds and prints strongly connected components
void printSCCs();
// Function that returns reverse (or transpose) of this graph

Graph getTranspose();
};
Graph::Graph(int V)
{
this->V = V;
}

{
visited[v] = true;
cout << v << " ";

if (!visited[*i])
}
Graph Graph::getTranspose()
{
Graph g(V);
for (int v = 0; v < V; v++)
{
{
g.adj[*i].push_back(v);
}
}
return g;
}

{
}
void Graph::fillOrder(int v, bool visited[], stack<int> &Stack)

{
visited[v] = true;

if(!visited[*i])
fillOrder(*i, visited, Stack);
// All vertices reachable from v are processed by now, push v to Stack

Stack.push(v);
}
// The main function that finds and prints all strongly connected components
void Graph::printSCCs()
{
stack<int> Stack;
// Mark all the vertices as not visited (For first DFS)

for(int i = 0; i < V; i++)
visited[i] = false;
// Fill vertices in stack according to their finishing times

for(int i = 0; i < V; i++)
if(visited[i] == false)
fillOrder(i, visited, Stack);
// Create a reversed graph

Graph gr = getTranspose();
// Mark all the vertices as not visited (For second DFS)

for(int i = 0; i < V; i++)
visited[i] = false;
// Now process all vertices in order defined by Stack

{
// Pop a vertex from stack
int v = Stack.top();
int v = Stack.top();
Stack.pop();
// Print Strongly connected component of the popped vertex

if (visited[v] == false)
{
gr.DFSUtil(v, visited);
cout << endl;
}
}
}

int main()
{
Graph g(5);
g.addEdge(1, 0);
g.addEdge(0, 2);
g.addEdge(2, 1);
g.addEdge(0, 3);
g.addEdge(3, 4);
cout << "Following are strongly connected components in given graph \n";
g.printSCCs();
return 0;
}

Output:

Following are strongly connected components in given graph
0 1 2
3
4

Time Complexity: The above algorithm calls DFS, fins reverse of the graph and again calls DFS. DFS takes
O(V+E) for a graph represented using adjacency list. Reversing a graph also takes O(V+E) time. For
reversing the graph, we simple traverse all adjacency lists.
The above algorithm is asymptotically best algorithm, but there are other algorithms like Tarjan’s algorithm
and path-based which have same time complexity but find SCCs using single DFS. The Tarjan’s algorithm is
discussed in the following post.
Tarjan’s Algorithm to find Strongly Connected Components
Applications:
SCC algorithms can be used as a first step in many graph algorithms that work only on strongly connected
graph.
In social networks, a group of people are generally strongly connected (For example, students of a class or
any other common place). Many people in these groups generally like some common pages or play common
games. The SCC algorithms can be used to find such groups and suggest the commonly liked pages or games
to the people in the group who have not yet liked commonly liked a page or played a game.
References:
http://en.wikipedia.org/wiki/Kosaraju%27s_algorithm
https://www.youtube.com/watch?v=PZQ0Pdk15RA
You may also like to see Tarjan’s Algorithm to find Strongly Connected Components.
discussed above
Find a peak element
Given an array of integers. Find a peak element in it. An array element is peak if it is NOT smaller than its
neighbors. For corner elements, we need to consider only one neighbor. For example, for input array {5, 10,
20, 15}, 20 is the only peak element. For input array {10, 20, 15, 2, 23, 90, 67}, there are two peak elements:
20 and 90. Note that we need to return any one peak element.
Following corner cases give better idea about the problem.

1) If input array is sorted in strictly increasing order, the last element is always a peak element. For example,
50 is peak element in {10, 20, 30, 40, 50}.
2) If input array is sorted in strictly decreasing order, the first element is always a peak element. 100 is the
peak element in {100, 80, 60, 50, 20}.
3) If all elements of input array are same, every element is a peak element.
It is clear from above examples that there is always a peak element in input array in any input array.
A simple solution is to do a linear scan of array and as soon as we find a peak element, we return it. The
worst case time complexity of this method would be O(n).
Can we find a peak element in worst time complexity better than O(n)?
We can use Divide and Conquer to find a peak in O(Logn) time. The idea is Binary Search based, we compare
middle element with its neighbors. If middle element is greater than both of its neighbors, then we return it.
If the middle element is smaller than the its left neighbor, then there is always a peak in left half (Why? take
few examples). If the middle element is smaller than the its right neighbor, then there is always a peak in
right half (due to same reason as left half). Following is C implementation of this approach.

// A divide and conquer solution to find a peak element element

#include <stdio.h>
// A binary search based function that returns index of a peak element

int findPeakUtil(int arr[], int low, int high, int n)
{
// Find index of middle element
int mid = low + (high - low)/2; /* (low + high)/2 */
// Compare middle element with its neighbours (if neighbours exist)

if ((mid == 0 || arr[mid-1] <= arr[mid]) &&
(mid == n-1 || arr[mid+1] <= arr[mid]))
return mid;
// If middle element is not peak and its left neighbor is greater than it
// then left half must have a peak element
else if (mid > 0 && arr[mid-1] > arr[mid])
return findPeakUtil(arr, low, (mid -1), n);
// If middle element is not peak and its right neighbor is greater than it
// then right half must have a peak element
else return findPeakUtil(arr, (mid + 1), high, n);
}
// A wrapper over recursive function findPeakUtil()

int findPeak(int arr[], int n)
{
return findPeakUtil(arr, 0, n-1, n);
}

int main()
{
int arr[] = {1, 3, 20, 4, 1, 0};
printf("Index of a peak point is %d", findPeak(arr, n));
return 0;
}

Output:

Index of a peak point is 2

Time Complexity: O(Logn) where n is number of elements in input array.
Exercise:
Consider the following modified definition of peak element. An array element is peak if it is greater than its
neighbors. Note that an array may not contain a peak element with this modified definition.
References:
http://courses.csail.mit.edu/6.006/spring11/lectures/lec02.pdf
http://www.youtube.com/watch?v=HtSuA80QTyo
discussed above.
Remove “b” and “ac” from a given string
Given a string, eliminate all “b” and “ac” in the string, you have to replace them in-place, and you are only
allowed to iterate over the string once. (Source Google Interview Question)
Examples:
acbac ==> ""

aaac ==> aa
ababac ==> aa
bbbbd ==> d

The two conditions are:

1. Filtering of all ‘b’ and ‘ac’ should be in single pass
2. No extra space allowed.
The approach is to use two index variables i and j. We move forward in string using ‘i’ and add characters
using index j except ‘b’ and ‘ac’. The trick here is how to track ‘a’ before ‘c’. An interesting approach is to use
a two state machine. The state is maintained to TWO when previous character is ‘a’, otherwise state is ONE.
1) If state is ONE, then do NOT copy the current character to output if one of the following conditions is true
…a) Current character is ‘b’ (We need to remove ‘b’)
…b) Current character is ‘a’ (Next character may be ‘c’)
2) If state is TWO and current character is not ‘c’, we first need to make sure that we copy the previous
character ‘a’. Then we check the current character, if current character is not ‘b’ and not ‘a’, then we copy it to
output.
// A C++ program to remove "b" and 'ac' from input string

#include <iostream>
#define ONE 1
#define TWO 2
// The main function that removes occurences of "a" and "bc" in input string
void stringFilter(char *str)
{
// state is initially ONE (The previous character is not a)
int state = ONE;
// i and j are index variables, i is used to read next character of input

// string, j is used for indexes of output string (modified input string)
int j = 0;
// Process all characters of input string one by one

for (int i = 0; str[i] != '\0'; i++)
{
/* If state is ONE, then do NOT copy the current character to output if
one of the following conditions is true
...a) Current character is 'b' (We need to remove 'b')
...b) Current character is 'a' (Next character may be 'c') */
if (state == ONE && str[i] != 'a' && str[i] != 'b')
{
str[j] = str[i];
j++;
}
// If state is TWO and current character is not 'c' (otherwise
// we ignore both previous and current characters)
if (state == TWO && str[i] != 'c')
{
// First copy the previous 'a'
str[j] = 'a';
j++;
// Then copy the current character if it is not 'a' and 'b'

if (str[i] != 'a' && str[i] != 'b')
{
str[j] = str[i];
j++;
}
}
// Change state according to current character

state = (str[i] == 'a')? TWO: ONE;
}
// If last character was 'a', copy it to output

if (state == TWO)
{
str[j] = 'a';
j++;
}
// Set the string terminator

str[j] = '\0';
}

int main()
{
char str1[] = "ad";
stringFilter(str1);
cout << str1 << endl;
char str2[] = "acbac";

stringFilter(str2);
char str3[] = "aaac";

stringFilter(str3);
char str4[] = "react";

stringFilter(str4);
char str5[] = "aa";

stringFilter(str5);
char str6[] = "ababaac";

stringFilter(str6);
return 0;
}

Output:

ad
aa
ret
aa
aaa

An extension of above problem where we don’t want “ac” in output at all:

The above code looks fine and seems to handle all cases, but what if input string is “aacacc”, the above code
produces output as “ac” which looks correct as it removes consecutive occurrences of ‘a’ and ‘c’. What if the
requirement is to not have an “ac” in output string at all. Can we modify the above program to produce
output as empty string for input “aacacc” and produce output as “d” when input is “abcaaccd”? It turns out
that it can also be done with given restrictions. The idea is simple. We need to add following lines inside for
loop of the above program.
if (j>1 && str[j-2] == 'a' && str[j-1] =='c')

j = j-2;

See this for different test cases of modified program.
A Simpler Solution to the Original Problem:
// // A C++ program to remove "b" and 'ac' from input string

void stringFilter(char *str)

{
int i = -1; // previous character

int j = 0; // current character
while (j < n)
{
/* check if current and next character forms ac */
if (j < n-1 && str[j] == 'a' && str[j+1] == 'c')
j += 2;
/* if current character is b */
else if (str[j] == 'b')
j++;
/* if current char is 'c && last char in output

is 'a' so delete both */
else if (i >= 0 && str[j] == 'c' && str[i] == 'a')
i--,j++;
/* else copy curr char to output string */

/* else copy curr char to output string */
else
str[++i] = str[j++];
}
str[++i] = '\0';
}

int main()
{
char str1[] = "ad";
cout << "Input => " << str1 << "\nOutput => ";
stringFilter(str1);
cout << str1 << endl << endl;
char str2[] = "acbac";

stringFilter(str2);
char str3[] = "aaac";

stringFilter(str3);
char str4[] = "react";

stringFilter(str4);
char str5[] = "aa";

stringFilter(str5);
char str6[] = "ababaac";

stringFilter(str6);
char str[] = "abc";

cout << "Input => " << str << "\nOutput => ";
stringFilter(str);
cout << str << endl << endl;
return 0;
}

Output:

Input => ad
Output => ad
Input => acbac

Output =>
Input => aaac

Output => aa
Input => react

Output => ret
Input => aa
Output => aa
Input => ababaac

Output => aaa
Input => abc

Output =>

Thanks to Gaurav Ahirwar for suggesting this simpler solution.
This article is contributed by Varun Jain. Please write comments if you find anything incorrect, or you
Articulation Points (or Cut Vertices) in a Graph
A vertex in an undirected connected graph is an articulation point (or cut vertex) iff removing it (and edges
through it) disconnects the graph. Articulation points represent vulnerabilities in a connected network –
single points whose failure would split the network into 2 or more disconnected components. They are useful
for designing reliable networks.
For a disconnected undirected graph, an articulation point is a vertex removing which increases number of
connected components.
Following are some example graphs with articulation points encircled with red color.
How to find all articulation points in a given graph?

A simple approach is to one by one remove all vertices and see if removal of a vertex causes disconnected
graph. Following are steps of simple approach for connected graph.
1) For every vertex v, do following

…..a) Remove v from graph
..…b) See if the graph remains connected (We can either use BFS or DFS)
…..c) Add v back to the graph
Time complexity of above method is O(V*(V+E)) for a graph represented using adjacency list. Can we do
better?
A O(V+E) algorithm to find all Articulation Points (APs)

The idea is to use DFS (Depth First Search). In DFS, we follow vertices in tree form called DFS tree. In DFS
tree, a vertex u is parent of another vertex v, if v is discovered by u (obviously v is an adjacent of u in graph).
In DFS tree, a vertex u is articulation point if one of the following two conditions is true.
1) u is root of DFS tree and it has at least two children.
2) u is not root of DFS tree and it has a child v such that no vertex in subtree rooted with v has a back edge to
one of the ancestors (in DFS tree) of u.
Following figure shows same points as above with one additional point that a leaf in DFS Tree can never be
an articulation point. (Source Ref 2)
We do DFS traversal of given graph with additional code to find out Articulation Points (APs). In DFS
traversal, we maintain a parent[] array where parent[u] stores parent of vertex u. Among the above
mentioned two cases, the first case is simple to detect. For every vertex, count children. If currently visited
vertex u is root (parent[u] is NIL) and has more than two children, print it.
How to handle second case? The second case is trickier. We maintain an array disc[] to store discovery time
of vertices. For every node u, we need to find out the earliest visited vertex (the vertex with minimum
discovery time) that can be reached from subtree rooted with u. So we maintain an additional array low[]
which is defined as follows.
low[u] = min(disc[u], disc[w])

where w is an ancestor of u and there is a back edge from
some descendant of u to w.

Following is C++ implementation of Tarjan’s algorithm for finding articulation points.
// A C++ program to find articulation points in a given undirected graph

#include<iostream>
#include <list>
#define NIL -1
// A class that represents an undirected graph

class Graph
{
list<int> *adj; // A dynamic array of adjacency lists
void APUtil(int v, bool visited[], int disc[], int low[],
int parent[], bool ap[]);
public:
void AP(); // prints articulation points
};
Graph::Graph(int V)
{
this->V = V;
}
}

{
adj[v].push_back(w);
adj[w].push_back(v); // Note: the graph is undirected
}
// A recursive function that find articulation points using DFS traversal

// u --> The vertex to be visited next
// visited[] --> keeps tract of visited vertices
// disc[] --> Stores discovery times of visited vertices
// parent[] --> Stores parent vertices in DFS tree
// ap[] --> Store articulation points
void Graph::APUtil(int u, bool visited[], int disc[],
int low[], int parent[], bool ap[])
{
// A static variable is used for simplicity, we can avoid use of static
// variable by passing a pointer.
static int time = 0;
// Count of children in DFS Tree

int children = 0;

visited[u] = true;
// Initialize discovery time and low value

disc[u] = low[u] = ++time;
// Go through all vertices aadjacent to this

{
int v = *i; // v is current adjacent of u
// If v is not visited yet, then make it a child of u

// in DFS tree and recur for it
if (!visited[v])
{
children++;
parent[v] = u;
APUtil(v, visited, disc, low, parent, ap);
// Check if the subtree rooted with v has a connection to

// one of the ancestors of u
low[u] = min(low[u], low[v]);
// u is an articulation point in following cases
// (1) u is root of DFS tree and has two or more chilren.

if (parent[u] == NIL && children > 1)
ap[u] = true;
// (2) If u is not root and low value of one of its child is more
// than discovery value of u.
if (parent[u] != NIL && low[v] >= disc[u])
ap[u] = true;
}
// Update low value of u for parent function calls.

else if (v != parent[u])
low[u] = min(low[u], disc[v]);
}
}
// The function to do DFS traversal. It uses recursive function APUtil()

void Graph::AP()
{
int *disc = new int[V];
int *low = new int[V];
int *parent = new int[V];
bool *ap = new bool[V]; // To store articulation points
// Initialize parent and visited, and ap(articulation point) arrays

for (int i = 0; i < V; i++)
{
parent[i] = NIL;
visited[i] = false;
ap[i] = false;
}
// Call the recursive helper function to find articulation points

// in DFS tree rooted with vertex 'i'
for (int i = 0; i < V; i++)
APUtil(i, visited, disc, low, parent, ap);
// Now ap[] contains articulation points, print them

for (int i = 0; i < V; i++)
if (ap[i] == true)
cout << i << " ";
}

int main()
{
// Create graphs given in above diagrams
cout << "\nArticulation points in first graph \n";
Graph g1(5);
g1.addEdge(1, 0);
g1.addEdge(0, 2);
g1.addEdge(2, 1);
g1.addEdge(0, 3);
g1.addEdge(3, 4);
g1.AP();
cout << "\nArticulation points in second graph \n";

Graph g2(4);
g2.addEdge(0, 1);
g2.addEdge(1, 2);
g2.addEdge(2, 3);
g2.AP();
cout << "\nArticulation points in third graph \n";

Graph g3(7);
g3.addEdge(0, 1);
g3.addEdge(1, 2);
g3.addEdge(2, 0);
g3.addEdge(1, 3);
g3.addEdge(1, 4);
g3.addEdge(1, 6);
g3.addEdge(3, 5);
g3.addEdge(4, 5);
g3.AP();
return 0;
}

Output:
Articulation points in first graph

0 3
Articulation points in second graph
1 2
Articulation points in third graph
1

Time Complexity: The above function is simple DFS with additional arrays. So time complexity is same as
DFS which is O(V+E) for adjacency list representation of graph.
References:
https://www.cs.washington.edu/education/courses/421/04su/slides/artic.pdf
http://www.slideshare.net/TraianRebedea/algorithm-design-and-complexity-course-8
http://faculty.simpson.edu/lydia.sinapova/www/cmsc250/LN250_Weiss/L25-Connectivity.htm
discussed above.
Bridges in a graph
An edge in an undirected connected graph is a bridge iff removing it disconnects the graph. For a
disconnected undirected graph, definition is similar, a bridge is an edge removing which increases number of
connected components.
Like Articulation Points,bridges represent vulnerabilities in a connected network and are useful for
designing reliable networks. For example, in a wired computer network, an articulation point indicates the
critical computers and a bridge indicates the critical wires or connections.
Following are some example graphs with bridges highlighted with red color.
How to find all bridges in a given graph?

A simple approach is to one by one remove all edges and see if removal of a edge causes disconnected graph.
Following are steps of simple approach for connected graph.
1) For every edge (u, v), do following

…..a) Remove (u, v) from graph
..…b) See if the graph remains connected (We can either use BFS or DFS)
…..c) Add (u, v) back to the graph.
Time complexity of above method is O(E*(V+E)) for a graph represented using adjacency list. Can we do
better?
A O(V+E) algorithm to find all Bridges

The idea is similar to O(V+E) algorithm for Articulation Points. We do DFS traversal of the given graph. In
DFS tree an edge (u, v) (u is parent of v in DFS tree) is bridge if there does not exit any other alternative to
reach u or an ancestor of u from subtree rooted with v. As discussed in the previous post, the value low[v]
indicates earliest visited vertex reachable from subtree rooted with v. The condition for an edge (u, v) to be a
bridge is, “low[v] > disc[u]”.
Following is C++ implementation of above approach.
// A C++ program to find bridges in a given undirected graph

// A C++ program to find bridges in a given undirected graph
#include<iostream>
#include <list>
#define NIL -1

class Graph
{
void bridgeUtil(int v, bool visited[], int disc[], int low[], int parent[]);
public:
void bridge(); // prints all bridges
};
Graph::Graph(int V)
{
this->V = V;
}

{
}
// A recursive function that finds and prints bridges using DFS traversal
void Graph::bridgeUtil(int u, bool visited[], int disc[],
int low[], int parent[])
{

visited[u] = true;


{
// If v is not visited yet, then recur for it

if (!visited[v])
{
parent[v] = u;
bridgeUtil(v, visited, disc, low, parent);

// If the lowest vertex reachable from subtree under v is

// If the lowest vertex reachable from subtree under v is
// below u in DFS tree, then u-v is a bridge
if (low[v] > disc[u])
cout << u <<" " << v << endl;
}

}
}
// DFS based function to find all bridges. It uses recursive function bridgeUtil()
void Graph::bridge()
{
// Initialize parent and visited arrays

for (int i = 0; i < V; i++)
{
parent[i] = NIL;
visited[i] = false;
}
// Call the recursive helper function to find Bridges

// in DFS tree rooted with vertex 'i'
for (int i = 0; i < V; i++)
bridgeUtil(i, visited, disc, low, parent);
}

int main()
{
cout << "\nBridges in first graph \n";
Graph g1(5);
g1.addEdge(1, 0);
g1.addEdge(0, 2);
g1.addEdge(2, 1);
g1.addEdge(0, 3);
g1.addEdge(3, 4);
g1.bridge();
cout << "\nBridges in second graph \n";

Graph g2(4);
g2.addEdge(0, 1);
g2.addEdge(1, 2);
g2.addEdge(2, 3);
g2.bridge();
cout << "\nBridges in third graph \n";

Graph g3(7);
g3.addEdge(0, 1);
g3.addEdge(1, 2);
g3.addEdge(2, 0);
g3.addEdge(1, 3);
g3.addEdge(1, 4);
g3.addEdge(1, 6);
g3.addEdge(3, 5);
g3.addEdge(4, 5);
g3.addEdge(4, 5);
g3.bridge();
return 0;
}

Output:

Bridges in first graph
3 4
0 3
Bridges in second graph

2 3
1 2
0 1
Bridges in third graph

1 6

Time Complexity: The above function is simple DFS with additional arrays. So time complexity is same as
DFS which is O(V+E) for adjacency list representation of graph.
References:
https://www.cs.washington.edu/education/courses/421/04su/slides/artic.pdf
http://www.slideshare.net/TraianRebedea/algorithm-design-and-complexity-course-8
http://faculty.simpson.edu/lydia.sinapova/www/cmsc250/LN250_Weiss/L25-Connectivity.htm
http://www.youtube.com/watch?v=bmyyxNyZKzI
discussed above.
Biconnected graph
An undirected graph is called Biconnected if there are two vertex-disjoint paths between any two vertices. In
a Biconnected Graph, there is a simple cycle through any two vertices.
By convention, two nodes connected by an edge form a biconnected graph, but this does not verify the above
properties. For a graph with more than two vertices, the above properties must be there for it to be
Biconnected.
Following are some examples.
See this for more examples.
How to find if a given graph is Biconnected or not?

A connected graph is Biconnected if it is connected and doesn’t have any Articulation Point. We mainly
need to check two things in a graph.
1) The graph is connected.
2) There is not articulation point in graph.
We start from any vertex and do DFS traversal. In DFS traversal, we check if there is any articulation point.
If we don’t find any articulation point, then the graph is Biconnected. Finally, we need to check whether all
vertices were reachable in DFS or not. If all vertices were not reachable, then the graph is not even
connected.
// A C++ program to find articulation points in a given undirected graph

#include<iostream>
#include <list>
#define NIL -1

class Graph
{
bool isBCUtil(int v, bool visited[], int disc[], int low[],int parent[]);
public:
bool isBC(); // returns true if graph is Biconnected, else returns false
};
Graph::Graph(int V)
{
this->V = V;
}

{
}
// A recursive function that returns true if there is an articulation

// point in given graph, otherwise returns false.
// This function is almost same as isAPUtil() here ( http://goo.gl/Me9Fw )
bool Graph::isBCUtil(int u, bool visited[], int disc[],int low[],int parent[])
{
// Count of children in DFS Tree

int children = 0;

visited[u] = true;


{
{
// If v is not visited yet, then make it a child of u

// in DFS tree and recur for it
if (!visited[v])
{
children++;
parent[v] = u;
// check if subgraph rooted with v has an articulation point

if (isBCUtil(v, visited, disc, low, parent))
return true;

// u is an articulation point in following cases
// (1) u is root of DFS tree and has two or more chilren.

if (parent[u] == NIL && children > 1)
return true;
// (2) If u is not root and low value of one of its child is

// more than discovery value of u.
if (parent[u] != NIL && low[v] >= disc[u])
return true;
}

}
return false;
}
// The main function that returns true if graph is Biconnected, otherwise false.
// It uses recursive function isBCUtil()
bool Graph::isBC()
{
// Initialize parent and visited, and ap(articulation point) arrays

for (int i = 0; i < V; i++)
{
parent[i] = NIL;
visited[i] = false;
}
// Call the recursive helper function to find if there is an articulation

// point in given graph. We do DFS traversal starring from vertex 0
if (isBCUtil(0, visited, disc, low, parent) == true)
return false;
// Now check whether the given graph is connected or not. An undirected

// graph is connected if all vertices are reachable from any starting
// point (we have taken 0 as starting point)
for (int i = 0; i < V; i++)
return false;
return false;
return true;
}

int main()
{
Graph g1(2);
g1.addEdge(0, 1);
g1.isBC()? cout << "Yes\n" : cout << "No\n";
Graph g2(5);
g2.addEdge(1, 0);
g2.addEdge(0, 2);
g2.addEdge(2, 1);
g2.addEdge(0, 3);
g2.addEdge(3, 4);
g2.addEdge(2, 4);
Graph g3(3);
g3.addEdge(0, 1);
g3.addEdge(1, 2);
Graph g4(5);
g4.addEdge(1, 0);
g4.addEdge(0, 2);
g4.addEdge(2, 1);
g4.addEdge(0, 3);
g4.addEdge(3, 4);
Graph g5(3);
g5.addEdge(0, 1);
g5.addEdge(1, 2);
g5.addEdge(2, 0);
return 0;
}

Time Complexity: The above function is a simple DFS with additional arrays. So time complexity is same
as DFS which is O(V+E) for adjacency list representation of graph.
References:
http://www.cs.purdue.edu/homes/ayg/CS251/slides/chap9d.pdf
discussed above.
Dynamic Programming | Set 30 (Dice Throw)
Given n dice each with m faces, numbered from 1 to m, find the number of ways to get sum X. X is the
summation of values on each face when all the dice are thrown.
The Naive approach is to find all the possible combinations of values from n dice and keep on counting
the results that sum to X.
This problem can be efficiently solved using Dynamic Programming (DP).

Let the function to find X from n dice is: Sum(m, n, X)
The function can be represented as:
Sum(m, n, X) = Finding Sum (X - 1) from (n - 1) dice plus 1 from nth dice
+ Finding Sum (X - 2) from (n - 1) dice plus 2 from nth dice
+ Finding Sum (X - 3) from (n - 1) dice plus 3 from nth dice
...................................................
...................................................
...................................................
+ Finding Sum (X - m) from (n - 1) dice plus m from nth dice
So we can recursively write Sum(m, n, x) as following

Sum(m, n, X) = Sum(m, n - 1, X - 1) +
Sum(m, n - 1, X - 2) +
.................... +
Sum(m, n - 1, X - m)

Why DP approach?
The above problem exhibits overlapping subproblems. See the below diagram. Also, see this recursive
implementation. Let there be 3 dice, each with 6 faces and we need to find the number of ways to get sum 8:

Sum(6, 3, 8) = Sum(6, 2, 7) + Sum(6, 2, 6) + Sum(6, 2, 5) +
Sum(6, 2, 4) + Sum(6, 2, 3) + Sum(6, 2, 2)
To evaluate Sum(6, 3, 8), we need to evaluate Sum(6, 2, 7) which can

recursively written as following:
Sum(6, 2, 7) = Sum(6, 1, 6) + Sum(6, 1, 5) + Sum(6, 1, 4) +
Sum(6, 1, 3) + Sum(6, 1, 2) + Sum(6, 1, 1)
We also need to evaluate Sum(6, 2, 6) which can recursively written

as following:
Sum(6, 2, 6) = Sum(6, 1, 5) + Sum(6, 1, 4) + Sum(6, 1, 3) +
Sum(6, 1, 2) + Sum(6, 1, 1)
..............................................
..............................................
Sum(6, 2, 2) = Sum(6, 1, 1)

Please take a closer look at the above recursion. The sub-problems in RED are solved first time and sub-
problems in BLUE are solved again (exhibit overlapping sub-problems). Hence, storing the results of the
solved sub-problems saves time.
Following is C++ implementation of Dynamic Programming approach.

// C++ program to find number of ways to get sum 'x' with 'n'
// dice where every dice has 'm' faces
#include <iostream>
#include <string.h>
// The main function that returns number of ways to get sum 'x'
// with 'n' dice and 'm' with m faces.
int findWays(int m, int n, int x)
{
// Create a table to store results of subproblems. One extra
// row and column are used for simpilicity (Number of dice
// is directly used as row index and sum is directly used
// as column index). The entries in 0th row and 0th column
// are never used.
int table[n + 1][x + 1];
memset(table, 0, sizeof(table)); // Initialize all entries as 0
// Table entries for only one dice

for (int j = 1; j <= m && j <= x; j++)
table[1][j] = 1;
// Fill rest of the entries in table using recursive relation

// i: number of dice, j: sum
for (int i = 2; i <= n; i++)
for (int j = 1; j <= x; j++)
for (int k = 1; k <= m && k < j; k++)
table[i][j] += table[i-1][j-k];
/* Uncomment these lines to see content of table

for (int i = 0; i <= n; i++)
{
for (int j = 0; j <= x; j++)
cout << table[i][j] << " ";
cout << endl;
} */
return table[n][x];
}

int main()
{
cout << findWays(4, 2, 1) << endl;
return 0;
}

Output:

0
2
21
4
6

Time Complexity: O(m * n * x) where m is number of faces, n is number of dice and x is given sum.
We can add following two conditions at the beginning of findWays() to improve performance of program for
extreme cases (x is too high or x is too low)

// When x is so high that sum can not go beyond x even when we
// get maximum value in every dice throw.
if (m*n <= x)
return (m*n == x);

// When x is too low
if (n >= x)
return (n == x);

With above conditions added, time complexity becomes O(1) when x >= m*n or when x Exercise:
Extend the above algorithm to find the probability to get Sum > X.
Expression Evaluation
Evaluate an expression represented by a String. Expression can contain parentheses, you can assume
parentheses are well-matched. For simplicity, you can assume only binary operations allowed are +, -, *, and
/. Arithmetic Expressions can be written in one of three forms:
Infix Notation: Operators are written between the operands they operate on, e.g. 3 + 4 .
Prefix Notation: Operators are written before the operands, e.g + 3 4
Postfix Notation: Operators are written after operands.
Infix Expressions are harder for Computers to evaluate because of the addional work needed to decide
precedence. Infix notation is how expressions are written and recognized by humans and, generally, input to
programs. Given that they are harder to evaluate, they are generally converted to one of the two remaining
forms. A very well known algorithm for converting an infix notation to a postfix notation is Shunting Yard
Algorithm by Edgar Dijkstra. This algorithm takes as input an Infix Expression and produces a queue that
has this expression converted to a postfix notation. Same algorithm can be modified so that it outputs result
of evaluation of expression instead of a queue. Trick is using two stacks instead of one, one for operands and
one for operators. Algorithm was described succinctly on http://www.cis.upenn.edu/ matuszek/cit594-
2002/Assignments/5-expressions.htm, and is re-produced here. (Note that credit for succinctness goes to
author of said page)
1. While there are still tokens to be read in,

1.1 Get the next token.
1.2 If the token is:
1.2.1 A number: push it onto the value stack.
1.2.2 A variable: get its value, and push onto the value stack.
1.2.3 A left parenthesis: push it onto the operator stack.
1.2.4 A right parenthesis:
1 While the thing on top of the operator stack is not a
left parenthesis,
1 Pop the operator from the operator stack.
2 Pop the value stack twice, getting two operands.
3 Apply the operator to the operands, in the correct order.
4 Push the result onto the value stack.
2 Pop the left parenthesis from the operator stack, and discard it.
1.2.5 An operator (call it thisOp):
1 While the operator stack is not empty, and the top thing on the
operator stack has the same or greater precedence as thisOp,
2 Push thisOp onto the operator stack.
2. While the operator stack is not empty,
3. At this point the operator stack should be empty, and the value
stack should have only one value in it, which is the final result.

It should be clear that this algorithm runs in linear time – each number or operator is pushed onto and
popped from Stack only once. Also see http://www2.lawrence.edu/fast/GREGGJ/CMSC270/Infix.html,
http://faculty.cs.niu.edu/~hutchins/csci241/eval.htm.
Following is Java implementation of above algorithm.
/* A Java program to evaluate a given expression where tokens are separated

by space.
Test Cases:
"10 + 2 * 6" ---> 22
"100 * 2 + 12" ---> 212
"100 * ( 2 + 12 )" ---> 1400
"100 * ( 2 + 12 ) / 14" ---> 100
*/
import java.util.Stack;
public class EvaluateString

{
public static int evaluate(String expression)
{
char[] tokens = expression.toCharArray();
// Stack for numbers: 'values'

Stack<Integer> values = new Stack<Integer>();
// Stack for Operators: 'ops'

Stack<Character> ops = new Stack<Character>();
for (int i = 0; i < tokens.length; i++)

{
// Current token is a whitespace, skip it
if (tokens[i] == ' ')
continue;
// Current token is a number, push it to stack for numbers

if (tokens[i] >= '0' && tokens[i] <= '9')
{
StringBuffer sbuf = new StringBuffer();
// There may be more than one digits in number
while (i < tokens.length && tokens[i] >= '0' && tokens[i] <= '9')
sbuf.append(tokens[i++]);
values.push(Integer.parseInt(sbuf.toString()));
}
// Current token is an opening brace, push it to 'ops'

else if (tokens[i] == '(')
ops.push(tokens[i]);
// Closing brace encountered, solve entire brace

else if (tokens[i] == ')')
{
while (ops.peek() != '(')
values.push(applyOp(ops.pop(), values.pop(), values.pop()));
ops.pop();
}
// Current token is an operator.

else if (tokens[i] == '+' || tokens[i] == '-' ||
tokens[i] == '*' || tokens[i] == '/')
{
// While top of 'ops' has same or greater precedence to current
// token, which is an operator. Apply operator on top of 'ops'
// to top two elements in values stack
while (!ops.empty() && hasPrecedence(tokens[i], ops.peek()))
// Push current token to 'ops'.
ops.push(tokens[i]);
}
}
// Entire expression has been parsed at this point, apply remaining

// ops to remaining values
while (!ops.empty())
// Top of 'values' contains result, return it

return values.pop();
}
// Returns true if 'op2' has higher or same precedence as 'op1',

// otherwise returns false.
public static boolean hasPrecedence(char op1, char op2)
{
if (op2 == '(' || op2 == ')')
return false;
if ((op1 == '*' || op1 == '/') && (op2 == '+' || op2 == '-'))
return false;
else
return true;
}
// A utility method to apply an operator 'op' on operands 'a'

// and 'b'. Return the result.
public static int applyOp(char op, int b, int a)
{
switch (op)
{
case '+':
return a + b;
case '-':
return a - b;
case '*':
return a * b;
case '/':
if (b == 0)
throw new
UnsupportedOperationException("Cannot divide by zero");
return a / b;
}
return 0;
}
// Driver method to test above methods

public static void main(String[] args)
{
System.out.println(EvaluateString.evaluate("10 + 2 * 6"));
System.out.println(EvaluateString.evaluate("100 * 2 + 12"));
System.out.println(EvaluateString.evaluate("100 * ( 2 + 12 )"));
System.out.println(EvaluateString.evaluate("100 * ( 2 + 12 ) / 14"));
}
}

Output:

22
212
1400
100

See this for a sample run with more test cases.
This article is compiled by Ciphe. Please write comments if you find anything incorrect, or you want to
share more information about the topic discussed above
Find all possible interpretations of an array of digits
Consider a coding system for alphabets to integers where ‘a’ is represented as 1, ‘b’ as 2, .. ‘z’ as 26. Given an
array of digits (1 to 9) as input, write a function that prints all valid interpretations of input array.
Examples
Input: {1, 1}
Output: ("aa", 'k")
[2 interpretations: aa(1, 1), k(11)]
Input: {1, 2, 1}
Output: ("aba", "au", "la")
[3 interpretations: aba(1,2,1), au(1,21), la(12,1)]
Input: {9, 1, 8}
Output: {"iah", "ir"}
[2 interpretations: iah(9,1,8), ir(9,18)]

Please note we cannot change order of array. That means {1,2,1} cannot become {2,1,1}
On first look it looks like a problem of permutation/combination. But on closer look you will figure out that
this is an interesting tree problem.
The idea here is string can take at-most two paths:
1. Proces single digit
2. Process two digits
That means we can use binary tree here. Processing with single digit will be left child and two digits will be
right child. If value two digits is greater than 26 then our right child will be null as we don’t have alphabet for
greater than 26.
Let’s understand with an example .Array a = {1,2,1}. Below diagram shows that how our tree grows.
“” {1,2,1} Codes used in tree

/ \ "a" --> 1
/ \ "b" --> 2
"a"{2,1} "l"{1} "l" --> 12
/ \ / \
/ \ / \
"ab"{1} "au" "la" null
/ \
/ \
"aba" null

Braces {} contain array still pending for processing. Note that with every level, our array size decreases. If
you will see carefully, it is not hard to find that tree height is always n (array size)
How to print all strings (interpretations)? Output strings are leaf node of tree. i.e for {1,2,1}, output is {aba
au la}.
We can conclude that there are mainly two steps to print all interpretations of given integer array.
Step 1: Create a binary tree with all possible interpretations in leaf nodes.
Step 2: Print all leaf nodes from the binary tree created in step 1.
Following is Java implementation of above algorithm.
// A Java program to print all interpretations of an integer array

import java.util.Arrays;
// A Binary Tree node

class Node {
String dataString;
Node left;
Node right;
Node(String dataString) {
this.dataString = dataString;
//Be default left and right child are null.
}
public String getDataString() {

return dataString;
}
}
public class arrayToAllInterpretations {
// Method to create a binary tree which stores all interpretations

// of arr[] in lead nodes
public static Node createTree(int data, String pString, int[] arr) {
// Invalid input as alphabets maps from 1 to 26

if (data > 26)
return null;
// Parent String + String for this node

String dataToStr = pString + alphabet[data];
Node root = new Node(dataToStr);
// if arr.length is 0 means we are done

if (arr.length != 0) {
data = arr[0];
// new array will be from index 1 to end as we are consuming

// first index with this node
int newArr[] = Arrays.copyOfRange(arr, 1, arr.length);
// left child
root.left = createTree(data, dataToStr, newArr);
// right child will be null if size of array is 0 or 1

if (arr.length > 1) {
data = arr[0] * 10 + arr[1];
// new array will be from index 2 to end as we

// are consuming first two index with this node
newArr = Arrays.copyOfRange(arr, 2, arr.length);
root.right = createTree(data, dataToStr, newArr);

}
}
return root;
}
// To print out leaf nodes

public static void printleaf(Node root) {
if (root == null)
return;
if (root.left == null && root.right == null)

System.out.print(root.getDataString() + " ");

printleaf(root.left);
printleaf(root.right);
}
// The main function that prints all interpretations of array

static void printAllInterpretations(int[] arr) {
// Step 1: Create Tree

Node root = createTree(0, "", arr);
// Step 2: Print Leaf nodes

printleaf(root);
System.out.println(); // Print new line

}
// For simplicity I am taking it as string array. Char Array will save space
private static final String[] alphabet = {"", "a", "b", "c", "d", "e",
"f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r",
"s", "t", "u", "v", "w", "x", "v", "z"};
// Driver method to test above methods

// aacd(1,1,3,4) amd(1,13,4) kcd(11,3,4)

// Note : 1,1,34 is not valid as we don't have values corresponding
// to 34 in alphabet
int[] arr = {1, 1, 3, 4};
printAllInterpretations(arr);
// aaa(1,1,1) ak(1,11) ka(11,1)

int[] arr2 = {1, 1, 1};
printAllInterpretations(arr2);
// bf(2,6) z(26)
int[] arr3 = {2, 6};
// ab(1,2), l(12)
int[] arr4 = {1, 2};
// a(1,0} j(10)
int[] arr5 = {1, 0};
// "" empty string output as array is empty

int[] arr6 = {};
// abba abu ava lba lu

int[] arr7 = {1, 2, 2, 1};
}
}

Output:

aacd amd kcd
aaa ak ka
bf z
ab l
a j

abba abu ava lba lu

Exercise:
1. What is the time complexity of this solution? [Hint : size of tree + finding leaf nodes]
2. Can we store leaf nodes at the time of tree creation so that no need to run loop again for leaf node fetching?
3. How can we reduce extra space?
This article is compiled by Varun Jain. Please write comments if you find anything incorrect, or you want to
Print all possible combinations of r elements in a given array of size n
Given an array of size n, generate and print all possible combinations of r elements in array. For example, if
input array is {1, 2, 3, 4} and r is 2, then output should be {1, 2}, {1, 3}, {1, 4}, {2, 3}, {2, 4} and {3, 4}.
Following are two methods to do this.
Method 1 (Fix Elements and Recur)

We create a temporary array ‘data[]’ which stores all outputs one by one. The idea is to start from first index
(index = 0) in data[], one by one fix elements at this index and recur for remaining indexes. Let the input
array be {1, 2, 3, 4, 5} and r be 3. We first fix 1 at index 0 in data[], then recur for remaining indexes, then we
fix 2 at index 0 and recur. Finally, we fix 3 and recur for remaining indexes. When number of elements in
data[] becomes equal to r (size of a combination), we print data[].
Following diagram shows recursion tree for same input.

// Program to print all combination of size r in an array of size n

#include <stdio.h>
void combinationUtil(int arr[], int data[], int start, int end, int index, int r);
// The main function that prints all combinations of size r

// in arr[] of size n. This function mainly uses combinationUtil()
void printCombination(int arr[], int n, int r)
{
// A temporary array to store all combination one by one
int data[r];
// Print all combination using temprary array 'data[]'

combinationUtil(arr, data, 0, n-1, 0, r);
}
/* arr[] ---> Input Array

data[] ---> Temporary array to store current combination
start & end ---> Staring and Ending indexes in arr[]
index ---> Current index in data[]
r ---> Size of a combination to be printed */
void combinationUtil(int arr[], int data[], int start, int end, int index, int r)
{
// Current combination is ready to be printed, print it
if (index == r)
{
for (int j=0; j<r; j++)
printf("%d ", data[j]);
printf("\n");
return;
}
// replace index with all possible elements. The condition

// "end-i+1 >= r-index" makes sure that including one element
// at index will make a combination with remaining elements
// at remaining positions
for (int i=start; i<=end && end-i+1 >= r-index; i++)
{
data[index] = arr[i];
combinationUtil(arr, data, i+1, end, index+1, r);
}
}

int main()
{
int arr[] = {1, 2, 3, 4, 5};
int r = 3;
printCombination(arr, n, r);
}

Output:

1 2 3
1 2 4
1 2 5
1 3 4
1 3 5
1 4 5
2 3 4
2 3 5
2 4 5
3 4 5

How to handle duplicates?

Note that the above method doesn’t handle duplicates. For example, if input array is {1, 2, 1} and r is 2, then
the program prints {1, 2} and {2, 1} as two different combinations. We can avoid duplicates by adding
following two additional things to above code.
1) Add code to sort the array before calling combinationUtil() in printCombination()
2) Add following lines at the end of for loop in combinationUtil()
// Since the elements are sorted, all occurrences of an element

// must be together
while (arr[i] == arr[i+1])
i++;

See this for an implementation that handles duplicates.
Method 2 (Include and Exclude every element)

Like the above method, We create a temporary array data[]. The idea here is similar to Subset Sum Problem.
We one by one consider every element of input array, and recur for two cases:
1) The element is included in current combination (We put the element in data[] and increment next
available index in data[])
2) The element is excluded in current combination (We do not put the element and do not change index)
When number of elements in data[] become equal to r (size of a combination), we print it.
This method is mainly based on Pascal’s Identity, i.e. n cr = n-1 cr + n-1 cr-1
Following is C++ implementation of method 2.

// Program to print all combination of size r in an array of size n

#include<stdio.h>
void combinationUtil(int arr[],int n,int r,int index,int data[],int i);
// The main function that prints all combinations of size r

// in arr[] of size n. This function mainly uses combinationUtil()
void printCombination(int arr[], int n, int r)
{
// A temporary array to store all combination one by one
int data[r];
// Print all combination using temprary array 'data[]'

combinationUtil(arr, n, r, 0, data, 0);
}
/* arr[] ---> Input Array

n ---> Size of input array
r ---> Size of a combination to be printed
index ---> Current index in data[]
data[] ---> Temporary array to store current combination
i ---> index of current element in arr[] */
void combinationUtil(int arr[], int n, int r, int index, int data[], int i)
{
// Current cobination is ready, print it
if (index == r)
{
for (int j=0; j<r; j++)
printf("%d ",data[j]);
printf("\n");
return;
}
// When no more elements are there to put in data[]

if (i >= n)
return;
// current is included, put next at next location

data[index] = arr[i];
combinationUtil(arr, n, r, index+1, data, i+1);
// current is excluded, replace it with next (Note that

// i+1 is passed, but index is not changed)
combinationUtil(arr, n, r, index, data, i+1);
}

int main()
{
int arr[] = {1, 2, 3, 4, 5};
int r = 3;
printCombination(arr, n, r);
return 0;
}

Output:

1 2 3
1 2 4
1 2 5
1 3 4
1 3 5
1 4 5
2 3 4
2 3 5
2 4 5
3 4 5

How to handle duplicates in method 2?

Like method 1, we can following two things to handle duplicates.
1) Add code to sort the array before calling combinationUtil() in printCombination()
2) Add following lines between two recursive calls of combinationUtil() in combinationUtil()
// Since the elements are sorted, all occurrences of an element

// must be together
while (arr[i] == arr[i+1])
i++;

See this for an implementation that handles duplicates.
This article is contributed by Bateesh. Please write comments if you find anything incorrect, or you want to
Given an array of of size n and a number k, find all elements that appear
more than n/k times
Given an array of size n, find all elements in array that appear more than n/k times. For example, if the input
arrays is {3, 1, 2, 2, 1, 2, 3, 3} and k is 4, then the output should be [2, 3]. Note that size of array is 8 (or n =
8), so we need to find all elements that appear more than 2 (or 8/4) times. There are two elements that
appear more than two times, 2 and 3.
A simple method is to pick all elements one by one. For every picked element, count its occurrences by
traversing the array, if count becomes more than n/k, then print the element. Time Complexity of this
method would be O(n2).
A better solution is to use sorting. First, sort all elements using a O(nLogn) algorithm. Once the array is
sorted, we can find all required elements in a linear scan of array. So overall time complexity of this method
is O(nLogn) + O(n) which is O(nLogn).
Following is an interesting O(nk) solution:

We can solve the above problem in O(nk) time using O(k-1) extra space. Note that there can never be more
than k-1 elements in output (Why?). There are mainly three steps in this algorithm.
1) Create a temporary array of size (k-1) to store elements and their counts (The output elements are going to
be among these k-1 elements). Following is structure of temporary array elements.
struct eleCount {
int element;
int count;
};
struct eleCount temp[];

This step takes O(k) time.
2) Traverse through the input array and update temp[] (add/remove an element or increase/decrease
count) for every traversed element. The array temp[] stores potential (k-1) candidates at every step. This step
takes O(nk) time.
3) Iterate through final (k-1) potential candidates (stored in temp[]). or every element, check if it actually
has count more than n/k. This step takes O(nk) time.
The main step is step 2, how to maintain (k-1) potential candidates at every point? The steps used in step 2
are like famous game: Tetris. We treat each number as a piece in Tetris, which falls down in our temporary
array temp[]. Our task is to try to keep the same number stacked on the same column (count in temporary
array is incremented).

Consider k = 4, n = 9
Given array: 3 1 2 2 2 1 4 3 3
i = 0
3 _ _
temp[] has one element, 3 with count 1
i = 1
3 1 _
temp[] has two elements, 3 and 1 with
counts 1 and 1 respectively
i = 2
3 1 2
temp[] has three elements, 3, 1 and 2 with
counts as 1, 1 and 1 respectively.
i = 3
- - 2
3 1 2
i = 4
- - 2
- - 2
3 1 2
i = 5
- - 2
- 1 2
3 1 2

Now the question arises, what to do when temp[] is full and we see a new element – we remove the bottom
row from stacks of elements, i.e., we decrease count of every element by 1 in temp[]. We ignore the current
element.

i = 6
- - 2
- 1 2
temp[] has two elements, 1 and 2 with
counts as 1 and 2 respectively.
i = 7
- 2
3 1 2
i = 8
3 - 2
3 1 2

Finally, we have at most k-1 numbers in temp[]. The elements in temp are {3, 1, 2}. Note that the counts in
temp[] are useless now, the counts were needed only in step 2. Now we need to check whether the actual
counts of elements in temp[] are more than n/k (9/4) or not. The elements 3 and 2 have counts more than
9/4. So we print 3 and 2.
Note that the algorithm doesn’t miss any output element. There can be two possibilities, many occurrences
are together or spread across the array. If occurrences are together, then count will be high and won’t
become 0. If occurrences are spread, then the element would come again in temp[]. Following is C++
implementation of above algorithm.
// A C++ program to print elements with count more than n/k

#include<iostream>
// A structure to store an element and its current count

struct eleCount
{
int e; // Element
int c; // Count
};
// Prints elements with more than n/k occurrences in arr[] of

// size n. If there are no such elements, then it prints nothing.
void moreThanNdK(int arr[], int n, int k)
{
// k must be greater than 1 to get some output
if (k < 2)
return;
/* Step 1: Create a temporary array (contains element

and count) of size k-1. Initialize count of all
elements as 0 */
struct eleCount temp[k-1];
for (int i=0; i<k-1; i++)
temp[i].c = 0;
/* Step 2: Process all elements of input array */

for (int i = 0; i < n; i++)
{
{
int j;
/* If arr[i] is already present in

the element count array, then increment its count */
for (j=0; j<k-1; j++)
{
if (temp[j].e == arr[i])
{
temp[j].c += 1;
break;
}
}
/* If arr[i] is not present in temp[] */

if (j == k-1)
{
int l;

/* If there is position available in temp[], then place
arr[i] in the first available position and set count as 1*/
for (l=0; l<k-1; l++)
{
if (temp[l].c == 0)
{
temp[l].e = arr[i];
temp[l].c = 1;
break;
}
}
/* If all the position in the temp[] are filled, then

decrease count of every element by 1 */
if (l == k-1)
for (l=0; l<k; l++)
temp[l].c -= 1;
}
}
/*Step 3: Check actual counts of potential candidates in temp[]*/

{
// Calculate actual count of elements
int ac = 0; // actual count
for (int j=0; j<n; j++)
if (arr[j] == temp[i].e)
ac++;
// If actual count is more than n/k, then print it

if (ac > n/k)
cout << "Number:" << temp[i].e
<< " Count:" << ac << endl;
}
}

int main()
{
cout << "First Test\n";
int arr1[] = {4, 5, 6, 7, 8, 4, 4};
int size = sizeof(arr1)/sizeof(arr1[0]);
int k = 3;
moreThanNdK(arr1, size, k);
cout << "\nSecond Test\n";
int arr2[] = {4, 2, 2, 7};
size = sizeof(arr2)/sizeof(arr2[0]);
k = 3;
cout << "\nThird Test\n";

int arr3[] = {2, 7, 2};
k = 2;
cout << "\nFourth Test\n";

int arr4[] = {2, 3, 3, 2};
k = 3;
return 0;
}

Output:
First Test
Number:4 Count:3
Second Test
Number:2 Count:2
Third Test
Number:2 Count:2
Fourth Test
Number:2 Count:2
Number:3 Count:2

Time Complexity: O(nk)

Generally asked variations of this problem are, find all elements that appear n/3 times or n/4 times in O(n)
time complexity and O(1) extra space.
Hashing can also be an efficient solution. With a good hash function, we can solve the above problem in
O(n) time on average. Extra space required hashing would be higher than O(k). Also, hashing cannot be used
to solve above variations with O(1) extra space.
Exercise:
The above problem can be solved in O(nLogk) time with the help of more appropriate data structures than
array for auxiliary storage of k-1 elements. Suggest a O(nLogk) approach.
This article is contributed by Kushagra Jaiswal. Please write comments if you find anything incorrect, or
you want to share more information about the topic discussed above
Dynamic Programming | Set 31 (Optimal Strategy for a Game)
Problem statement: Consider a row of n coins of values v1 . . . vn, where n is even. We play a game against an
opponent by alternating turns. In each turn, a player selects either the first or last coin from the row,
removes it from the row permanently, and receives the value of the coin. Determine the maximum possible
amount of money we can definitely win if we move first.
Note: The opponent is as clever as the user.
Let us understand the problem with few examples:
1. 5, 3, 7, 10 : The user collects maximum value as 15(10 + 5)
2. 8, 15, 3, 7 : The user collects maximum value as 22(7 + 15)
Does choosing the best at each move give an optimal solution?
No. In the second example, this is how the game can finish:
1.
…….User chooses 8.
…….Opponent chooses 15.
Total value collected by user is 15(8 + 7)
2.
Total value collected by user is 22(7 + 15)
So if the user follows the second game state, maximum value can be collected although the first move is not
the best.
There are two choices:

1. The user chooses the ith coin with value Vi: The opponent either chooses (i+1)th coin or jth coin. The
opponent intends to choose the coin which leaves the user with minimum value.
i.e. The user can collect the value Vi + min(F(i+2, j), F(i+1, j-1) )
2. The user chooses the jth coin with value Vj: The opponent either chooses ith coin or (j-1)th coin. The
opponent intends to choose the coin which leaves the user with minimum value.
i.e. The user can collect the value Vj + min(F(i+1, j-1), F(i, j-2) )
Following is recursive solution that is based on above two choices. We take the maximum of two choices.
F(i, j) represents the maximum value the user can collect from
i'th coin to j'th coin.
F(i, j) = Max(Vi + min(F(i+2, j), F(i+1, j-1) ),

Vj + min(F(i+1, j-1), F(i, j-2) ))
Base Cases
F(i, j) = Vi If j == i
F(i, j) = max(Vi, Vj) If j == i+1

Why Dynamic Programming?

The above relation exhibits overlapping sub-problems. In the above relation, F(i+1, j-1) is calculated twice.

// C program to find out maximum value from a given sequence of coins

#include <stdio.h>
#include <limits.h>
// Utility functions to get maximum and minimum of two intgers

int max(int a, int b) { return a > b ? a : b; }
int min(int a, int b) { return a < b ? a : b; }
// Returns optimal value possible that a player can collect from

// an array of coins of size n. Note than n must be even
int optimalStrategyOfGame(int* arr, int n)
{
// Create a table to store solutions of subproblems
int table[n][n], gap, i, j, x, y, z;
// Fill table using above recursive formula. Note that the table
// is filled in diagonal fashion (similar to http://goo.gl/PQqoS),
// from diagonal elements to table[0][n-1] which is the result.
{
for (i = 0, j = gap; j < n; ++i, ++j)
{
// Here x is value of F(i+2, j), y is F(i+1, j-1) and
// z is F(i, j-2) in above recursive formula
x = ((i+2) <= j) ? table[i+2][j] : 0;
y = ((i+1) <= (j-1)) ? table[i+1][j-1] : 0;
z = (i <= (j-2))? table[i][j-2]: 0;
table[i][j] = max(arr[i] + min(x, y), arr[j] + min(y, z));

}
}
}

int main()
{
int arr1[] = {8, 15, 3, 7};
printf("%d\n", optimalStrategyOfGame(arr1, n));
int arr2[] = {2, 2, 2, 2};

n = sizeof(arr2)/sizeof(arr2[0]);
int arr3[] = {20, 30, 2, 2, 2, 10};

n = sizeof(arr3)/sizeof(arr3[0]);
return 0;
}

Output:

22
4
42

Exercise
Your thoughts on the strategy when the user wishes to only win instead of winning with the maximum value.
Like above problem, number of coins is even.
Can Greedy approach work quite well and give an optimal solution? Will your answer change if number of
coins is odd?
Connectivity in a directed graph
Given a directed graph, find out whether the graph is strongly connected or not. A directed graph is strongly
connected if there is a path between any two pair of vertices. For example, following is a strongly connected
graph.
It is easy for undirected graph , we can just do a BFS and DFS starting from any vertex. If BFS or DFS
visits all vertices, then the given undirected graph is connected. This approach won’t work for a directed
graph. For example, consider the following graph which is not strongly connected. If we start DFS (or BFS)
from vertex 0, we can reach all vertices, but if we start from any other vertex, we cannot reach all vertices.
How to do for directed graph?

A simple idea is to use a all pair shortest path algorithm like Floyd Warshall or find Transitive Closure
of graph. Time complexity of this method would be O(v3).
We can also do DFS V times starting from every vertex. If any DFS, doesn’t visit all vertices, then graph is
not strongly connected. This algorithm takes O(V*(V+E)) time which can be same as transitive closure for a
dense graph.
A better idea can be Strongly Connected Components (SCC) algorithm. We can find all SCCs in
O(V+E) time. If number of SCCs is one, then graph is strongly connected. The algorithm for SCC does extra
work as it finds all SCCs.
Following is Kosaraju’s DFS based simple algorithm that does two DFS traversals of graph:
1) Initialize all vertices as not visited.
2) Do a DFS traversal of graph starting from any arbitrary vertex v. If DFS traversal doesn’t visit all vertices,
then return false.
3) Reverse all arcs (or find transpose or reverse of graph)
4) Mark all vertices as not-visited in reversed graph.
5) Do a DFS traversal of reversed graph starting from same vertex v (Same as step 2). If DFS traversal
doesn’t visit all vertices, then return false. Otherwise return true.
The idea is, if every node can be reached from a vertex v, and every node can reach v, then the graph is
strongly connected. In step 2, we check if all vertices are reachable from v. In step 4, we check if all vertices
can reach v (In reversed graph, if all vertices are reachable from v, then all vertices can reach v in original
graph).
// Program to check if a given directed graph is strongly connected or not

#include <iostream>
#include <list>
#include <stack>
class Graph
{
list<int> *adj; // An array of adjacency lists

public:
// Constructor and Destructor
Graph(int V) { this->V = V; adj = new list<int>[V];}
~Graph() { delete [] adj; }
// Method to add an edge

// The main function that returns true if the graph is strongly

// connected, otherwise false
bool isSC();

};

{
visited[v] = true;

if (!visited[*i])
}

{
Graph g(V);
for (int v = 0; v < V; v++)
{
{
}
}
return g;
}

{
}
// The main function that returns true if graph is strongly connected
bool Graph::isSC()
{
// St1p 1: Mark all the vertices as not visited (For first DFS)
bool visited[V];
for (int i = 0; i < V; i++)
visited[i] = false;
// Step 2: Do DFS traversal starting from first vertex.

DFSUtil(0, visited);
// If DFS traversal doesn’t visit all vertices, then return false.

for (int i = 0; i < V; i++)
return false;
// Step 3: Create a reversed graph

// Step 4: Mark all the vertices as not visited (For second DFS)
for(int i = 0; i < V; i++)
visited[i] = false;
// Step 5: Do DFS for reversed graph starting from first vertex.

// Staring Vertex must be same starting point of first DFS
gr.DFSUtil(0, visited);
// If all vertices are not visited in second DFS, then

// return false
for (int i = 0; i < V; i++)
return false;
return true;
}

int main()
{
// Create graphs given in the above diagrams
Graph g1(5);
g1.addEdge(0, 1);
g1.addEdge(1, 2);
g1.addEdge(2, 3);
g1.addEdge(3, 0);
g1.addEdge(2, 4);
g1.addEdge(4, 2);
g1.isSC()? cout << "Yes\n" : cout << "No\n";
Graph g2(4);
g2.addEdge(0, 1);
g2.addEdge(1, 2);
g2.addEdge(2, 3);
g2.isSC()? cout << "Yes\n" : cout << "No\n";
return 0;
}

Output:

Yes
No

Time Complexity: Time complexity of above implementation is sane as Depth First Search which is
O(V+E) if the graph is represented using adjacency matrix representation.
Exercise:
Can we use BFS instead of DFS in above algorithm?
References:
http://www.ieor.berkeley.edu/~hochbaum/files/ieor266-2012.pdf
discussed above
Iterative Method to find Height of Binary Tree
There are two conventions to define height of Binary Tree
1) Number of nodes on longest path from root to the deepest node.
2) Number of edges on longest path from root to the deepest node.
In this post, the first convention is followed. For example, height of the below tree is 3.
Example Tree
Recursive method to find height of Binary Tree is discussed here. How to find height without recursion? We
can use level order traversal to find height without recursion. The idea is to traverse level by level. Whenever
move down to a level, increment height by 1 (height is initialized as 0). Count number of nodes at each level,
stop traversing when count of nodes at next level is 0.
Following is detailed algorithm to find level order traversal using queue.
Create a queue.
Push root into the queue.
height = 0
Loop
nodeCount = size of queue

// If number of nodes at this level is 0, return height
if nodeCount is 0
return Height;
else
increase Height
// Remove nodes of this level and add nodes of

// next level
while (nodeCount > 0)
pop node from front
push its children to queue
decrease nodeCount
// At this point, queue has nodes of next level

/* Program to find height of the tree by Iterative Method */

#include <iostream>
#include <queue>
// A Binary Tree Node

struct node
struct node
{
struct node *left;
int data;
struct node *right;
};
// Iterative method to find height of Bianry Tree

int treeHeight(node *root)
{
// Base Case
if (root == NULL)
return 0;
// Create an empty queue for level order tarversal

queue<node *> q;
// Enqueue Root and initialize height

q.push(root);
int height = 0;
while (1)
{
// nodeCount (queue size) indicates number of nodes
// at current lelvel.
int nodeCount = q.size();
if (nodeCount == 0)
return height;
height++;
// Dequeue all nodes of current level and Enqueue all

// nodes of next level
while (nodeCount > 0)
{
node *node = q.front();
q.pop();
q.push(node->left);
q.push(node->right);
nodeCount--;
}
}
}
// Utility function to create a new tree node

{
temp->data = data;
temp->left = NULL;
temp->right = NULL;
return temp;
}

int main()
{
// Let us create binary tree shown in above diagram
cout << "Height of tree is " << treeHeight(root);

return 0;
}

Output:

Height of tree is 3

Time Complexity: O(n) where n is number of nodes in given binary tree.
This article is contributed by Rahul Kumar. Please write comments if you find anything incorrect, or you
Random number generator in arbitrary probability distribution fashion
Given n numbers, each with some frequency of occurrence. Return a random number with probability
proportional to its frequency of occurrence.
Example:
Let following be the given numbers.

arr[] = {10, 30, 20, 40}
Let following be the frequencies of given numbers.

freq[] = {1, 6, 2, 1}
The output should be

10 with probability 1/10

It is quite clear that the simple random number generator won’t work here as it doesn’t keep track of the
frequency of occurrence.
We need to somehow transform the problem into a problem whose solution is known to us.
One simple method is to take an auxiliary array (say aux[]) and duplicate the numbers according to their
frequency of occurrence. Generate a random number(say r) between 0 to Sum-1(including both), where Sum
represents summation of frequency array (freq[] in above example). Return the random number aux[r]
(Implementation of this method is left as an exercise to the readers).
The limitation of the above method discussed above is huge memory consumption when frequency of
occurrence is high. If the input is 997, 8761 and 1, this method is clearly not efficient.
How can we reduce the memory consumption? Following is detailed algorithm that uses O(n) extra space
where n is number of elements in input arrays.
1. Take an auxiliary array (say prefix[]) of size n.

2. Populate it with prefix sum, such that prefix[i] represents sum of numbers from 0 to i.
3. Generate a random number(say r) between 1 to Sum(including both), where Sum represents summation
of input frequency array.
4. Find index of Ceil of random number generated in step #3 in the prefix array. Let the index be index
c.
5. Return the random number arr[indexc], where arr[] contains the input n numbers.
Before we go to the implementation part, let us have quick look at the algorithm with an example:
arr[]: {10, 20, 30}
freq[]: {2, 3, 1}
Prefix[]: {2, 5, 6}
Since last entry in prefix is 6, all possible values of r are [1, 2, 3, 4, 5, 6]
1: Ceil is 2. Random number generated is 10.
6. Ceil is 6. Random number generated is 30.
In the above example
10 is generated with probability 2/6.
How does this work?

Any number input[i] is generated as many times as its frequency of occurrence because there exists count of
integers in range(prefix[i – 1], prefix[i]] is input[i]. Like in the above example 3 is generated thrice, as there
exists 3 integers 3, 4 and 5 whose ceil is 5.

//C program to generate random numbers according to given frequency distribution

#include <stdio.h>
#include <stdlib.h>
// Utility function to find ceiling of r in arr[l..h]

int findCeil(int arr[], int r, int l, int h)
{
int mid;
while (l < h)
{
mid = l + ((h - l) >> 1); // Same as mid = (l+h)/2
(r > arr[mid]) ? (l = mid + 1) : (h = mid);
}
return (arr[l] >= r) ? l : -1;
}
// The main function that returns a random number from arr[] according to
// distribution array defined by freq[]. n is size of arrays.
int myRand(int arr[], int freq[], int n)
{
// Create and fill prefix array
int prefix[n], i;
prefix[0] = freq[0];
for (i = 1; i < n; ++i)
prefix[i] = prefix[i - 1] + freq[i];
// prefix[n-1] is sum of all frequencies. Generate a random number

// with value from 1 to this sum
int r = (rand() % prefix[n - 1]) + 1;
// Find index of ceiling of r in prefix arrat

int indexc = findCeil(prefix, r, 0, n - 1);
return arr[indexc];
}

int main()
{
int arr[] = {1, 2, 3, 4};
int freq[] = {10, 5, 20, 100};
int i, n = sizeof(arr) / sizeof(arr[0]);

srand(time(NULL));
// Let us generate 10 random numbers accroding to

// given distribution
for (i = 0; i < 5; i++)
printf("%d\n", myRand(arr, freq, n));
return 0;
}

Output: May be different for different runs

4
3
4
4
4

Design a stack with operations on middle element
How to implement a stack which will support following operations in O(1) time complexity ?
1) push() which adds an element to the top of stack.
2) pop() which removes an element from top of stack.
3) findMiddle() which will return middle element of the stack.
4) deleteMiddle() which will delete the middle element.
Push and pop are standard stack operations.
The important question is, whether to use a linked list or array for implementation of stack?
Please note that, we need to find and delete middle element. Deleting an element from middle is not O(1) for
array. Also, we may need to move the middle pointer up when we push an element and move down when we
pop(). In singly linked list, moving middle pointer in both directions is not possible.
The idea is to use Doubly Linked List (DLL). We can delete middle element in O(1) time by maintaining mid
pointer. We can move mid pointer in both directions using previous and next pointers.
Following is C implementation of push(), pop() and findMiddle() operations. Implementation of

deleteMiddle() is left as an exercise. If there are even elements in stack, findMiddle() returns the first
middle element. For example, if stack contains {1, 2, 3, 4}, then findMiddle() would return 2.
/* Program to implement a stack that supports findMiddle() and deleteMiddle

in O(1) time */
#include <stdio.h>
#include <stdlib.h>
/* A Doubly Linked List Node */

struct DLLNode
{
struct DLLNode *prev;
int data;
struct DLLNode *next;
};
/* Representation of the stack data structure that supports findMiddle()

in O(1) time. The Stack is implemented using Doubly Linked List. It
maintains pointer to head node, pointer to middle node and count of
nodes */
struct myStack
{
struct DLLNode *head;
struct DLLNode *mid;
int count;
};
/* Function to create the stack data structure */

struct myStack *createMyStack()
{
struct myStack *ms =
(struct myStack*) malloc(sizeof(struct myStack));
ms->count = 0;
return ms;
};
/* Function to push an element to the stack */

void push(struct myStack *ms, int new_data)
{
/* allocate DLLNode and put in data */
struct DLLNode* new_DLLNode =
(struct DLLNode*) malloc(sizeof(struct DLLNode));
new_DLLNode->data = new_data;
/* Since we are adding at the begining,

new_DLLNode->prev = NULL;
/* link the old list off the new DLLNode */

new_DLLNode->next = ms->head;
/* Increment count of items in stack */

ms->count += 1;
/* Change mid pointer in two cases

1) Linked List is empty
2) Number of nodes in linked list is odd */
if (ms->count == 1)
{
ms->mid = new_DLLNode;
}
else
{
ms->head->prev = new_DLLNode;
if (ms->count & 1) // Update mid if ms->count is odd

ms->mid = ms->mid->prev;
}
/* move head to point to the new DLLNode */

ms->head = new_DLLNode;
}
/* Function to pop an element from stack */

int pop(struct myStack *ms)
{
/* Stack underflow */
if (ms->count == 0)
{
printf("Stack is empty\n");
return -1;
}
struct DLLNode *head = ms->head;

int item = head->data;
ms->head = head->next;
// If linked list doesn't become empty, update prev

// of new head as NULL
if (ms->head != NULL)
ms->head->prev = NULL;
ms->count -= 1;
// update the mid pointer when we have even number of

// elements in the stack, i,e move down the mid pointer.
if (!((ms->count) & 1 ))
ms->mid = ms->mid->next;
free(head);
return item;
}
// Function for finding middle of the stack
int findMiddle(struct myStack *ms)
{
if (ms->count == 0)
{
printf("Stack is empty now\n");
return -1;
}
return ms->mid->data;
}
// Driver program to test functions of myStack

int main()
{
/* Let us create a stack using push() operation*/
struct myStack *ms = createMyStack();
push(ms, 11);
push(ms, 22);
push(ms, 33);
push(ms, 44);
push(ms, 55);
push(ms, 66);
push(ms, 77);
printf("Item popped is %d\n", pop(ms));

printf("Item popped is %d\n", pop(ms));
printf("Middle Element is %d\n", findMiddle(ms));
return 0;
}

Output:

Item popped is 77
Item popped is 66
Middle Element is 33

This article is contributed by Chandra Prakash. Please write comments if you find anything incorrect, or
Delete N nodes after M nodes of a linked list
Given a linked list and two integers M and N. Traverse the linked list such that you retain M nodes then
delete next N nodes, continue the same till end of the linked list.
Examples:
Input:
M = 2, N = 2
Linked List: 1->2->3->4->5->6->7->8
Output:
Linked List: 1->2->5->6
Input:
M = 3, N = 2
Linked List: 1->2->3->4->5->6->7->8->9->10
Output:
Linked List: 1->2->3->6->7->8
Input:
M = 1, N = 1
Linked List: 1->2->3->4->5->6->7->8->9->10
Output:
Linked List: 1->3->5->7->9

The main part of the problem is to maintain proper links between nodes, make sure that all corner cases are
handled. Following is C implementation of function skipMdeleteN() that skips M nodes and delete N nodes
till end of list. It is assumed that M cannot be 0.
// C program to delete N nodes after M nodes of a linked list

#include <stdio.h>
#include <stdlib.h>
// A linked list node

struct node
{
int data;
struct node *next;
};
/* Function to insert a node at the beginning */

void push(struct node ** head_ref, int new_data)
{
/* allocate node */



}
}

{
{
temp = temp->next;
}
printf("\n");
}
// Function to skip M nodes and then delete N nodes of the linked list.
void skipMdeleteN(struct node *head, int M, int N)
{
struct node *curr = head, *t;
int count;
// The main loop that traverses through the whole list

while (curr)
{
// Skip M nodes
for (count = 1; count<M && curr!= NULL; count++)
curr = curr->next;
// If we reached end of list, then return

if (curr == NULL)
return;
// Start from next node and delete N nodes

t = curr->next;
for (count = 1; count<=N && t!= NULL; count++)
{
struct node *temp = t;
t = t->next;
free(temp);
}
curr->next = t; // Link the previous list with remaining nodes
// Set current pointer for next iteration

curr = t;
}
}

int main()
{
1->2->3->4->5->6->7->8->9->10 */
int M=2, N=3;
push(&head, 10);
push(&head, 9);
push(&head, 8);
push(&head, 7);
push(&head, 6);
push(&head, 5);
push(&head, 4);
push(&head, 3);
push(&head, 2);
push(&head, 1);
printf("M = %d, N = %d \nGiven Linked list is :\n", M, N);
printList(head);
skipMdeleteN(head, M, N);
printf("\nLinked list after deletion is :\n");

printList(head);
return 0;
}

Output:

M = 2, N = 3
Given Linked list is :
1 2 3 4 5 6 7 8 9 10
Linked list after deletion is :

1 2 6 7

Time Complexity: O(n) where n is number of nodes in linked list.
Eulerian path and circuit for undirected graph
Eulerian Path is a path in graph that visits every edge exactly once. Eulerian Circuit is an Eulerian Path which
starts and ends on the same vertex.
How to find whether a given graph is Eulerian or not?

The problem is same as following question. “Is it possible to draw a given graph without lifting pencil from
the paper and without tracing any of the edges more than once”.
A graph is called Eulerian if it has an Eulerian Cycle and called Semi-Eulerian if it has an Eulerian Path. The
problem seems similar to Hamiltonian Path which is NP complete problem for a general graph. Fortunately,
we can find whether a given graph has a Eulerian Path or not in polynomial time. In fact, we can find it in
O(V+E) time.
Following are some interesting properties of undirected graphs with an Eulerian path and cycle. We can use
these properties to find whether a graph is Eulerian or not.
Eulerian Cycle
An undirected graph has Eulerian cycle if following two conditions are true.
….a) All vertices with non-zero degree are connected. We don’t care about vertices with zero degree because
they don’t belong to Eulerian Cycle or Path (we only consider all edges).
….b) All vertices have even degree.
Eulerian Path
An undirected graph has Eulerian Path if following two conditions are true.
….a) Same as condition (a) for Eulerian Cycle
….b) If zero or two vertices have odd degree and all other vertices have even degree. Note that only one
vertex with odd degree is not possible in an undirected graph (sum of all degrees is always even in an
undirected graph)
Note that a graph with no edges is considered Eulerian because there are no edges to traverse.
How does this work?

In Eulerian path, each time we visit a vertex v, we walk through two unvisited edges with one end point as v.
Therefore, all middle vertices in Eulerian Path must have even degree. For Eulerian Cycle, any vertex can be
middle vertex, therefore all vertices must have even degree.
// A C++ program to check if a given graph is Eulerian or not

#include<iostream>
#include <list>

class Graph
{
public:
// Constructor and destructor
Graph(int V) {this->V = V; adj = new list<int>[V]; }
~Graph() { delete [] adj; } // To avoid memory leak

// Method to check if this graph is Eulerian or not

int isEulerian();
// Method to check if all non-zero degree vertices are connected

bool isConnected();
// Function to do DFS starting from v. Used in isConnected();

};

{
}

{
visited[v] = true;

if (!visited[*i])
}
// Method to check if all non-zero degree vertices are connected.

// It mainly does DFS traversal starting from
bool Graph::isConnected()
{
bool visited[V];
int i;
for (i = 0; i < V; i++)
visited[i] = false;
// Find a vertex with non-zero degree

for (i = 0; i < V; i++)
if (adj[i].size() != 0)
break;
// If there are no edges in the graph, return true

if (i == V)
return true;
// Start DFS traversal from a vertex with non-zero degree

// Check if all non-zero degree vertices are visited

for (i = 0; i < V; i++)
if (visited[i] == false && adj[i].size() > 0)
return false;
return true;
}
/* The function returns one of the following values

0 --> If grpah is not Eulerian
1 --> If graph has an Euler path (Semi-Eulerian)
2 --> If graph has an Euler Circuit (Eulerian) */
int Graph::isEulerian()
{
// Check if all non-zero degree vertices are connected
if (isConnected() == false)
return 0;
// Count vertices with odd degree

int odd = 0;
for (int i = 0; i < V; i++)
if (adj[i].size() & 1)
odd++;
// If count is more than 2, then graph is not Eulerian

if (odd > 2)
return 0;
// If odd count is 2, then semi-eulerian.

// If odd count is 0, then eulerian
// Note that odd count can never be 1 for undirected graph
return (odd)? 1 : 2;
}
// Function to run test cases

void test(Graph &g)
{
int res = g.isEulerian();
if (res == 0)
cout << "Graph is not Eulerian\n";
else if (res == 1)
cout << "Graph has a Euler path\n";
else
cout << "Graph has a Euler cycle\n";
}

int main()
{
// Let us create and test graphs shown in above figures
Graph g1(5);
g1.addEdge(1, 0);
g1.addEdge(0, 2);
g1.addEdge(2, 1);
g1.addEdge(0, 3);
g1.addEdge(3, 4);
test(g1);
Graph g2(5);
g2.addEdge(1, 0);
g2.addEdge(0, 2);
g2.addEdge(2, 1);
g2.addEdge(0, 3);
g2.addEdge(3, 4);
g2.addEdge(4, 0);
test(g2);
Graph g3(5);
g3.addEdge(1, 0);
g3.addEdge(0, 2);
g3.addEdge(2, 1);
g3.addEdge(0, 3);
g3.addEdge(3, 4);
g3.addEdge(1, 3);
test(g3);
// Let us create a graph with 3 vertices

// connected in the form of cycle
Graph g4(3);
g4.addEdge(0, 1);
g4.addEdge(1, 2);
g4.addEdge(2, 0);
test(g4);
// Let us create a graph with all veritces

// with zero degree
Graph g5(3);
test(g5);
return 0;
}

Output:

Graph has a Euler path

Graph has a Euler cycle
Graph is not Eulerian

Time Complexity: O(V+E)
We will soon be covering following topics on Eulerian Path and Circuit

1) Eulerian Path and Circuit for a Directed Graphs.
2) How to print a Eulerian Path or Circuit?
References:
http://en.wikipedia.org/wiki/Eulerian_path
discussed above
Working with Shared Libraries | Set 1
This article is not for those algo geeks. If you are interested in systems related stuff, just read on…
Shared libraries are useful in sharing code which is common across many applications. For example, it is
more economic to pack all the code related to TCP/IP implementation in a shared library. However, data
can’t be shared as every application needs its own set of data. Applications like, browser, ftp, telnet, etc…
make use of the shared ‘network’ library to elevate specific functionality.
Every operating system has its own representation and tool-set to create shared libraries. More or less the
concepts are same. On Windows every object file (*.obj, *.dll, *.ocx, *.sys, *.exe etc…) follow a format called
Portalbe Executable. Even shared libraries (called as Dynamic Linked Libraries or DLL in short) are also
represented in PE format. The tool-set that is used to create these libraries need to understand the binary
format. Linux variants follow a format called Executable and Linkable Format (ELF). The ELF files are
position independent (PIC) format. Shared libraries in Linux are referred as shared objects (generally with
extension *.so). These are similar to DLLs in Windows platform. Even shared object files follow the ELF
binary format.
Remember, the file extensions (*.dll, *.so, *.a, *.lib, etc…) are just for programmer convenience. They don’t
have any significance. All these are binary files. You can name them as you wish. Yet ensure you provide
absolute paths in building applications.
In general, when we compile an application the steps are simple. Compile, Link and Load. However, it is not
simple. These steps are more versatile on modern operating systems.
When you link your application against static library, the code is part of your application. There is no
dependency. Even though it causes the application size to increase, it has its own advantages. The primary
one is speed as there will be no symbol (a program entity) resolution at runtime. Since every piece of code
part of the binary image, such applications are independent of version mismatch issues. However, the cost is
on fixing an issue in library code. If there is any bug in library code, entire application need to be recompiled
and shipped to the client. In case of dynamic libraries, fixing or upgrading the libraries is easy. You just need
to ship the updated shared libraries. The application need not to recompile, it only need to re-run. You can
design a mechanism where we don’t need to restart the application.
When we link an application against a shared library, the linker leaves some stubs (unresolved symbols) to
be filled at application loading time. These stubs need to be filled by a tool called, dynamic linker at run time
or at application loading time. Again loading of a library is of two types, static loading and dynamic loading.
Don’t confuse between static loading vs static linking and dynamic loading vs dynamic linking.
For example, you have built an application that depends on libstdc++.so which is a shared object (dynamic
libary). How does the application become aware of required shared libraries? (If you are interested, explore
the tools tdump from Borland tool set, objdump or nm or readelf tools on Linux).
Static loading:
In static loading, all of those dependent shared libraries are loaded into memory even before the
application starts execution. If loading of any shared library fails, the application won’t run.
A dynamic loader examines application’s dependency on shared libraries. If these libraries are already
loaded into the memory, the library address space is mapped to application virtual address space
(VAS) and the dynamic linker does relocation of unresolved symbols.
If these libraries are not loaded into memory (perhaps your application might be first to invoke the
shared library), the loader searches in standard library paths and loads them into memory, then maps
and resolves symbols. Again loading is big process, if you are interested write your own loader :).
While resolving the symbols, if the dynamic linker not able to find any symbol (may be due to older
version of shared library), the application can’t be started.
Dynamic Loading:
As the name indicates, dynamic loading is about loading of library on demand.

For example, if you want a small functionality from a shared library. Why should it be loaded at the
application load time and sit in the memory? You can invoke loading of these shared libraries
dynamically when you need their functionality. This is called dynamic loading. In this case, the
programmer aware of situation ‘when should the library be loaded’. The tool-set and relevant kernel
provides API to support dynamic loading, and querying of symbols in the shared library.
More details in later articles.
Note: If you come across terms like loadable modules or equivalent terms, don’t mix them with shared
libraries. They are different from shared libraries The kernels provide framework to support loadable
modules.
Exercise:
1. Assuming you have understood the concepts, How do you design an application (e.g. Banking) which can
upgrade to new shared libraries without re-running the application.
Dynamic Programming | Set 32 (Word Break Problem)
Given an input string and a dictionary of words, find out if the input string can be segmented into a space-
separated sequence of dictionary words. See following examples for more details.
This is a famous Google interview question, also being asked by many other companies now a days.
Consider the following dictionary

{ i, like, sam, sung, samsung, mobile, ice,
cream, icecream, man, go, mango}
Input: ilike
Output: Yes
The string can be segmented as "i like".
Input: ilikesamsung
Output: Yes
The string can be segmented as "i like samsung" or "i like sam sung".

Recursive implementation:
The idea is simple, we consider each prefix and search it in dictionary. If the prefix is present in dictionary,
we recur for rest of the string (or suffix). If the recursive call for suffix returns true, we return true, otherwise
we try next prefix. If we have tried all prefixes and none of them resulted in a solution, we return false.
We strongly recommend to see substr function which is used extensively in following implementations.

// A recursive program to test whether a given string can be segmented into

// space separated words in dictionary
#include <iostream>
/* A utility function to check whether a word is present in dictionary or not.

An array of strings is used for dictionary. Using array of strings for
dictionary is definitely not a good idea. We have used for simplicity of
the program*/
int dictionaryContains(string word)
{
string dictionary[] = {"mobile","samsung","sam","sung","man","mango",
"icecream","and","go","i","like","ice","cream"};
int size = sizeof(dictionary)/sizeof(dictionary[0]);
for (int i = 0; i < size; i++)
if (dictionary[i].compare(word) == 0)
return true;
return false;
}
// returns true if string can be segmented into space separated

// words, otherwise returns false
bool wordBreak(string str)
{
int size = str.size();
// Base case
if (size == 0) return true;
// Try all prefixes of lengths from 1 to size

for (int i=1; i<=size; i++)
{
// The parameter for dictionaryContains is str.substr(0, i)
// str.substr(0, i) which is prefix (of input string) of
// length 'i'. We first check whether current prefix is in
// dictionary. Then we recursively check for remaining string
// str.substr(i, size-i) which is suffix of length size-i
if (dictionaryContains( str.substr(0, i) ) &&
wordBreak( str.substr(i, size-i) ))
return true;
}
// If we have tried all prefixes and none of them worked

return false;
}

int main()
{
wordBreak("ilikesamsung")? cout <<"Yes\n": cout << "No\n";
wordBreak("iiiiiiii")? cout <<"Yes\n": cout << "No\n";
wordBreak("")? cout <<"Yes\n": cout << "No\n";
wordBreak("ilikelikeimangoiii")? cout <<"Yes\n": cout << "No\n";
wordBreak("samsungandmango")? cout <<"Yes\n": cout << "No\n";
wordBreak("samsungandmangok")? cout <<"Yes\n": cout << "No\n";
return 0;
}

Output:

Yes
Yes
Yes
Yes
Yes
No

Dynamic Programming
Why Dynamic Programming? The above problem exhibits overlapping sub-problems. For example, see the
following partial recursion tree for string “abcde” in worst case.
// A Dynamic Programming based program to test whether a given string can

// be segmented into space separated words in dictionary
#include <iostream>
#include <string.h>
/* A utility function to check whether a word is present in dictionary or not.

An array of strings is used for dictionary. Using array of strings for
dictionary is definitely not a good idea. We have used for simplicity of
the program*/
int dictionaryContains(string word)
{
string dictionary[] = {"mobile","samsung","sam","sung","man","mango",
"icecream","and","go","i","like","ice","cream"};
int size = sizeof(dictionary)/sizeof(dictionary[0]);
for (int i = 0; i < size; i++)
if (dictionary[i].compare(word) == 0)
return true;
return false;
}
// Returns true if string can be segmented into space separated

// words, otherwise returns false
bool wordBreak(string str)
{
int size = str.size();
if (size == 0) return true;
// Create the DP table to store results of subroblems. The value wb[i]
// will be true if str[0..i-1] can be segmented into dictionary words,
// otherwise false.
bool wb[size+1];
memset(wb, 0, sizeof(wb)); // Initialize all values as false.
for (int i=1; i<=size; i++)

{
// if wb[i] is false, then check if current prefix can make it true.
// Current prefix is "str.substr(0, i)"
if (wb[i] == false && dictionaryContains( str.substr(0, i) ))
wb[i] = true;
// wb[i] is true, then check for all substrings starting from

// (i+1)th character and store their results.
if (wb[i] == true)
{
// If we reached the last prefix
if (i == size)
return true;
for (int j = i+1; j <= size; j++)

{
// Update wb[j] if it is false and can be updated
// Note the parameter passed to dictionaryContains() is
// substring starting from index 'i' and length 'j-i'
if (wb[j] == false && dictionaryContains( str.substr(i, j-i) ))
wb[j] = true;
// If we reached the last character

if (j == size && wb[j] == true)
return true;
}
}
}
/* Uncomment these lines to print DP table "wb[]"

for (int i = 1; i <= size; i++)
cout << " " << wb[i]; */
// If we have tried all prefixes and none of them worked

return false;
}

int main()
{
wordBreak("ilikesamsung")? cout <<"Yes\n": cout << "No\n";
wordBreak("iiiiiiii")? cout <<"Yes\n": cout << "No\n";
wordBreak("")? cout <<"Yes\n": cout << "No\n";
wordBreak("ilikelikeimangoiii")? cout <<"Yes\n": cout << "No\n";
wordBreak("samsungandmango")? cout <<"Yes\n": cout << "No\n";
wordBreak("samsungandmangok")? cout <<"Yes\n": cout << "No\n";
return 0;
}

Output:

Yes
Yes
Yes
Yes
Yes
No

Exercise:
The above solutions only finds out whether a given string can be segmented or not. Extend the above
Dynamic Programming solution to print all possible partitions of input string. See extended recursive
solution for reference.
Examples:
Input: ilikeicecreamandmango
Output:
i like ice cream and man go
i like ice cream and mango
i like icecream and man go
i like icecream and mango
Input: ilikesamsungmobile
Output:
i like sam sung mobile
i like samsung mobile

discussed above
Custom Tree Problem
You are given a set of links, e.g.

a ---> b
b ---> c
b ---> d
a ---> e

Print the tree that would form when each pair of these links that has the same character as start and end
point is joined together. You have to maintain fidelity w.r.t. the height of nodes, i.e. nodes at height n from
root should be printed at same row or column. For set of links given above, tree printed should be –
-->a
|-->b
| |-->c
| |-->d
|-->e

Note that these links need not form a single tree; they could form, ahem, a forest. Consider the following
links

a ---> b
a ---> g
b ---> c
c ---> d
d ---> e
c ---> f
z ---> y
y ---> x
x ---> w

The output would be following forest.

-->a
|-->b
| |-->c
| | |-->d
| | | |-->e
| | |-->f
|-->g
-->z
|-->y
| |-->x
| | |-->w

You can assume that given links can form a tree or forest of trees only, and there are no duplicates among
links.
Solution: The idea is to maintain two arrays, one array for tree nodes and other for trees themselves (we
call this array forest). An element of the node array contains the TreeNode object that corresponds to
respective character. An element of the forest array contains Tree object that corresponds to respective root
of tree.
It should be obvious that the crucial part is creating the forest here, once it is created, printing it out in
required format is straightforward. To create the forest, following procedure is used –
Do following for each input link,

1. If start of link is not present in node array
Create TreeNode objects for start character
Add entries of start in both arrays.
2. If end of link is not present in node array
Create TreeNode objects for start character
Add entry of end in node array.
3. If end of link is present in node array.
If end of link is present in forest array, then remove it
from there.
4. Add an edge (in tree) between start and end nodes of link.

It should be clear that this procedure runs in linear time in number of nodes as well as of links – it makes
only one pass over the links. It also requires linear space in terms of alphabet size.
Following is Java implementation of above algorithm. In the following implementation characters are
assumed to be only lower case characters from ‘a’ to ‘z’.
// Java program to create a custom tree from a given set of links.

// The main class that represents tree and has main method
public class Tree {

private TreeNode root;

/* Returns an array of trees from links input. Links are assumed to
be Strings of the form "<s> <e>" where <s> and <e> are starting
and ending points for the link. The returned array is of size 26
and has non-null values at indexes corresponding to roots of trees
in output */
public Tree[] buildFromLinks(String [] links) {

// Create two arrays for nodes and forest
TreeNode[] nodes = new TreeNode[26];
Tree[] forest = new Tree[26];

// Process each link
for (String link : links) {

// Find the two ends of current link
String[] ends = link.split(" ");
int start = (int) (ends[0].charAt(0) - 'a'); // Start node
int end = (int) (ends[1].charAt(0) - 'a'); // End node

// If start of link not seen before, add it two both arrays
if (nodes[start] == null)
if (nodes[start] == null)
{
nodes[start] = new TreeNode((char) (start + 'a'));

// Note that it may be removed later when this character is
// last character of a link. For example, let we first see
// a--->b, then c--->a. We first add 'a' to array of trees
// and when we see link c--->a, we remove it from trees array.
forest[start] = new Tree(nodes[start]);
}

// If end of link is not seen before, add it to the nodes array
if (nodes[end] == null)
nodes[end] = new TreeNode((char) (end + 'a'));

// If end of link is seen before, remove it from forest if
// it exists there.
else forest[end] = null;

// Establish Parent-Child Relationship between Start and End
nodes[start].addChild(nodes[end], end);
}
return forest;
}

// Constructor
public Tree(TreeNode root) { this.root = root; }

public static void printForest(String[] links)
{
Tree t = new Tree(new TreeNode('\0'));
for (Tree t1 : t.buildFromLinks(links)) {
if (t1 != null)
{
t1.root.printTreeIdented("");
System.out.println("");
}
}
}

// Driver method to test
String [] links1 = {"a b", "b c", "b d", "a e"};
System.out.println("------------ Forest 1 ----------------");
printForest(links1);

String [] links2 = {"a b", "a g", "b c", "c d", "d e", "c f",
"z y", "y x", "x w"};
System.out.println("------------ Forest 2 ----------------");
printForest(links2);
}
}
// Class to represent a tree node

class TreeNode {
TreeNode []children;
char c;

// Adds a child 'n' to this node
public void addChild(TreeNode n, int index) { this.children[index] = n;}

// Constructor
public TreeNode(char c) { this.c = c; this.children = new TreeNode[26];}
public TreeNode(char c) { this.c = c; this.children = new TreeNode[26];}

// Recursive method to print indented tree rooted with this node.
public void printTreeIdented(String indent) {
System.out.println(indent + "-->" + c);
for (TreeNode child : children) {
if (child != null)
child.printTreeIdented(indent + " |");
}
}
}

Output:
------------ Forest 1 ----------------

-->a
|-->b
| |-->c
| |-->d
|-->e
------------ Forest 2 ----------------

-->a
|-->b
| |-->c
| | |-->d
| | | |-->e
| | |-->f
|-->g
-->z
|-->y
| |-->x
| | |-->w

Exercise:
In the above implementation, endpoints of input links are assumed to be from set of only 26 characters.
Extend the implementation where endpoints are strings of any length.
This article is contributed by Ciphe. Please write comments if you find anything incorrect, or you want to
Unbounded Binary Search Example (Find the point where a monotonically
increasing function becomes positive first time)
Given a function ‘int f(unsigned int x)’ which takes a non-negative integer ‘x’ as input and returns an
integer as output. The function is monotonically increasing with respect to value of x, i.e., the value of
f(x+1) is greater than f(x) for every input x. Find the value ‘n’ where f() becomes positive for the first time.
Since f() is monotonically increasing, values of f(n+1), f(n+2),… must be positive and values of f(n-2), f(n-3),
.. must be negative.
Find n in O(logn) time, you may assume that f(x) can be evaluated in O(1) time for any input x.
A simple solution is to start from i equals to 0 and one by one calculate value of f(i) for 1, 2, 3, 4 .. etc until
we find a positive f(i). This works, but takes O(n) time.
Can we apply Binary Search to find n in O(Logn) time? We can’t directly apply Binary Search as we
don’t have an upper limit or high index. The idea is to do repeated doubling until we find a positive value,
i.e., check values of f() for following values until f(i) becomes positive.
f(0)
f(1)
f(2)
f(4)
f(8)
f(16)
f(32)
....
....
f(high)
Let 'high' be the value of i when f() becomes positive for first time.

Can we apply Binary Search to find n after finding ‘high’? We can apply Binary Search now, we can use
‘high/2′ as low and ‘high’ as high indexes in binary search. The result n must lie between ‘high/2′ and ‘high’.
Number of steps for finding ‘high’ is O(Logn). So we can find ‘high’ in O(Logn) time. What about time taken
by Binary Search between high/2 and high? The value of ‘high’ must be less than 2*n. The number of
elements between high/2 and high must be O(n). Therefore, time complexity of Binary Search is O(Logn)
and overall time complexity is 2*O(Logn) which is O(Logn).

#include <stdio.h>
int binarySearch(int low, int high); // prototype
// Let's take an example function as f(x) = x^2 - 10*x - 20

// Note that f(x) can be any monotonocally increasing function
int f(int x) { return (x*x - 10*x - 20); }
// Returns the value x where above function f() becomes positive

// first time.
int findFirstPositive()
{
// When first value itself is positive
if (f(0) > 0)
return 0;
// Find 'high' for binary search by repeated doubling

int i = 1;
while (f(i) <= 0)
i = i*2;
// Call binary search

return binarySearch(i/2, i);
}
// Searches first positive value of f(i) where low <= i <= high
int binarySearch(int low, int high)
{
if (high >= low)
{
int mid = low + (high - low)/2; /* mid = (low + high)/2 */
// If f(mid) is greater than 0 and one of the following two

// conditions is true:
// a) mid is equal to low
// b) f(mid-1) is negative
if (f(mid) > 0 && (mid == low || f(mid-1) <= 0))
return mid;
// If f(mid) is smaller than or equal to 0

if (f(mid) <= 0)
return binarySearch((mid + 1), high);
else // f(mid) > 0
return binarySearch(low, (mid -1));
}
/* Return -1 if there is no positive value in given range */

return -1;
}

int main()
{
printf("The value n where f() becomes positive first is %d",
findFirstPositive());
return 0;
}

Output:

The value n where f() becomes positive first is 12

discussed above
Dynamic Programming | Set 33 (Find if a string is interleaved of two other
strings)
Given three strings A, B and C. Write a function that checks whether C is an interleaving of A and B. C is said
to be interleaving A and B, if it contains all characters of A and B and order of all characters in individual
strings is preserved.
We have discussed a simple solution of this problem here. The simple solution doesn’t work if strings A and
B have some common characters. For example A = “XXY”, string B = “XXZ” and string C = “XXZXXXY”. To
handle all cases, two possibilities need to be considered.
a) If first character of C matches with first character of A, we move one character ahead in A and C and
recursively check.
b) If first character of C matches with first character of B, we move one character ahead in B and C and
recursively check.
If any of the above two cases is true, we return true, else false. Following is simple recursive implementation
of this approach (Thanks to Frederic for suggesting this)
// A simple recursive function to check whether C is an interleaving of A and B

bool isInterleaved(char *A, char *B, char *C)
{
// Base Case: If all strings are empty
if (!(*A || *B || *C))
return true;
// If C is empty and any of the two strings is not empty

if (*C == '\0')
return false;
// If any of the above mentioned two possibilities is true,

// then return true, otherwise false
return ( (*C == *A) && isInterleaved(A+1, B, C+1))
|| ((*C == *B) && isInterleaved(A, B+1, C+1));
}

Dynamic Programming
The worst case time complexity of recursive solution is O(2n). The above recursive solution certainly has
many overlapping subproblems. For example, if wee consider A = “XXX”, B = “XXX” and C = “XXXXXX”
and draw recursion tree, there will be many overlapping subproblems.
Therefore, like other typical Dynamic Programming problems, we can solve it by creating a table and store
results of subproblems in bottom up manner. Thanks to Abhinav Ramana for suggesting this method and
implementation.
// A Dynamic Programming based program to check whether a string C is

// an interleaving of two other strings A and B.
#include <iostream>
#include <string.h>
// The main function that returns true if C is

// an interleaving of A and B, otherwise false.
bool isInterleaved(char* A, char* B, char* C)
bool isInterleaved(char* A, char* B, char* C)
{
// Find lengths of the two strings
int M = strlen(A), N = strlen(B);
// Let us create a 2D table to store solutions of

// subproblems. C[i][j] will be true if C[0..i+j-1]
// is an interleaving of A[0..i-1] and B[0..j-1].
bool IL[M+1][N+1];
memset(IL, 0, sizeof(IL)); // Initialize all values as false.
// C can be an interleaving of A and B only of sum

// of lengths of A & B is equal to length of C.
if ((M+N) != strlen(C))
return false;
// Process all characters of A and B

for (int i=0; i<=M; ++i)
{
for (int j=0; j<=N; ++j)
{
// two empty strings have an empty string
// as interleaving
if (i==0 && j==0)
IL[i][j] = true;
// A is empty
else if (i==0 && B[j-1]==C[j-1])
IL[i][j] = IL[i][j-1];
// B is empty
else if (j==0 && A[i-1]==C[i-1])
IL[i][j] = IL[i-1][j];
// Current character of C matches with current character of A,

// but doesn't match with current character of B
else if(A[i-1]==C[i+j-1] && B[j-1]!=C[i+j-1])
IL[i][j] = IL[i-1][j];
// Current character of C matches with current character of B,

// but doesn't match with current character of A
else if (A[i-1]!=C[i+j-1] && B[j-1]==C[i+j-1])
IL[i][j] = IL[i][j-1];
// Current character of C matches with that of both A and B

else if (A[i-1]==C[i+j-1] && B[j-1]==C[i+j-1])
IL[i][j]=(IL[i-1][j] || IL[i][j-1]) ;
}
}
return IL[M][N];
}
// A function to run test cases

void test(char *A, char *B, char *C)
{
if (isInterleaved(A, B, C))
cout << C <<" is interleaved of " << A <<" and " << B << endl;
else
cout << C <<" is not interleaved of " << A <<" and " << B << endl;
}

int main()
{
test("XXY", "XXZ", "XXZXXXY");
test("XY" ,"WZ" ,"WZXY");
test ("XY", "X", "XXY");
test ("YX", "X", "XXY");
test ("XXY", "XXZ", "XXXXZY");
return 0;
}

Output:

XXZXXXY is not interleaved of XXY and XXZ
WZXY is interleaved of XY and WZ
XXY is interleaved of XY and X
XXY is not interleaved of YX and X
XXXXZY is interleaved of XXY and XXZ

See this for more test cases.
Time Complexity: O(MN)

Auxiliary Space: O(MN)
discussed above
Check for Identical BSTs without building the trees
Given two arrays which represent a sequence of keys. Imagine we make a Binary Search Tree (BST) from
each array. We need to tell whether two BSTs will be identical or not without actually constructing the tree.
Examples
For example, the input arrays are {2, 4, 3, 1} and {2, 1, 4, 3} will construct the same tree

Let the input arrays be a[] and b[]
Example 1:
a[] = {2, 4, 1, 3} will construct following tree.
2
/ \
1 4
/
3
b[] = {2, 4, 3, 1} will also also construct the same tree.
2
/ \
1 4
/
3
So the output is "True"
Example 2:
a[] = {8, 3, 6, 1, 4, 7, 10, 14, 13}
b[] = {8, 10, 14, 3, 6, 4, 1, 7, 13}
They both construct the same following BST, so output is "True"

8
/ \
3 10
/ \ \
1 6 14
/ \ /
4 7 13

Solution:
According to BST property, elements of left subtree must be smaller and elements of right subtree must be
greater than root.
Two arrays represent sane BST if for every element x, the elements in left and right subtrees of x appear after
it in both arrays. And same is true for roots of left and right subtrees.
The idea is to check of if next smaller and greater elements are same in both arrays. Same properties are
recursively checked for left and right subtrees. The idea looks simple, but implementation requires checking
all conditions for all elements. Following is an interesting recursive implementation of the idea.
// A C program to check for Identical BSTs without building the trees

#include<stdio.h>
#include<limits.h>
#include<stdbool.h>
/* The main function that checks if two arrays a[] and b[] of size n construct
same BST. The two values 'min' and 'max' decide whether the call is made for
left subtree or right subtree of a parent element. The indexes i1 and i2 are
the indexes in (a[] and b[]) after which we search the left or right child.
the indexes in (a[] and b[]) after which we search the left or right child.
Initially, the call is made for INT_MIN and INT_MAX as 'min' and 'max'
respectively, because root has no parent.
i1 and i2 are just after the indexes of the parent element in a[] and b[]. */
bool isSameBSTUtil(int a[], int b[], int n, int i1, int i2, int min, int max)
{
int j, k;
/* Search for a value satisfying the constraints of min and max in a[] and
b[]. If the parent element is a leaf node then there must be some
elements in a[] and b[] satisfying constraint. */
for (j=i1; j<n; j++)
if (a[j]>min && a[j]<max)
break;
for (k=i2; k<n; k++)
if (b[k]>min && b[k]<max)
break;
/* If the parent element is leaf in both arrays */

if (j==n && k==n)
return true;
/* Return false if any of the following is true

a) If the parent element is leaf in one array, but non-leaf in other.
b) The elements satisfying constraints are not same. We either search
for left child or right child of the parent element (decinded by min
and max values). The child found must be same in both arrays */
if (((j==n)^(k==n)) || a[j]!=b[k])
return false;
/* Make the current child as parent and recursively check for left and right
subtrees of it. Note that we can also pass a[k] in place of a[j] as they
are both are same */
return isSameBSTUtil(a, b, n, j+1, k+1, a[j], max) && // Right Subtree
isSameBSTUtil(a, b, n, j+1, k+1, min, a[j]); // Left Subtree
}
// A wrapper over isSameBSTUtil()

bool isSameBST(int a[], int b[], int n)
{
return isSameBSTUtil(a, b, n, 0, 0, INT_MIN, INT_MAX);
}

int main()
{
int a[] = {8, 3, 6, 1, 4, 7, 10, 14, 13};
int b[] = {8, 10, 14, 3, 6, 4, 1, 7, 13};
int n=sizeof(a)/sizeof(a[0]);
printf("%s\n", isSameBST(a, b, n)?
"BSTs are same":"BSTs not same");
return 0;
}

Output:

BSTs are same

This article is compiled by Amit Jain. Please write comments if you find anything incorrect, or you want to
Find the Increasing subsequence of length three with maximum product
Given a sequence of non-negative integers, find the subsequence of length 3 having maximum product with
the numbers of the subsequence being in ascending order.
Examples:

Input:
arr[] = {6, 7, 8, 1, 2, 3, 9, 10}
Output:
8 9 10
Input:
arr[] = {1, 5, 10, 8, 9}
Output: 5 8 9

Since we want to find the maximum product, we need to find following two things for every element in the
given sequence:
LSL: The largest smaller element on left of given element
LGR: The largest greater element on right of given element.
Once we find LSL and LGR for an element, we can find the product of element with its LSL and LGR (if they
both exist). We calculate this product for every element and return maximum of all products.
A simple method is to use nested loops. The outer loop traverses every element in sequence. Inside the
outer loop, run two inner loops (one after other) to find LSL and LGR of current element. Time complexity of
this method is O(n2).
We can do this in O(nLogn) time . For simplicity, let us first create two arrays LSL[] and LGR[] of size n
each where n is number of elements in input array arr[]. The main task is to fill two arrays LSL[] and LGR[].
Once we have these two arrays filled, all we need to find maximum product LSL[i]*arr[i]*LGR[i] where 0 fill
LSL[] in O(nLogn) time. The idea is to use a Balanced Binary Search Tree like AVL. We start with empty
AVL tree, insert the leftmost element in it. Then we traverse the input array starting from the second element
to second last element. For every element currently being traversed, we find the floor of it in AVL tree. If
floor exists, we store the floor in LSL[], otherwise we store NIL. After storing the floor, we insert the current
element in the AVL tree.
We can fill LGR[] in O(n) time. The idea is similar to this post. We traverse from right side and keep track
of the largest element. If the largest element is greater than current element, we store it in LGR[], otherwise
we store NIL.
Finally, we run a O(n) loop and return maximum of LSL[i]*arr[i]*LGR[i]
Overall complexity of this approach is O(nLogn) + O(n) + O(n) which is O(nLogn). Auxiliary space required
is O(n). Note that we can avoid space required for LSL, we can find and use LSL values in final loop.
This article is contributed by Amit Jain. Please write comments if you find anything incorrect, or you want
Working with Shared Libraries | Set 2
We have covered basic information about shared libraries in the previous post. In the current article we will
learn how to create shared libraries on Linux.
Prior to that we need to understand how a program is loaded into memory, various (basic) steps involved in
the process.
Let us see a typical “Hello World” program in C. Simple Hello World program screen image is given below.
We were compiling our code using the command “gcc -o sample shared.c ” When we compile our code,
the compiler won’t resolve implementation of the function printf(). It only verifies the syntactical checking.
The tool chain leaves a stub in our application which will be filled by dynamic linker. Since printf is standard
function the compiler implicitly invoking its shared library. More details down.
We are using ldd to list dependencies of our program binary image. In the screen image, we can see our
sample program depends on three binary files namely, linux-vdso.so.1, libc.so.6 and /lib64/ld-linux-x86-
64.so.2.
The file VDSO is fast implementation of system call interface and some other stuff, it is not our focus (on
some older systems you may see different file name in liue of *.vsdo.*). Ignore this file. We have interest in
the other two files.
The file libc.so.6 is C implementation of various standard functions. It is the file where we see printf
definition needed for our Hello World. It is the shared library needed to be loaded into memory to run our
Hello World program.
The third file /lib64/ld-linux-x86-64.so.2 is infact an executable that runs when an application is
invoked. When we invoke the program on bash terminal, typically the bash forks itself and replaces its
address space with image of program to run (so called fork-exec pair). The kernel verifies whether the
libc.so.6 resides in the memory. If not, it will load the file into memory and does the relocation of libc.so.6
symbols. It then invokes the dynamic linker (/lib64/ld-linux-x86-64.so.2) to resolve unresolved symbols of
application code (printf in the present case). Then the control transfers to our program main. (I have
intensionally omitted many details in the process, our focus is to understand basic details).
Creating our own shared library:
Let us work with simple shared library on Linux. Create a file library.c with the following content.
The file library.c defines a function signum which will be used by our application code. Compile the file
library.c file using the following command.
gcc -shared -fPIC -o liblibrary.so library.c
The flag -shared instructs the compiler that we are building a shared library. The flag -fPIC is to generate
position independent code (ignore for now). The command generates a shared library liblibrary.so in the
current working directory. We have our shared object file (shared library name in Linux) ready to use.
Create another file application.c with the following content.
In the file application.c we are invoking the function signum which was defined in a shared library.
Compile the application.c file using the following command.
gcc application.c -L /home/geetanjali/coding/ -llibrary -o sample
The flag -llibrary instructs the compiler to look for symbol definitions that are not available in the current
code (signum function in our case). The option -L is hint to the compiler to look in the directory followed by
the option for any shared libraries (during link time only). The command generates an executable named as
“sample“.
If you invoke the executable, the dynamic linker will not be able to find the required shared library. By
default it won’t look into current working directory. You have to explicitly instruct the tool chain to provide
proper paths. The dynamic linker searches standard paths available in the LD_LIBRARY_PATH and also
searches in system cache (for details explore the command ldconfig). We have to add our working directory
to the LD_LIBRARY_PATH environment variable. The following command does the same.
export LD_LIBRARY_PATH=/home/geetanjali/coding/:$LD_LIBRARY_PATH
You can now invoke our executable as shown.
./sample
Sample output on my system is shown below.
Note: The path /home/geetanjali/coding/ is working directory path on my machine. You need to use
your working directory path where ever it is being used in the above commands.
Stay tuned, we haven’t even explored 1/3rd of shared library concepts. More advanced concepts in the later
articles.
Exercise:
It is workbook like article. You won’t gain much unless you practice and do some research.
1. Create similar example and write your won function in the shared library. Invoke the function in another
application.
2. Is (Are) there any other tool(s) which can list dependent libraries?
3. What is position independent code (PIC)?
4. What is system cache in the current context? How does the directory /etc/ld.so.conf.d/* related in the
current context?
QuickSort on Singly Linked List
QuickSort on Doubly Linked List is discussed here. QuickSort on Singly linked list was given as an exercise.
Following is C++ implementation for same. The important things about implementation are, it changes
pointers rather swapping data and time complexity is same as the implementation for Doubly Linked List.
In partition(), we consider last element as pivot. We traverse through the current list and if a node has
value greater than pivot, we move it after tail. If the node has smaller value, we keep it at its current position.
In QuickSortRecur(), we first call partition() which places pivot at correct position and returns pivot.
After pivot is placed at correct position, we find tail node of left side (list before pivot) and recur for left list.
Finally, we recur for right list.
// C++ program for Quick Sort on Singly Linled List

#include <iostream>
#include <cstdio>
/* a node of the singly linked list */

struct node
{
int data;
struct node *next;
};
/* A utility function to insert a node at the beginning of linked list */

{
/* allocate node */
struct node* new_node = new node;



}
/* A utility function to print linked list */

{
{
node = node->next;
}
printf("\n");
}
// Returns the last node of the list

struct node *getTail(struct node *cur)
{
while (cur != NULL && cur->next != NULL)
cur = cur->next;
return cur;
}
// Partitions the list taking the last element as the pivot

struct node *partition(struct node *head, struct node *end,
struct node *partition(struct node *head, struct node *end,
struct node **newHead, struct node **newEnd)
{
struct node *pivot = end;
struct node *prev = NULL, *cur = head, *tail = pivot;
// During partition, both the head and end of the list might change
// which is updated in the newHead and newEnd variables
while (cur != pivot)
{
if (cur->data < pivot->data)
{
// First node that has a value less than the pivot - becomes
// the new head
if ((*newHead) == NULL)
(*newHead) = cur;
prev = cur;
cur = cur->next;
}
else // If cur node is greater than pivot
{
// Move cur node to next of tail, and change tail
if (prev)
prev->next = cur->next;
struct node *tmp = cur->next;
cur->next = NULL;
tail->next = cur;
tail = cur;
cur = tmp;
}
}
// If the pivot data is the smallest element in the current list,

// pivot becomes the head
if ((*newHead) == NULL)
(*newHead) = pivot;
// Update newEnd to the current last node

(*newEnd) = tail;
// Return the pivot node

return pivot;
}
//here the sorting happens exclusive of the end node

struct node *quickSortRecur(struct node *head, struct node *end)
{
// base condition
if (!head || head == end)
return head;
node *newHead = NULL, *newEnd = NULL;
// Partition the list, newHead and newEnd will be updated

// by the partition function
struct node *pivot = partition(head, end, &newHead, &newEnd);
// If pivot is the smallest element - no need to recur for

// the left part.
if (newHead != pivot)
{
// Set the node before the pivot node as NULL
struct node *tmp = newHead;
struct node *tmp = newHead;
while (tmp->next != pivot)
tmp = tmp->next;
tmp->next = NULL;
// Recur for the list before pivot

newHead = quickSortRecur(newHead, tmp);
// Change next of last node of the left half to pivot

tmp = getTail(newHead);
tmp->next = pivot;
}
// Recur for the list after the pivot element

pivot->next = quickSortRecur(pivot->next, newEnd);
return newHead;
}
// The main function for quick sort. This is a wrapper over recursive
// function quickSortRecur()
void quickSort(struct node **headRef)
{
(*headRef) = quickSortRecur(*headRef, getTail(*headRef));
return;
}

int main()
{
push(&a, 5);
push(&a, 20);
push(&a, 4);
push(&a, 3);
push(&a, 30);
cout << "Linked List before sorting \n";

printList(a);
quickSort(&a);
cout << "Linked List after sorting \n";

printList(a);
return 0;
}

Output:

30 3 4 20 5
3 4 5 20 30

This article is contributed by Balasubramanian.N . Please write comments if you find anything incorrect,
Print all possible strings of length k that can be formed from a set of n
characters
Given a set of characters and a positive integer k, print all possible strings of length k that can be formed
from the given set.
Examples:
Input:
set[] = {'a', 'b'}, k = 3
Output:
aaa
aab
aba
abb
baa
bab
bba
bbb
Input:
set[] = {'a', 'b', 'c', 'd'}, k = 1
Output:
a
b
c
d

For a given set of size n, there will be n^k possible strings of length k. The idea is to start from an empty
output string (we call it prefix in following code). One by one add all characters to prefix. For every character
added, print all possible strings with current prefix by recursively calling for k equals to k-1.
Following is Java implementation for same.

// Java program to print all possible strings of length k

class PrintAllKLengthStrings {
// Driver method to test below methods

System.out.println("First Test");
char set1[] = {'a', 'b'};
int k = 3;
printAllKLength(set1, k);

System.out.println("\nSecond Test");
char set2[] = {'a', 'b', 'c', 'd'};
k = 1;
printAllKLength(set2, k);
}
// The method that prints all possible strings of length k. It is

// mainly a wrapper over recursive function printAllKLengthRec()
static void printAllKLength(char set[], int k) {
int n = set.length;
printAllKLengthRec(set, "", n, k);
}
// The main recursive method to print all possible strings of length k

static void printAllKLengthRec(char set[], String prefix, int n, int k) {

// Base case: k is 0, print prefix
if (k == 0) {
System.out.println(prefix);
return;
}
// One by one add all characters from set and recursively

// call for k equals to k-1
for (int i = 0; i < n; ++i) {

// Next character of input added
String newPrefix = prefix + set[i];

// k is decreased, because we have added a new character
printAllKLengthRec(set, newPrefix, n, k - 1);
}
}
}

Output:

First Test
aaa
aab
aba
abb
baa
bab
bba
bbb
Second Test
a
b
c
d

The above solution is mainly generalization of this post.
This article is contriibuted by Abhinav Ramana. Please write comments if you find anything incorrect, or
Given a Binary Tree (BT), convert it to a Doubly Linked List(DLL). The left and right pointers in nodes are to
be used as previous and next pointers respectively in converted DLL. The order of nodes in DLL must be
same as Inorder of the given Binary Tree. The first node of Inorder traversal (left most node in BT) must be
head node of the DLL.
A solution to this problem is discussed in this post.

In this post, another simple and efficient solution is discussed. The solution discussed here has two simple
steps.
1) Fix Left Pointers : In this step, we change left pointers to point to previous nodes in DLL. The idea is
simple, we do inorder traversal of tree. In inorder traversal, we keep track of previous visited node and
change left pointer to the previous node. See fixPrevPtr() in below implementation.
2) Fix Right Pointers : The above is intuitive and simple. How to change right pointers to point to next
node in DLL? The idea is to use left pointers fixed in step 1. We start from the rightmost node in Binary Tree
(BT). The rightmost node is the last node in DLL. Since left pointers are changed to point to previous node
in DLL, we can linearly traverse the complete DLL using these pointers. The traversal would be from last to
first node. While traversing the DLL, we keep track of the previously visited node and change the right
pointer to the previous node. See fixNextPtr() in below implementation.
// A simple inorder traversal based program to convert a Binary Tree to DLL

#include<stdio.h>
#include<stdlib.h>
// A tree node
struct node
{
int data;
};

struct node *newNode(int data)
{
struct node *node = (struct node *)malloc(sizeof(struct node));
node->data = data;
return(node);
}
// Standard Inorder traversal of tree

// Standard Inorder traversal of tree
{
if (root != NULL)
{
printf("\t%d",root->data);
}
}
// Changes left pointers to work as previous pointers in converted DLL

// The function simply does inorder traversal of Binary Tree and updates
// left pointer using previously visited node
void fixPrevPtr(struct node *root)
{
static struct node *pre = NULL;
if (root != NULL)
{
fixPrevPtr(root->left);
root->left = pre;
pre = root;
fixPrevPtr(root->right);
}
}
// Changes right pointers to work as next pointers in converted DLL

struct node *fixNextPtr(struct node *root)
{
// Find the right most node in BT or last node in DLL

while (root && root->right != NULL)
root = root->right;
// Start from the rightmost node, traverse back using left pointers.
// While traversing, change right pointer of nodes.
while (root && root->left != NULL)
{
prev = root;
root = root->left;
root->right = prev;
}
// The leftmost node is head of linked list, return it

return (root);
}
// The main function that converts BST to DLL and returns head of DLL
struct node *BTToDLL(struct node *root)
{
// Set the previous pointer
fixPrevPtr(root);
// Set the next pointer and return head of DLL

return fixNextPtr(root);
}
// Traverses the DLL from left tor right

void printList(struct node *root)
{
{
printf("\t%d", root->data);
printf("\t%d", root->data);
root = root->right;
}
}

int main(void)
{
printf("\n\t\tInorder Tree Traversal\n\n");

inorder(root);
struct node *head = BTToDLL(root);
printf("\n\n\t\tDLL Traversal\n\n");
printList(head);
return 0;
}

Output:
Inorder Tree Traversal
25 12 30 10 36 15
DLL Traversal
25 12 30 10 36 15

Time Complexity: O(n) where n is the number of nodes in given Binary Tree. The solution simply does two
traversals of all Binary Tree nodes.
This article is contributed by Bala. Please write comments if you find anything incorrect, or you want to
Print ancestors of a given binary tree node without recursion
Given a Binary Tree and a key, write a function that prints all the ancestors of the key in the given binary
tree.
For example, consider the following Binary Tree
1
/ \
2 3
/ \ / \
4 5 6 7
/ \ /
8 9 10

Following are different input keys and their ancestors in the above tree
Input Key List of Ancestors

-------------------------
1
2 1
3 1
4 2 1
5 2 1
6 3 1
7 3 1
8 4 2 1
9 5 2 1
10 7 3 1

Recursive solution for this problem is discussed here.

It is clear that we need to use a stack based iterative traversal of the Binary Tree. The idea is to have all
ancestors in stack when we reach the node with given key. Once we reach the key, all we have to do is, print
contents of stack.
How to get all ancestors in stack when we reach the given node? We can traverse all nodes in Postorder way.
If we take a closer look at the recursive postorder traversal, we can easily observe that, when recursive
function is called for a node, the recursion call stack contains ancestors of the node. So idea is do iterative
Postorder traversal and stop the traversal when we reach the desired node.
// C program to print all ancestors of a given key

#include <stdio.h>
#include <stdlib.h>

// Structure for a tree node

struct Node
{
{
int data;
};
// Structure for Stack

struct Stack
{
int size;
int top;
};

{
node->data = data;
return node;
}

{
struct Stack* stack = (struct Stack*) malloc(sizeof(struct Stack));
stack->size = size;
stack->top = -1;
stack->array = (struct Node**) malloc(stack->size * sizeof(struct Node*));
return stack;
}

{
return ((stack->top + 1) == stack->size);
}
{
return stack->top == -1;
}
{
if (isFull(stack))
return;
}
{
if (isEmpty(stack))
return NULL;
}
struct Node* peek(struct Stack* stack)
{
if (isEmpty(stack))
return NULL;
return stack->array[stack->top];
}
// Iterative Function to print all ancestors of a given key

void printAncestors(struct Node *root, int key)
{
// Create a stack to hold ancestors
struct Stack* stack = createStack(MAX_SIZE);
// Traverse the complete tree in postorder way till we find the key
while (1)
{
// Traverse the left side. While traversing, push the nodes into
// the stack so that their right subtrees can be traversed later
while (root && root->data != key)
{
push(stack, root); // push current node
root = root->left; // move to next node
}
// If the node whose ancestors are to be printed is found,

// then break the while loop.
if (root && root->data == key)
break;
// Check if right sub-tree exists for the node at top

// If not then pop that node because we don't need this
// node any more.
if (peek(stack)->right == NULL)
{
root = pop(stack);
// If the popped node is right child of top, then remove the top
// as well. Left child of the top must have processed before.
// Consider the following tree for example and key = 3. If we
// remove the following loop, the program will go in an
// infinite loop after reaching 5.
// 1
// / \
// 2 3
// \
// 4
// \
// 5
while (!isEmpty(stack) && peek(stack)->right == root)
root = pop(stack);
}
// if stack is not empty then simply set the root as right child
// of top and start traversing right sub-tree.
root = isEmpty(stack)? NULL: peek(stack)->right;
}
// If stack is not empty, print contents of stack

// Here assumption is that the key is there in tree
while (!isEmpty(stack))
printf("%d ", pop(stack)->data);
}

int main()
{
// Let us construct a binary tree
struct Node* root = newNode(1);
printf("Following are all keys and their ancestors\n");

for (int key = 1; key <= 10; key++)
{
printf("%d: ", key);
printAncestors(root, key);
printf("\n");
}
getchar();
return 0;
}

Output:

Following are all keys and their ancestors
1:
2: 1
3: 1
4: 2 1
5: 2 1
6: 3 1
7: 3 1
8: 4 2 1
9: 5 2 1
10: 7 3 1

Exercise
Note that the above solution assumes that the given key is present in the given Binary Tree. It may go in
infinite loop if key is not present. Extend the above solution to work even when the key is not present in tree.
This article is contrubuted by Chandra Prakash. Please write comments if you find anything incorrect, or
Find the minimum element in a sorted and rotated array
A sorted array is rotated at some unknown point, find the minimum element in it.
Following solution assumes that all elements are distinct.
Examples
Input: {5, 6, 1, 2, 3, 4}
Output: 1
Input: {1, 2, 3, 4}
Output: 1
Input: {2, 1}
Output: 1

A simple solution is to traverse the complete array and find minimum. This solution requires Θ(n) time.
We can do it in O(Logn) using Binary Search. If we take a closer look at above examples, we can easily figure
out following pattern: The minimum element is the only element whose previous element is greater than it.
If there is no such element, then there is no rotation and first element is the minimum element. Therefore,
we do binary search for an element which is smaller than the previous element. We strongly recommend you
to try it yourself before seeing the following C implementation.
// C program to find minimum element in a sorted and rotated array

#include <stdio.h>
int findMin(int arr[], int low, int high)

{
// This condition is needed to handle the case when array is not
// rotated at all
if (high < low) return arr[0];
// If there is only one element left

if (high == low) return arr[low];
// Find mid
int mid = low + (high - low)/2; /*(low + high)/2;*/
// Check if element (mid+1) is minimum element. Consider

// the cases like {3, 4, 5, 1, 2}
if (mid < high && arr[mid+1] < arr[mid])
return arr[mid+1];
// Check if mid itself is minimum element

return arr[mid];
// Decide whether we need to go to left half or right half

if (arr[high] > arr[mid])
return findMin(arr, low, mid-1);
return findMin(arr, mid+1, high);
}

int main()
int main()
{
int arr1[] = {5, 6, 1, 2, 3, 4};
int n1 = sizeof(arr1)/sizeof(arr1[0]);
printf("The minimum element is %d\n", findMin(arr1, 0, n1-1));
int arr2[] = {1, 2, 3, 4};

int arr3[] = {1};

int arr4[] = {1, 2};

int arr5[] = {2, 1};

int arr6[] = {5, 6, 7, 1, 2, 3, 4};

int arr7[] = {1, 2, 3, 4, 5, 6, 7};

int arr8[] = {2, 3, 4, 5, 6, 7, 8, 1};

int arr9[] = {3, 4, 5, 1, 2};

return 0;
}

Output:

The minimum element is 1

How to handle duplicates?

It turned out that duplicates can’t be handled in O(Logn) time in all cases. Thanks to Amit Jain for inputs.
The special cases that cause problems are like {2, 2, 2, 2, 2, 2, 2, 2, 0, 1, 1, 2} and {2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2,
2}. It doesn’t look possible to go to left half or right half by doing constant number of comparisons at the
middle. Following is an implementation that handles duplicates. It may become O(n) in worst case though.

// C program to find minimum element in a sorted and rotated array

#include <stdio.h>
int min(int x, int y) { return (x < y)? x :y; }
// The function that handles duplicates. It can be O(n) in worst case.

int findMin(int arr[], int low, int high)
{
// This condition is needed to handle the case when array is not
// rotated at all
if (high < low) return arr[0];
// If there is only one element left

if (high == low) return arr[low];
// Find mid
int mid = low + (high - low)/2; /*(low + high)/2;*/
// Check if element (mid+1) is minimum element. Consider

// the cases like {1, 1, 0, 1}
if (mid < high && arr[mid+1] < arr[mid])
return arr[mid+1];
// This case causes O(n) time

if (arr[low] == arr[mid] && arr[high] == arr[mid])
return min(findMin(arr, low, mid-1), findMin(arr, mid+1, high));
// Check if mid itself is minimum element

return arr[mid];
// Decide whether we need to go to left half or right half

if (arr[high] > arr[mid])
return findMin(arr, low, mid-1);
return findMin(arr, mid+1, high);
}

int main()
{
int arr1[] = {5, 6, 1, 2, 3, 4};
int arr2[] = {1, 1, 0, 1};

int arr3[] = {1, 1, 2, 2, 3};

int arr4[] = {3, 3, 3, 4, 4, 4, 4, 5, 3, 3};

int arr5[] = {2, 2, 2, 2, 2, 2, 2, 2, 0, 1, 1, 2};

int arr6[] = {2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1};

int arr7[] = {2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2};

return 0;
}

Output:


This article is contributed by Abhay Rathi. Please write comments if you find anything incorrect, or you
Ford-Fulkerson Algorithm for Maximum Flow Problem
Given a graph which represents a flow network where every edge has a capacity. Also given two vertices
source ‘s’ and sink ‘t’ in the graph, find the maximum possible flow from s to t with following constraints:
a) Flow on an edge doesn’t exceed the given capacity of the edge.
b) Incoming flow is equal to outgoing flow for every vertex except s and t.
For example, consider the following graph from CLRS book.
The maximum possible flow in the above graph is 23.
Ford-Fulkerson Algorithm
The following is simple idea of Ford-Fulkerson algorithm:
1) Start with initial flow as 0.
2) While there is a augmenting path from source to sink.
Add this path-flow to flow.
3) Return flow.

Time Complexity: Time complexity of the above algorithm is O(max_flow * E). We run a loop while there
is an augmenting path. In worst case, we may add 1 unit flow in every iteration. Therefore the time
complexity becomes O(max_flow * E).
How to implement the above simple algorithm?

Let us first define the concept of Residual Graph which is needed for understanding the implementation.
Residual Graph of a flow network is a graph which indicates additional possible flow. If there is a path
from source to sink in residual graph, then it is possible to add flow. Every edge of a residual graph has a
value called residual capacity which is equal to original capacity of the edge minus current flow. Residual
capacity is basically the current capacity of the edge.
Let us now talk about implementation details. Residual capacity is 0 if there is no edge between to vertices
of residual graph. We can initialize the residual graph as original graph as there is no initial flow and initially
residual capacity is equal to original capacity. To find an augmenting path, we can either do a BFS or DFS of
the residual graph. We have used BFS in below implementation. Using BFS, we can find out if there is a path
from source to sink. BFS also builds parent[] array. Using the parent[] array, we traverse through the found
path and find possible flow through this path by finding minimum residual capacity along the path. We later
add the found path flow to overall flow.
The important thing is, we need to update residual capacities in the residual graph. We subtract path flow
from all edges along the path and we add path flow along the reverse edges We need to add path flow along
reverse edges because may later need to send flow in reverse direction (See following video for example).
http://www.youtube.com/watch?v=-8MwfgB-lyM
Following is C++ implementation of Ford-Fulkerson algorithm. To keep things simple, graph is represented
as a 2D matrix.
// C++ program for implementation of Ford Fulkerson algorithm

#include <iostream>
#include <limits.h>
#include <string.h>
#include <queue>
// Number of vertices in given graph

#define V 6
/* Returns true if there is a path from source 's' to sink 't' in

residual graph. Also fills parent[] to store the path */
bool bfs(int rGraph[V][V], int s, int t, int parent[])
{
// Create a visited array and mark all vertices as not visited
bool visited[V];
// Create a queue, enqueue source vertex and mark source vertex

// as visited
queue <int> q;
q.push(s);
visited[s] = true;
parent[s] = -1;
// Standard BFS Loop

while (!q.empty())
{
int u = q.front();
q.pop();
for (int v=0; v<V; v++)

{
if (visited[v]==false && rGraph[u][v] > 0)
{
q.push(v);
parent[v] = u;
visited[v] = true;
}
}
}
// If we reached sink in BFS starting from source, then return

// true, else false
return (visited[t] == true);
}
// Returns tne maximum flow from s to t in the given graph
int fordFulkerson(int graph[V][V], int s, int t)
{
int u, v;
// Create a residual graph and fill the residual graph with

// given capacities in the original graph as residual capacities
// in residual graph
int rGraph[V][V]; // Residual graph where rGraph[i][j] indicates
// residual capacity of edge from i to j (if there
// is an edge. If rGraph[i][j] is 0, then there is not)
for (u = 0; u < V; u++)
for (v = 0; v < V; v++)
rGraph[u][v] = graph[u][v];
int parent[V]; // This array is filled by BFS and to store path
int max_flow = 0; // There is no flow initially
// Augment the flow while tere is path from source to sink

while (bfs(rGraph, s, t, parent))
{
// Find minimum residual capacity of the edhes along the
// path filled by BFS. Or we can say find the maximum flow
// through the path found.
int path_flow = INT_MAX;
for (v=t; v!=s; v=parent[v])
{
u = parent[v];
path_flow = min(path_flow, rGraph[u][v]);
}
// update residual capacities of the edges and reverse edges

// along the path
for (v=t; v != s; v=parent[v])
{
u = parent[v];
rGraph[u][v] -= path_flow;
rGraph[v][u] += path_flow;
}
// Add path flow to overall flow

max_flow += path_flow;
}
// Return the overall flow

return max_flow;
}

int main()
{
// Let us create a graph shown in the above example
int graph[V][V] = { {0, 16, 13, 0, 0, 0},
{0, 0, 10, 12, 0, 0},
{0, 4, 0, 0, 14, 0},
{0, 0, 9, 0, 0, 20},
{0, 0, 0, 7, 0, 4},
{0, 0, 0, 0, 0, 0}
};
cout << "The maximum possible flow is " << fordFulkerson(graph, 0, 5);
return 0;
return 0;
}

Output:

The maximum possible flow is 23

The above implementation of Ford Fulkerson Algorithm is called Edmonds-Karp Algorithm. The idea of
Edmonds-Karp is to use BFS in Ford Fulkerson implementation as BFS always picks a path with minimum
number of edges. When BFS is used, the worst case time complexity can be reduced to O(VE 2). The above
implementation uses adjacency matrix representation though where BFS takes O(V2) time, the time
complexity of the above implementation is O(EV3) (Refer CLRS book for proof of time complexity)
This is an important problem as it arises in many practical situations. Examples include, maximizing the
transportation with given traffic limits, maximizing packet flow in computer networks.
Exercise:
Modify the above implementation so that it that runs in O(VE 2) time.
References:
http://www.stanford.edu/class/cs97si/08-network-flow-problems.pdf
L. Rivest
discussed above.
Dynamic Programming | Set 34 (Assembly Line Scheduling)
A car factory has two assembly lines, each with n stations. A station is denoted by S where i is either 1 or 2
i,j
and indicates the assembly line the station is on, and j indicates the number of the station. The time taken
per station is denoted by ai,j. Each station is dedicated to some sort of work like engine fitting, body fitting,
painting and so on. So, a car chassis must pass through each of the n stations in order before exiting the
factory. The parallel stations of the two assembly lines perform the same task. After it passes through station
Si,j, it will continue to station Si,j+1 unless it decides to transfer to the other line. Continuing on the same line
incurs no extra cost, but transferring from line i at station j – 1 to station j on the other line takes time ti,j.
Each assembly line takes an entry time ei and exit time x which may be different for the two lines. Give an
i
algorithm for computing the minimum time it will take to build a car chassis.
The below figure presents the problem in a clear picture:
The following information can be extracted from the problem statement to make it simpler:
Two assembly lines, 1 and 2, each with stations from 1 to n.

A car chassis must pass through all stations from 1 to n in order(in any of the two assembly lines). i.e.
it cannot jump from station i to station j if they are not at one move distance.
The car chassis can move one station forward in the same line, or one station diagonally in the other
line. It incurs an extra cost ti, j to move to station j from line i. No cost is incurred for movement in
same line.
The time taken in station j on line i is ai, j.
Si, j represents a station j on line i.
Breaking the problem into smaller sub-problems:

We can easily find the ith factorial if (i-1)th factorial is known. Can we apply the similar funda here?
If the minimum time taken by the chassis to leave station Si, j-1 is known, the minimum time taken to leave
station Si, j can be calculated quickly by combining ai, j and ti, j.
T1(j) indicates the minimum time taken by the car chassis to leave station j on assembly line 1.
T2(j) indicates the minimum time taken by the car chassis to leave station j on assembly line 2.
Base cases:
The entry time ei comes into picture only when the car chassis enters the car factory.
Time taken to leave first station in line 1 is given by:

T1(1) = Entry time in Line 1 + Time spent in station S1,1
T1(1) = e1 + a1,1
Similarly, time taken to leave first station in line 2 is given by:
T2(1) = e 2 + a2,1
Recursive Relations:
If we look at the problem statement, it quickly boils down to the below observations:
The car chassis at station S1,j can come either from station S1, j-1 or station S2, j-1.
Case #1: Its previous station is S1, j-1

The minimum time to leave station S1,j is given by:
T1(j) = Minimum time taken to leave station S1, j-1 + Time spent in station S1, j
T1(j) = T1(j-1) + a1, j
Case #2: Its previous station is S2, j-1

The minimum time to leave station S1, j is given by:
T1(j) = Minimum time taken to leave station S2, j-1 + Extra cost incurred to change the assembly line + Time
spent in station S1, j
T1(j) = T2(j-1) + t2, j + a1, j
The minimum time T1(j) is given by the minimum of the two obtained in cases #1 and #2.
T1(j) = min((T1(j-1) + a1, j ), (T2(j-1) + t2, j + a1, j ))
Similarly the minimum time to reach station S2, j is given by:
T2(j) = min((T2(j-1) + a2, j), (T1(j-1) + t1, j + a2, j))
The total minimum time taken by the car chassis to come out of the factory is given by:
Tmin = min(Time taken to leave station S i,n + Time taken to exit the car factory)
Tmin = min(T1(n) + x1, T2(n) + x2)
Why dynamic programming?

The above recursion exhibits overlapping sub-problems. There are two ways to reach station S1, j :
1. From station S1, j-1

So, to find the minimum time to leave station S1, j the minimum time to leave the previous two stations must
be calculated(as explained in above recursion).
Similarly, there are two ways to reach station S2, j:

Please note that the minimum times to leave stations S1, j-1 and S2, j-1 have already been calculated.
So, we need two tables to store the partial results calculated for each station in an assembly line. The table
will be filled in bottom-up fashion.
Note:
In this post, the word “leave” has been used in place of “reach” to avoid the confusion. Since the car chassis
must spend a fixed time in each station, the word leave suits better.
Implementation:

// A C program to find minimum possible time by the car chassis to complete

#include <stdio.h>
#define NUM_LINE 2
#define NUM_STATION 4
// Utility function to find minimum of two numbers

int min(int a, int b) { return a < b ? a : b; }
int carAssembly(int a[][NUM_STATION], int t[][NUM_STATION], int *e, int *x)

{
int T1[NUM_STATION], T2[NUM_STATION], i;
T1[0] = e[0] + a[0][0]; // time taken to leave first station in line 1

T2[0] = e[1] + a[1][0]; // time taken to leave first station in line 2
// Fill tables T1[] and T2[] using the above given recursive relations
for (i = 1; i < NUM_STATION; ++i)
{
T1[i] = min(T1[i-1] + a[0][i], T2[i-1] + t[1][i] + a[0][i]);
T2[i] = min(T2[i-1] + a[1][i], T1[i-1] + t[0][i] + a[1][i]);
}
// Consider exit times and retutn minimum

return min(T1[NUM_STATION-1] + x[0], T2[NUM_STATION-1] + x[1]);
}
int main()
{
int a[][NUM_STATION] = {{4, 5, 3, 2},
{2, 10, 1, 4}};
int t[][NUM_STATION] = {{0, 7, 4, 5},
{0, 9, 2, 8}};
int e[] = {10, 12}, x[] = {18, 7};
printf("%d", carAssembly(a, t, e, x));
return 0;
}

Output:

35

The bold line shows the path covered by the car chassis for given input values.
Exercise:
Extend the above algorithm to print the path covered by the car chassis in the factory.
References:
L. Rivest
Dynamic Programming | Set 35 (Longest Arithmetic Progression)
Given a set of numbers, find the L ength of the Longest Arithmetic Progression (LLAP) in it.
Examples:
set[] = {1, 7, 10, 15, 27, 29}

output = 3
The longest arithmetic progression is {1, 15, 29}
set[] = {5, 10, 15, 20, 25, 30}

output = 6
The whole set is in AP

For simplicity, we have assumed that the given set is sorted. We can always add a pre-processing step to first
sort the set and then apply the below algorithms.
A simple solution is to one by one consider every pair as first two elements of AP and check for the
remaining elements in sorted set. To consider all pairs as first two elements, we need to run a O(n^2) nested
loop. Inside the nested loops, we need a third loop which linearly looks for the more elements in Arithmetic
Progression (AP). This process takes O(n3) time.
We can solve this problem in O(n2) time using Dynamic Programming. To get idea of the DP solution,
let us first discuss solution of following simpler problem.
Given a sorted set, find if there exist three elements in Arithmetic Progression or not
Please note that, the answer is true if there are 3 or more elements in AP, otherwise false.
To find the three elements, we first fix an element as middle element and search for other two (one smaller
and one greater). We start from the second element and fix every element as middle element. For an element
set[j] to be middle of AP, there must exist elements ‘set[i]’ and ‘set[k]’ such that set[i] + set[k] = 2*set[j]
where 0 How to efficiently find i and k for a given j? We can find i and k in linear time using following simple
algorithm.
1) Initialize i as j-1 and k as j+1
2) Do following while i >= 0 and j a) If set[i] + set[k] is equal to 2*set[j], then we are done.
……..b) If set[i] + set[k] > 2*set[j], then decrement i (do i–-).
……..c) Else if set[i] + set[k] // The function returns true if there exist three elements in AP // Assumption:
set[0..n-1] is sorted. // The code strictly implements the algorithm provided in the reference. bool
arithmeticThree(int set[], int n) { // One by fix every element as middle element for (int j=1; j<n-1; j++) { //
Initialize i and k for the current j int i = j-1, k = j+1; // Find if there exist i and k that form AP // with j as
middle element while (i >= 0 && k <= n-1) { if (set[i] + set[k] == 2*set[j]) return true; (set[i] + set[k] <
2*set[j])? k++ : i–; } } return false; }
See this for a complete running program.
How to extend the above solution for the original problem?

The above function returns a boolean value. The required output of original problem is Length of the
Longest Arithmetic Progression (LLAP) which is an integer value. If the given set has two or more
elements, then the value of LLAP is at least 2 (Why?).
The idea is to create a 2D table L[n][n]. An entry L[i][j] in this table stores LLAP with set[i] and set[j] as
first two elements of AP and j > i. The last column of the table is always 2 (Why – see the meaning of L[i][j]).
Rest of the table is filled from bottom right to top left. To fill rest of the table, j (second element in AP) is first
fixed. i and k are searched for a fixed j. If i and k are found such that i, j, k form an AP, then the value of L[i]
[j] is set as L[j][k] + 1. Note that the value of L[j][k] must have been filled before as the loop traverses from
right to left columns.
Following is C++ implementation of the Dynamic Programming algorithm.
// C++ program to find Length of the Longest AP (llap) in a given sorted set.
// The code strictly implements the algorithm provided in the reference.
#include <iostream>
// Returns length of the longest AP subset in a given set

int lenghtOfLongestAP(int set[], int n)
{
if (n <= 2) return n;
// Create a table and initialize all values as 2. The value of

// L[i][j] stores LLAP with set[i] and set[j] as first two
// elements of AP. Only valid entries are the entries where j>i
int L[n][n];
int llap = 2; // Initialize the result
// Fill entries in last column as 2. There will always be

// two elements in AP with last number of set as second
// element in AP
for (int i = 0; i < n; i++)
L[i][n-1] = 2;
// Consider every element as second element of AP

for (int j=n-2; j>=1; j--)
{
// Search for i and k for j
int i = j-1, k = j+1;
while (i >= 0 && k <= n-1)
{
if (set[i] + set[k] < 2*set[j])
k++;
// Before changing i, set L[i][j] as 2

else if (set[i] + set[k] > 2*set[j])
{ L[i][j] = 2, i--; }
else
{
// Found i and k for j, LLAP with i and j as first two
// elements is equal to LLAP with j and k as first two
// elements plus 1. L[j][k] must have been filled
// before as we run the loop from right side
L[i][j] = L[j][k] + 1;
// Update overall LLAP, if needed

llap = max(llap, L[i][j]);
// Change i and k to fill more L[i][j] values for

// current j
i--; k++;
}
}
// If the loop was stopped due to k becoming more than

// n-1, set the remaining entties in column j as 2
while (i >= 0)
{
L[i][j] = 2;
L[i][j] = 2;
i--;
}
}
return llap;
}

int main()
{
int set1[] = {1, 7, 10, 13, 14, 19};
int n1 = sizeof(set1)/sizeof(set1[0]);
cout << lenghtOfLongestAP(set1, n1) << endl;
int set2[] = {1, 7, 10, 15, 27, 29};

int set3[] = {2, 4, 6, 8, 10};

return 0;
}

Output:

4
3
5


Auxiliary Space: O(n2)
References:
http://www.cs.uiuc.edu/~jeffe/pubs/pdf/arith.pdf
discussed above
How to check if two given line segments intersect?
Given two line segments (p1, q1) and (p2, q2), find if the given line segments intersect with each other.
Before we discuss solution, let us define notion of orientation. Orientation of an ordered triplet of points in
the plane can be
–counterclockwise
–clockwise
–colinear
The following diagram shows different possible orientations of (a, b, c)
Note the word ‘ordered’ here. Orientation of (a, b, c) may be different from orientation of (c, b, a).
How is Orientation useful here?

Two segments (p1,q1) and (p2,q2) intersect if and only if one of the following two conditions is verified
1. General Case:
– (p1, q1, p2) and (p1, q1, q2) have different orientations and
– (p2, q2, p1) and (p2, q2, q1) have different orientations
2. Special Case
– (p1, q1, p2), (p1, q1, q2), (p2, q2, p1), and (p2, q2, q1) are all collinear and
– the x-projections of (p1, q1) and (p2, q2) intersect
– the y-projections of (p1, q1) and (p2, q2) intersect
Examples of General Case:
Examples of Special Case:

Following is C++ implementation based on above idea.
// A C++ program to check if two given line segments intersect

#include <iostream>
struct Point
{
int x;
int y;
};
// Given three colinear points p, q, r, the function checks if

// point q lies on line segment 'pr'
bool onSegment(Point p, Point q, Point r)
{
if (q.x <= max(p.x, r.x) && q.x >= min(p.x, r.x) &&
q.y <= max(p.y, r.y) && q.y >= min(p.y, r.y))
return true;
return false;
}
// To find orientation of ordered triplet (p, q, r).

// The function returns following values
// 0 --> p, q and r are colinear
// 1 --> Clockwise
// 2 --> Counterclockwise
int orientation(Point p, Point q, Point r)
{
// See 10th slides from following link for derivation of the formula
// http://www.dcs.gla.ac.uk/~pat/52233/slides/Geometry1x1.pdf
int val = (q.y - p.y) * (r.x - q.x) -
(q.x - p.x) * (r.y - q.y);
if (val == 0) return 0; // colinear
return (val > 0)? 1: 2; // clock or counterclock wise

}
// The main function that returns true if line segment 'p1q1'

// and 'p2q2' intersect.
bool doIntersect(Point p1, Point q1, Point p2, Point q2)
{
// Find the four orientations needed for general and
// special cases
int o1 = orientation(p1, q1, p2);
int o2 = orientation(p1, q1, q2);
// General case
if (o1 != o2 && o3 != o4)
if (o1 != o2 && o3 != o4)
return true;
// Special Cases
// p1, q1 and p2 are colinear and p2 lies on segment p1q1
if (o1 == 0 && onSegment(p1, p2, q1)) return true;
// p1, q1 and p2 are colinear and q2 lies on segment p1q1

if (o2 == 0 && onSegment(p1, q2, q1)) return true;

// p2, q2 and q1 are colinear and q1 lies on segment p2q2

return false; // Doesn't fall in any of the above cases

}

int main()
{
struct Point p1 = {1, 1}, q1 = {10, 1};
struct Point p2 = {1, 2}, q2 = {10, 2};
doIntersect(p1, q1, p2, q2)? cout << "Yes\n": cout << "No\n";
p1 = {10, 0}, q1 = {0, 10};

p2 = {0, 0}, q2 = {10, 10};
p1 = {-5, -5}, q1 = {0, 0};

p2 = {1, 1}, q2 = {10, 10};
return 0;
}

Output:

No
Yes
No

Sources:
http://www.dcs.gla.ac.uk/~pat/52233/slides/Geometry1x1.pdf
L. Rivest
discussed above
How to check if a given point lies inside or outside a polygon?
Given a polygon and a point ‘p’, find if ‘p’ lies inside the polygon or not. The points lying on the border are
considered inside.
We strongly recommend to see the following post first.

Following is a simple idea to check whether a point is inside or outside.
1) Draw a horizontal line to the right of each point and extend it to infinity
1) Count the number of times the line intersects with polygon edges.
2) A point is inside the polygon if either count of intersections is odd or

point lies on an edge of polygon. If none of the conditions is true, then
point lies outside.

How to handle point ‘g’ in the above figure?

Note that we should returns true if the point lies on the line or same as one of the vertices of the given
polygon. To handle this, after checking if the line from ‘p’ to extreme intersects, we check whether ‘p’ is
colinear with vertices of current line of polygon. If it is coliear, then we check if the point ‘p’ lies on current
side of polygon, if it lies, we return true, else false.
Following is C++ implementation of the above idea.
// A C++ program to check if a given point lies inside a given polygon

// Refer http://www.geeksforgeeks.org/check-if-two-given-line-segments-intersect/
// for explanation of functions onSegment(), orientation() and doIntersect()
#include <iostream>
#include <iostream>
// Define Infinite (Using INT_MAX caused overflow problems)

#define INF 10000
struct Point
{
int x;
int y;
};
// Given three colinear points p, q, r, the function checks if

// point q lies on line segment 'pr'
bool onSegment(Point p, Point q, Point r)
{
if (q.x <= max(p.x, r.x) && q.x >= min(p.x, r.x) &&
q.y <= max(p.y, r.y) && q.y >= min(p.y, r.y))
return true;
return false;
}

// 1 --> Clockwise
{
int val = (q.y - p.y) * (r.x - q.x) -
(q.x - p.x) * (r.y - q.y);

}
// The function that returns true if line segment 'p1q1'

// and 'p2q2' intersect.
bool doIntersect(Point p1, Point q1, Point p2, Point q2)
{
// Find the four orientations needed for general and
// special cases
// General case
if (o1 != o2 && o3 != o4)
return true;
// Special Cases
// p1, q1 and p2 are colinear and q2 lies on segment p1q1


// p2, q2 and q1 are colinear and q1 lies on segment p2q2


}
// Returns true if the point p lies inside the polygon[] with n vertices
bool isInside(Point polygon[], int n, Point p)
{
// There must be at least 3 vertices in polygon[]
if (n < 3) return false;
// Create a point for line segment from p to infinite

Point extreme = {INF, p.y};
// Count intersections of the above line with sides of polygon

int count = 0, i = 0;
do
{
int next = (i+1)%n;
// Check if the line segment from 'p' to 'extreme' intersects

// with the line segment from 'polygon[i]' to 'polygon[next]'
if (doIntersect(polygon[i], polygon[next], p, extreme))
{
// If the point 'p' is colinear with line segment 'i-next',
// then check if it lies on segment. If it lies, return true,
// otherwise false
if (orientation(polygon[i], p, polygon[next]) == 0)
return onSegment(polygon[i], p, polygon[next]);
count++;
}
i = next;
} while (i != 0);
// Return true if count is odd, false otherwise

return count&1; // Same as (count%2 == 1)
}

int main()
{
Point polygon1[] = {{0, 0}, {10, 0}, {10, 10}, {0, 10}};
int n = sizeof(polygon1)/sizeof(polygon1[0]);
Point p = {20, 20};
isInside(polygon1, n, p)? cout << "Yes \n": cout << "No \n";
p = {5, 5};
Point polygon2[] = {{0, 0}, {5, 5}, {5, 0}};

p = {3, 3};
n = sizeof(polygon2)/sizeof(polygon2[0]);
p = {5, 1};
p = {8, 1};
Point polygon3[] = {{0, 0}, {10, 0}, {10, 10}, {0, 10}};
p = {-1,10};
n = sizeof(polygon3)/sizeof(polygon3[0]);
return 0;
}

Output:
No
Yes
Yes
Yes
No
No

Time Complexity: O(n) where n is the number of vertices in the given polygon.
Source:
discussed above
Convex Hull | Set 1 (Jarvis’s Algorithm or Wrapping)
Given a set of points in the plane. the convex hull of the set is the smallest convex polygon that contains all
the points of it.

The idea of Jarvis’s Algorithm is simple, we start from the leftmost point (or point with minimum x
coordinate value) and we keep wrapping points in counterclockwise direction. The big question is, given a
point p as current point, how to find the next point in output? The idea is to use orientation() here. Next
point is selected as the point that beats all other points at counterclockwise orientation, i.e., next point is q if
for any other point r, we have “orientation(p, r, q) = counterclockwise”. Following is the detailed algorithm.
1) Initialize p as leftmost point.

2) Do following while we don’t come back to the first (or leftmost) point.
…..a) The next point q is the point such that the triplet (p, q, r) is counterclockwise for any other point r.
…..b) next[p] = q (Store q as next of p in the output convex hull).
…..c) p = q (Set p as q for next iteration).
// A C++ program to find convex hull of a set of points

// for explanation of orientation()
#include <iostream>
// Define Infinite (Using INT_MAX caused overflow problems)

#define INF 10000
struct Point
{
int x;
int y;
};

// 1 --> Clockwise
{
int val = (q.y - p.y) * (r.x - q.x) -
(q.x - p.x) * (r.y - q.y);

}
// Prints convex hull of a set of n points.

void convexHull(Point points[], int n)
{
// There must be at least 3 points
// There must be at least 3 points
if (n < 3) return;
// Initialize Result
int next[n];
for (int i = 0; i < n; i++)
next[i] = -1;
// Find the leftmost point

int l = 0;
for (int i = 1; i < n; i++)
if (points[i].x < points[l].x)
l = i;
// Start from leftmost point, keep moving counterclockwise

// until reach the start point again
int p = l, q;
do
{
// Search for a point 'q' such that orientation(p, i, q) is
// counterclockwise for all points 'i'
q = (p+1)%n;
for (int i = 0; i < n; i++)
if (orientation(points[p], points[i], points[q]) == 2)
q = i;
next[p] = q; // Add q to result as a next point of p

p = q; // Set p as q for next iteration
} while (p != l);
// Print Result
for (int i = 0; i < n; i++)
{
if (next[i] != -1)
cout << "(" << points[i].x << ", " << points[i].y << ")\n";
}
}

int main()
{
Point points[] = {{0, 3}, {2, 2}, {1, 1}, {2, 1},
{3, 0}, {0, 0}, {3, 3}};
int n = sizeof(points)/sizeof(points[0]);
convexHull(points, n);
return 0;
}

Output: The output is points of the convex hull.

(0, 3)
(3, 0)
(0, 0)
(3, 3)

Time Complexity: For every point on the hull we examine all the other points to determine the next point.
Time complexity is Θ(m * n) where n is number of input points and m is number of output or hull points (m
2). The worst case occurs when all the points are on the hull (m = n)
We will soon be discussing other algorithms for finding convex hulls.
Sources:
http://www.cs.uiuc.edu/~jeffe/teaching/373/notes/x05-convexhull.pdf
http://www.dcs.gla.ac.uk/~pat/52233/slides/Hull1x1.pdf
discussed above
Maximum Bipartite Matching
A matching in a Bipartite Graph is a set of the edges chosen in such a way that no two edges share an
endpoint. A maximum matching is a matching of maximum size (maximum number of edges). In other
words, a matching is maximum if any edge is added to it, it is no longer a matching. There can be more than
one maximum matchings for a given Bipartite Graph.
Why do we care?
There are many real world problems that can be formed as Bipartite Matching. For example, consider the
following problem:
There are M job applicants and N jobs. Each applicant has a subset of jobs that he/she is interested in.
Each job opening can only accept one applicant and a job applicant can be appointed for only one job.
Find an assignment of jobs to applicants in such that as many applicants as possible get jobs.
We strongly recommend to read the following post first.
Maximum Bipartite Matching and Max Flow Problem

Maximum Bipartite Matching (MBP) problem can be solved by converting it into a flow network (See this
video to know how did we arrive this conclusion). Following are the steps.
1) Build a Flow Network

There must be a source and sink in a flow network. So we add a source and add edges from source to all
applicants. Similarly, add edges from all jobs to sink. The capacity of every edge is marked as 1 unit.
2) Find the maximum flow.
We use Ford-Fulkerson algorithm to find the maximum flow in the flow network built in step 1. The
maximum flow is actually the MBP we are looking for.
How to implement the above approach?

Let us first define input and output forms. Input is in the form of Edmonds matrix which is a 2D array
‘bpGraph[M][N]’ with M rows (for M job applicants) and N columns (for N jobs). The value bpGraph[i][j] is
1 if i’th applicant is interested in j’th job, otherwise 0.
Output is number maximum number of people that can get jobs.
A simple way to implement this is to create a matrix that represents

adjacency matrix representation of a
directed graph with M+N+2 vertices. Call the fordFulkerson() for the matrix. This implementation requires
O((M+N)*(M+N)) extra space.
Extra space can be be reduced and code can be simplified using the fact that the graph is bipartite and
capacity of every edge is either 0 or 1. The idea is to use DFS traversal to find a job for an applicant (similar
to augmenting path in Ford-Fulkerson). We call bpm() for every applicant, bpm() is the DFS based function
that tries all possibilities to assign a job to the applicant.
In bpm(), we one by one try all jobs that an applicant ‘u’ is interested in until we find a job, or all jobs are
tried without luck. For every job we try, we do following.
If a job is not assigned to anybody, we simply assign it to the applicant and return true. If a job is assigned to
somebody else say x, then we recursively check whether x can be assigned some other job. To make sure that
x doesn’t get the same job again, we mark the job ‘v’ as seen before we make recursive call for x. If x can get
other job, we change the applicant for job ‘v’ and return true. We use an array maxR[0..N-1] that stores the
applicants assigned to different jobs.
If bmp() returns true, then it means that there is an augmenting path in flow network and 1 unit of flow is
added to the result in maxBPM().
// A C++ program to find maximal Bipartite matching.

#include <iostream>
#include <string.h>
// M is number of applicants and N is number of jobs

#define M 6
#define N 6
// A DFS based recursive function that returns true if a

// matching for vertex u is possible
bool bpm(bool bpGraph[M][N], int u, bool seen[], int matchR[])
{
// Try every job one by one
for (int v = 0; v < N; v++)
{
// If applicant u is interested in job v and v is
// not visited
if (bpGraph[u][v] && !seen[v])
{
seen[v] = true; // Mark v as visited
// If job 'v' is not assigned to an applicant OR

// previously assigned applicant for job v (which is matchR[v])
// has an alternate job available.
// Since v is marked as visited in the above line, matchR[v]
// in the following recursive call will not get job 'v' again
if (matchR[v] < 0 || bpm(bpGraph, matchR[v], seen, matchR))
{
matchR[v] = u;
return true;
}
}
}
return false;
}
// Returns maximum number of matching from M to N

int maxBPM(bool bpGraph[M][N])
{
// An array to keep track of the applicants assigned to
// jobs. The value of matchR[i] is the applicant number
// assigned to job i, the value -1 indicates nobody is
// assigned.
int matchR[N];
// Initially all jobs are available

memset(matchR, -1, sizeof(matchR));
int result = 0; // Count of jobs assigned to applicants

for (int u = 0; u < M; u++)
{
// Mark all jobs as not seen for next applicant.
bool seen[N];
memset(seen, 0, sizeof(seen));
// Find if the applicant 'u' can get a job

if (bpm(bpGraph, u, seen, matchR))
result++;
}
return result;
}

int main()
{
// Let us create a bpGraph shown in the above example
bool bpGraph[M][N] = { {0, 1, 1, 0, 0, 0},
{1, 0, 0, 1, 0, 0},
{0, 0, 1, 0, 0, 0},
{0, 0, 1, 1, 0, 0},
{0, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 1}
};
cout << "Maximum number of applicants that can get job is "
<< maxBPM(bpGraph);
return 0;
}

Output:

Maximum number of applicants that can get job is 5

References:
http://www.cs.cornell.edu/~wdtseng/icpc/notes/graph_part5.pdf
http://www.youtube.com/watch?v=NlQqmEXuiC8
http://en.wikipedia.org/wiki/Maximum_matching
http://www.cs.princeton.edu/courses/archive/spring13/cos423/lectures/07NetworkFlowII-2×2.pdf
http://www.ise.ncsu.edu/fangroup/or766.dir/or766_ch7.pdf
discussed above
Find minimum s-t cut in a flow network
In a flow network, an s-t cut is a cut that requires the source ‘s’ and the sink ‘t’ to be in different subsets, and
it consists of edges going from the source’s side to the sink’s side. The capacity of an s-t cut is defined by the
sum of capacity of each edge in the cut-set. (Source: Wiki)
The problem discussed here is to find minimum capacity s-t cut of the given network. Expected output is all
edges of the minimum cut.
For example, in the following flow network, example s-t cuts are {{0 ,1}, {0, 2}}, {{0, 2}, {1, 2}, {1, 3}}, etc.
The minimum s-t cut is {{1, 3}, {4, 3}, {4 5}} which has capacity as 12+7+4 = 23.
We strongly recommend to read the below post first.

Minimum Cut and Maximum Flow

Like Maximum Bipartite Matching, this is another problem which can solved using Ford-Fulkerson
Algorithm. This is based on max-flow min-cut theorem.
The max-flow min-cut theorem states that in a flow network, the amount of maximum flow is equal to
capacity of the minimum cut. See CLRS book for proof of this theorem.
From Ford-Fulkerson, we get capacity of minimum cut. How to print all edges that form the minimum cut?
The idea is to use residual graph.
Following are steps to print all edges of minimum cut.
1) Run Ford-Fulkerson algorithm and consider the final residual graph.
2) Find the set of vertices that are reachable from source in the residual graph.
3) All edges which are from a reachable vertex to non-reachable vertex are minimum cut edges. Print all
such edges.
// C++ program for finding minimum cut using Ford-Fulkerson

#include <iostream>
#include <limits.h>
#include <string.h>
#include <queue>

#define V 6

int bfs(int rGraph[V][V], int s, int t, int parent[])
int bfs(int rGraph[V][V], int s, int t, int parent[])
{
bool visited[V];

// as visited
queue <int> q;
q.push(s);
visited[s] = true;
parent[s] = -1;

while (!q.empty())
{
int u = q.front();
q.pop();

{
{
q.push(v);
parent[v] = u;
visited[v] = true;
}
}
}

// true, else false
}
// A DFS based function to find all reachable vertices from s. The function
// marks visited[i] as true if i is reachable from s. The initial values in
// visited[] must be false. We can also use BFS to find reachable vertices
void dfs(int rGraph[V][V], int s, bool visited[])
{
visited[s] = true;
for (int i = 0; i < V; i++)
if (rGraph[s][i] && !visited[i])
dfs(rGraph, i, visited);
}
// Prints the minimum s-t cut

void minCut(int graph[V][V], int s, int t)
{
int u, v;

int rGraph[V][V]; // rGraph[i][j] indicates residual capacity of edge i-j
for (u = 0; u < V; u++)
for (v = 0; v < V; v++)

{
{
u = parent[v];
}

// along the path
{
u = parent[v];
}
}
// Flow is maximum now, find vertices reachable from s

bool visited[V];
memset(visited, false, sizeof(visited));
dfs(rGraph, s, visited);
// Print all edges that are from a reachable vertex to

// non-reachable vertex in the original graph
for (int i = 0; i < V; i++)
for (int j = 0; j < V; j++)
if (visited[i] && !visited[j] && graph[i][j])
cout << i << " - " << j << endl;
return;
}

int main()
{
int graph[V][V] = { {0, 16, 13, 0, 0, 0},
{0, 0, 10, 12, 0, 0},
{0, 4, 0, 0, 14, 0},
{0, 0, 9, 0, 0, 20},
{0, 0, 0, 7, 0, 4},
{0, 0, 0, 0, 0, 0}
};
minCut(graph, 0, 5);
return 0;
}

Output:

1 - 3
4 - 3
4 - 5

References:
http://www.cs.princeton.edu/courses/archive/spring06/cos226/lectures/maxflow.pdf
discussed above
Stable Marriage Problem
Given N men and N women, where each person has ranked all members of the opposite sex in order of
preference, marry the men and women together such that there are no two people of opposite sex who would
both rather have each other than their current partners. If there are no such people, all the marriages are
“stable” (Source Wiki).
Consider the following example.
Let there be two men m1 and m2 and two women w1 and w2.
Let m1‘s list of preferences be {w1, w2}
Let m2‘s list of preferences be {w1, w2}
Let w1‘s list of preferences be {m1, m2}
Let w2‘s list of preferences be {m1, m2}
The matching { {m1, w2}, {w1, m2} } is not stable because m1 and w1 would prefer each other over their
assigned partners. The matching {m1, w1} and {m2, w2} is stable because there are no two people of opposite
sex that would prefer each other over their assigned partners.
It is always possible to form stable marriages from lists of preferences (See references for proof). Following
is Gale–Shapley algorithm to find a stable matching:
The idea is to iterate through all free men while there is any free man available. Every free man goes to all
women in his preference list according to the order. For every woman he goes to, he checks if the woman is
free, if yes, they both become engaged. If the woman is not free, then the woman chooses either says no to
him or dumps her current engagement according to her preference list. So an engagement done once can be
broken if a woman gets better option.
Following is complete algorithm from Wiki

Initialize all men and women to free
while there exist a free man m who still has a woman w to propose to
{
w = m's highest ranked such woman to whom he has not yet proposed
if w is free
(m, w) become engaged
else some pair (m', w) already exists
if w prefers m to m'
(m, w) become engaged
m' becomes free
else
(m', w) remain engaged
}

Input & Output: Input is a 2D matrix of size (2*N)*N where N is number of women or men. Rows from 0
to N-1 represent preference lists of men and rows from N to 2*N – 1 represent preference lists of women. So
men are numbered from 0 to N-1 and women are numbered from N to 2*N – 1. The output is list of married
pairs.
// C++ program for stable marriage problem

#include <iostream>
#include <string.h>
#include <stdio.h>
// Number of Men or Women

#define N 4
// This function returns true if woman 'w' prefers man 'm1' over man 'm'
bool wPrefersM1OverM(int prefer[2*N][N], int w, int m, int m1)
{
// Check if w prefers m over her current engagment m1
for (int i = 0; i < N; i++)
{
// If m1 comes before m in lisr of w, then w prefers her
// cirrent engagement, don't do anything
if (prefer[w][i] == m1)
return true;
// If m cmes before m1 in w's list, then free her current

// engagement and engage her with m
if (prefer[w][i] == m)
return false;
}
}
// Prints stable matching for N boys and N girls. Boys are numbered as 0 to
// N-1. Girls are numbereed as N to 2N-1.
void stableMarriage(int prefer[2*N][N])
{
// Stores partner of women. This is our output array that
// stores paing information. The value of wPartner[i]
// indicates the partner assigned to woman N+i. Note that
// the woman numbers between N and 2*N-1. The value -1
// indicates that (N+i)'th woman is free
int wPartner[N];
// An array to store availability of men. If mFree[i] is

// false, then man 'i' is free, otherwise engaged.
bool mFree[N];
// Initialize all men and women as free

memset(wPartner, -1, sizeof(wPartner));
memset(mFree, false, sizeof(mFree));
int freeCount = N;
// While there are free men

while (freeCount > 0)
{
// Pick the first free man (we could pick any)
int m;
for (m = 0; m < N; m++)
if (mFree[m] == false)
break;
// One by one go to all women according to m's preferences.

// Here m is the picked free man
for (int i = 0; i < N && mFree[m] == false; i++)
{
int w = prefer[m][i];
// The woman of preference is free, w and m become

// partners (Note that the partnership maybe changed
// later). So we can say they are engaged not married
if (wPartner[w-N] == -1)
{
wPartner[w-N] = m;
mFree[m] = true;
mFree[m] = true;
freeCount--;
}
else // If w is not free

{
// Find current engagement of w
int m1 = wPartner[w-N];
// If w prefers m over her current engagement m1,

// then break the engagement between w and m1 and
// engage m with w.
if (wPrefersM1OverM(prefer, w, m, m1) == false)
{
wPartner[w-N] = m;
mFree[m] = true;
mFree[m1] = false;
}
} // End of Else
} // End of the for loop that goes to all women in m's list
} // End of main while loop

cout << "Woman Man" << endl;
for (int i = 0; i < N; i++)
cout << " " << i+N << "\t" << wPartner[i] << endl;
}

int main()
{
int prefer[2*N][N] = { {7, 5, 6, 4},
{5, 4, 6, 7},
{4, 5, 6, 7},
{4, 5, 6, 7},
{0, 1, 2, 3},
{0, 1, 2, 3},
{0, 1, 2, 3},
{0, 1, 2, 3},
};
stableMarriage(prefer);
return 0;
}

Output:

Woman Man
4 2
5 1
6 3
7 0

References:
http://www.csee.wvu.edu/~ksmani/courses/fa01/random/lecnotes/lecture5.pdf
http://www.youtube.com/watch?v=5RSMLgy06Ew#t=11m4s
discussed above
Convex Hull | Set 2 (Graham Scan)
Given a set of points in the plane. the convex hull of the set is the smallest convex polygon that contains all
the points of it.

We have discussed Jarvis’s Algorithm for Convex Hull. Worst case time complexity of Jarvis’s Algorithm is
O(n^2). Using Graham’s scan algorithm, we can find Convex Hull in O(nLogn) time. Following is Graham’s
algorithm
Let points[0..n-1] be the input array.
1) Find the bottom-most point by comparing y coordinate of all points. If there are two points with same y
value, then the point with smaller x coordinate value is considered. Put the bottom-most point at first
position.
2) Consider the remaining n-1 points and sort them by polor angle in counterclockwise order around
points[0]. If polor angle of two points is same, then put the nearest point first.
3) Create an empty stack ‘S’ and push points[0], points[1] and points[2] to S.
4) Process remaining n-3 points one by one. Do following for every point ‘points[i]’
4.1) Keep removing points from stack while orientation of following 3 points is not counterclockwise (or
they don’t make a left turn).
a) Point next to top in stack
b) Point at the top of stack
c) points[i]
4.2) Push points[i] to S
5) Print contents of S
The above algorithm can be divided in two phases.
Phase 1 (Sort points): We first find the bottom-most point. The idea is to pre-process points be sorting
them with respect to the bottom-most point. Once the points are sorted, they form a simple closed path (See
following diagram).
What should be the sorting criteria? computation of actual angles would be inefficient since trigonometric
functions are not simple to evaluate. The idea is to use the orientation to compare angles without actually
computing them (See the compare() function below)
Phase 2 (Accept or Reject Points): Once we have the closed path, the next step is to traverse the path
and remove concave points on this path. How to decide which point to remove and which to keep? Again,
orientation helps here. The first two points in sorted array are always part of Convex Hull. For remaining
points, we keep track of recent three points, and find the angle formed by them. Let the three points be
prev(p), curr(c) and next(n). If orientation of these points (considering them in same order) is not
counterclockwise, we discard c, otherwise we keep it. Following diagram shows step by step process of this
phase (Source of these diagrams is Ref 2).
// A C++ program to find convex hull of a set of points

#include <iostream>
#include <stack>
#include <stdlib.h>
struct Point
{
int x;
int y;
};
// A globle point needed for sorting points with reference to the first point
// Used in compare function of qsort()
Point p0;
// A utility function to find next to top in a stack

Point nextToTop(stack<Point> &S)
{
Point p = S.top();
S.pop();
Point res = S.top();
S.push(p);
return res;
}
}
// A utility function to swap two points

int swap(Point &p1, Point &p2)
{
Point temp = p1;
p1 = p2;
p2 = temp;
}
// A utility function to return square of distance between p1 and p2

int dist(Point p1, Point p2)
{
return (p1.x - p2.x)*(p1.x - p2.x) + (p1.y - p2.y)*(p1.y - p2.y);
}

// 1 --> Clockwise
{
int val = (q.y - p.y) * (r.x - q.x) -
(q.x - p.x) * (r.y - q.y);

}
// A function used by library function qsort() to sort an array of

// points with respect to the first point
int compare(const void *vp1, const void *vp2)
{
Point *p1 = (Point *)vp1;
// Find orientation
int o = orientation(p0, *p1, *p2);
if (o == 0)
return (dist(p0, *p2) >= dist(p0, *p1))? -1 : 1;
return (o == 2)? -1: 1;

}
// Prints convex hull of a set of n points.

void convexHull(Point points[], int n)
{
// Find the bottommost point
int ymin = points[0].y, min = 0;
for (int i = 1; i < n; i++)
{
int y = points[i].y;
// Pick the bottom-most or chose the left most point in case of tie
if ((y < ymin) || (ymin == y && points[i].x < points[min].x))
ymin = points[i].y, min = i;
}
// Place the bottom-most point at first position

swap(points[0], points[min]);
// Sort n-1 points with respect to the first point. A point p1 comes
// before p2 in sorted ouput if p2 has larger polar angle (in
// counterclockwise direction) than p1
// counterclockwise direction) than p1
p0 = points[0];
qsort(&points[1], n-1, sizeof(Point), compare);
// Create an empty stack and push first three points to it.

stack<Point> S;
S.push(points[0]);
S.push(points[1]);
S.push(points[2]);
// Process remaining n-3 points

for (int i = 3; i < n; i++)
{
// Keep removing top while the angle formed by points next-to-top,
// top, and points[i] makes a non-left turn
while (orientation(nextToTop(S), S.top(), points[i]) != 2)
S.pop();
S.push(points[i]);
}
// Now stack has the output points, print contents of stack

while (!S.empty())
{
Point p = S.top();
cout << "(" << p.x << ", " << p.y <<")" << endl;
S.pop();
}
}

int main()
{
Point points[] = {{0, 3}, {1, 1}, {2, 2}, {4, 4},
{0, 0}, {1, 2}, {3, 1}, {3, 3}};
convexHull(points, n);
return 0;
}

Output:

(0, 3)
(4, 4)
(3, 1)
(0, 0)

Time Complexity: Let n be the number of input points. The algorithm takes O(nLogn) time if we use a
O(nLogn) sorting algorithm.
The first step (finding the bottom-most point) takes O(n) time. The second step (sorting points) takes
O(nLogn) time. In third step, every element is pushed and popped at most one time. So the third step to
process points one by one takes O(n) time, assuming that the stack operations take O(1) time. Overall
complexity is O(n) + O(nLogn) + O(n) which is O(nLogn)
References:
L. Rivest
http://www.dcs.gla.ac.uk/~pat/52233/slides/Hull1x1.pdf
discussed above
Merge k sorted arrays | Set 1
Given k sorted arrays of size n each, merge them and print the sorted output.
Example:
Input:
k = 3, n = 4
arr[][] = { {1, 3, 5, 7},
{2, 4, 6, 8},
{0, 9, 10, 11}} ;
Output: 0 1 2 3 4 5 6 7 8 9 10 11

A simple solution is to create an output array of size n*k and one by one copy all arrays to it. Finally, sort the
output array using any O(nLogn) sorting algorithm. This approach takes O(nkLognk) time.
We can merge arrays in O(nk*Logk) time using Min Heap. Following is detailed algorithm.
1. Create an output array of size n*k.

2. Create a min heap of size k and insert 1st element in all the arrays into a the heap
3. Repeat following steps n*k times.
a) Get minimum element from heap (minimum is always at root) and store it in output array.
b) Replace heap root with next element from the array from which the element is extracted. If the array
doesn’t have any more elements, then replace root with infinite. After replacing the root, heapify the tree.
// C++ program to merge k sorted arrays of size n each.

#include<iostream>
#include<limits.h>
#define n 4
// A min heap node

struct MinHeapNode
{
int element; // The element to be stored
int i; // index of the array from which the element is taken
int j; // index of the next element to be picked from array
};
// Prototype of a utility function to swap two min heap nodes

void swap(MinHeapNode *x, MinHeapNode *y);

class MinHeap
{
MinHeapNode *harr; // pointer to array of elements in heap
public:
// Constructor: creates a min heap of given size
MinHeap(MinHeapNode a[], int size);



// to get the root

MinHeapNode getMin() { return harr[0]; }
// to replace root with new node x and heapify() new root

void replaceMin(MinHeapNode x) { harr[0] = x; MinHeapify(0); }
};
// This function takes an array of arrays as an argument and

// All arrays are assumed to be sorted. It merges them together
// and prints the final sorted output.
int *mergeKArrays(int arr[][n], int k)
{
int *output = new int[n*k]; // To store output array
// Create a min heap with k heap nodes. Every heap node

// has first element of an array
MinHeapNode *harr = new MinHeapNode[k];
for (int i = 0; i < k; i++)
{
harr[i].element = arr[i][0]; // Store the first element
harr[i].i = i; // index of array
harr[i].j = 1; // Index of next element to be stored from array
}
MinHeap hp(harr, k); // Create the heap
// Now one by one get the minimum element from min

// heap and replace it with next element of its array
for (int count = 0; count < n*k; count++)
{
// Get the minimum element and store it in output
MinHeapNode root = hp.getMin();
output[count] = root.element;
// Find the next elelement that will replace current

// root of heap. The next element belongs to same
// array as the current root.
if (root.j < n)
{
root.element = arr[root.i][root.j];
root.j += 1;
}
// If root was the last element of its array
else root.element = INT_MAX; //INT_MAX is for infinite
// Replace root with next element of array

hp.replaceMin(root);
}
return output;
}
// FOLLOWING ARE IMPLEMENTATIONS OF STANDARD MIN HEAP METHODS

// FROM CORMEN BOOK
MinHeap::MinHeap(MinHeapNode a[], int size)
{
{
heap_size = size;
while (i >= 0)
{
MinHeapify(i);
i--;
}
}

{
int l = left(i);
int r = right(i);
int smallest = i;
if (l < heap_size && harr[l].element < harr[i].element)
smallest = l;
if (r < heap_size && harr[r].element < harr[smallest].element)
smallest = r;
if (smallest != i)
{
}
}

void swap(MinHeapNode *x, MinHeapNode *y)
{
MinHeapNode temp = *x; *x = *y; *y = temp;
}
// A utility function to print array elements

{
for (int i=0; i < size; i++)
cout << arr[i] << " ";
}

int main()
{
// Change n at the top to change number of elements
// in an array
int arr[][n] = {{2, 6, 12, 34},
{1, 9, 20, 1000},
{23, 34, 90, 2000}};
int k = sizeof(arr)/sizeof(arr[0]);
int *output = mergeKArrays(arr, k);
cout << "Merged array is " << endl;

printArray(output, n*k);
return 0;
}

Output:

Merged array is
1 2 6 9 12 20 23 34 34 90 1000 2000

Time Complexity: The main step is 3rd step, the loop runs n*k times. In every iteration of loop, we call
heapify which takes O(Logk) time. Therefore, the time complexity is O(nk Logk).
There are other interesting methods to merge k sorted arrays in O(nkLogk), we will sonn be discussing them
as separate posts.
Thanks to vignesh for suggesting this problem and initial solution. Please write comments if you find
Fleury’s Algorithm for printing Eulerian Path or Circuit
Eulerian Path is a path in graph that visits every edge exactly once. Eulerian Circuit is an Eulerian Path which
starts and ends on the same vertex.
We strongly recommend to first read the following post on Euler Path and Circuit.
http://www.geeksforgeeks.org/eulerian-path-and-circuit/
In the above mentioned post, we discussed the problem of finding out whether a given graph is Eulerian or
not. In this post, an algorithm to print Eulerian trail or circuit is discussed.
Following is Fleury’s Algorithm for printing Eulerian trail or cycle (Source Ref1).
1. Make sure the graph has either 0 or 2 odd vertices.
2. If there are 0 odd vertices, start anywhere. If there are 2 odd vertices, start at one of them.
3. Follow edges one at a time. If you have a choice between a bridge and a non-bridge, always choose the
non-bridge.
4. Stop when you run out of edges.
The idea is, “don’t burn bridges“ so that we can come back to a vertex and traverse remaining edges. For
example let us consider the following graph.
There are two vertices with odd degree, ‘2’ and ‘3’, we can start path from any of them. Let us start tour from
vertex ‘2’.
There are three edges going out from vertex ‘2’, which one to pick? We don’t pick the edge ‘2-3′ because that
is a bridge (we won’t be able to come back to ‘3’). We can pick any of the remaining two edge. Let us say we
pick ‘2-0′. We remove this edge and move to vertex ‘0’.
There is only one edge from vertex ‘0’, so we pick it, remove it and move to vertex ‘1’. Euler tour becomes ‘2-
0 0-1′.
There is only one edge from vertex ‘1’, so we pick it, remove it and move to vertex ‘2’. Euler tour becomes ‘2-
0 0-1 1-2′
Again there is only one edge from vertex 2, so we pick it, remove it and move to vertex 3. Euler tour becomes
‘2-0 0-1 1-2 2-3′
There are no more edges left, so we stop here. Final tour is ‘2-0 0-1 1-2 2-3′.
See this for and this fore more examples.
Following is C++ implementation of above algorithm. In the following code, it is assumed that the given
graph has an Eulerian trail or Circuit. The main focus is to print an Eulerian trail or circuit. We can use
isEulerian() to first check whether there is an Eulerian Trail or Circuit in the given graph.
We first find the starting point which must be an odd vertex (if there are odd vertices) and store it in variable
‘u’. If there are zero odd vertices, we start from vertex ‘0’. We call printEulerUtil() to print Euler tour starting
with u. We traverse all adjacent vertices of u, if there is only one adjacent vertex, we immediately consider it.
If there are more than one adjacent vertices, we consider an adjacent v only if edge u-v is not a bridge. How
to find if a given is edge is bridge? We count number of vertices reachable from u. We remove edge u-v and
again count number of reachable vertices from u. If number of reachable vertices are reduced, then edge u-v
is a bridge. To count reachable vertices, we can either use BFS or DFS, we have used DFS in the above code.
The function DFSCount(u) returns number of vertices reachable from u.
Once an edge is processed (included in Euler tour), we remove it from the graph. To remove the edge, we
replace the vertex entry with -1 in adjacency list. Note that simply deleting the node may not work as the
code is recursive and a parent call may be in middle of adjacency list.
// A C++ program print Eulerian Trail in a given Eulerian or Semi-Eulerian Graph

#include <iostream>
#include <string.h>
#include <list>

class Graph
{
public:
Graph(int V) { this->V = V; adj = new list<int>[V]; }
// functions to add and remove edge

void addEdge(int u, int v) { adj[u].push_back(v); adj[v].push_back(u); }
void rmvEdge(int u, int v);
// Methods to print Eulerian tour

void printEulerTour();
void printEulerUtil(int s);
// This function returns count of vertices reachable from v. It does DFS

int DFSCount(int v, bool visited[]);
// Utility function to check if edge u-v is a valid next edge in

// Eulerian trail or circuit
bool isValidNextEdge(int u, int v);
};
/* The main function that print Eulerian Trail. It first finds an odd
degree vertex (if there is any) and then calls printEulerUtil()
to print the path */
void Graph::printEulerTour()
{
// Find a vertex with odd degree
int u = 0;
for (int i = 0; i < V; i++)
if (adj[i].size() & 1)
{ u = i; break; }
// Print tour starting from oddv

printEulerUtil(u);
cout << endl;
}
// Print Euler tour starting from vertex u

void Graph::printEulerUtil(int u)
{
{
int v = *i;
// If edge u-v is not removed and it's a a valid next edge

if (v != -1 && isValidNextEdge(u, v))
{
cout << u << "-" << v << " ";
rmvEdge(u, v);
printEulerUtil(v);
}
}
}
// The function to check if edge u-v can be considered as next edge in

// Euler Tout
// Euler Tout
bool Graph::isValidNextEdge(int u, int v)
{
// The edge u-v is valid in one of the following two cases:
// 1) If v is the only adjacent vertex of u

int count = 0; // To store count of adjacent vertices
if (*i != -1)
count++;
if (count == 1)
return true;
// 2) If there are multiple adjacents, then u-v is not a bridge

// Do following steps to check if u-v is a bridge
// 2.a) count of vertices reachable from u

bool visited[V];
memset(visited, false, V);
int count1 = DFSCount(u, visited);
// 2.b) Remove edge (u, v) and after removing the edge, count
// vertices reachable from u
rmvEdge(u, v);
memset(visited, false, V);
int count2 = DFSCount(u, visited);
// 2.c) Add the edge back to the graph

addEdge(u, v);
// 2.d) If count1 is greater, then edge (u, v) is a bridge

return (count1 > count2)? false: true;
}
// This function removes edge u-v from graph. It removes the edge by
// replacing adjcent vertex value with -1.
void Graph::rmvEdge(int u, int v)
{
// Find v in adjacency list of u and replace it with -1
list<int>::iterator iv = find(adj[u].begin(), adj[u].end(), v);
*iv = -1;
// Find u in adjacency list of v and replace it with -1

list<int>::iterator iu = find(adj[v].begin(), adj[v].end(), u);
*iu = -1;
}
// A DFS based function to count reachable vertices from v

int Graph::DFSCount(int v, bool visited[])
{
visited[v] = true;
int count = 1;
// Recur for all vertices adjacent to this vertex

if (*i != -1 && !visited[*i])
count += DFSCount(*i, visited);
return count;
}
int main()
{
// Let us first create and test graphs shown in above figure
Graph g1(4);
g1.addEdge(0, 1);
g1.addEdge(0, 2);
g1.addEdge(1, 2);
g1.addEdge(2, 3);
g1.printEulerTour();
Graph g2(3);
g2.addEdge(0, 1);
g2.addEdge(1, 2);
g2.addEdge(2, 0);
Graph g3(5);
g3.addEdge(1, 0);
g3.addEdge(0, 2);
g3.addEdge(2, 1);
g3.addEdge(0, 3);
g3.addEdge(3, 4);
g3.addEdge(3, 2);
g3.addEdge(3, 1);
g3.addEdge(2, 4);
return 0;
}

Output:

2-0 0-1 1-2 2-3
0-1 1-2 2-0
0-1 1-2 2-0 0-3 3-4 4-2 2-3 3-1

Note that the above code modifies given graph, we can create a copy of graph if we don’t want the given
graph to be modified.
Time Complexity: Time complexity of the above implementation is O ((V+E)2). The function
printEulerUtil() is like DFS and it calls isValidNextEdge() which also does DFS two times. Time complexity
of DFS for adjacency list representation is O(V+E). Therefore overall time complexity is O((V+E)*(V+E))
which can be written as O(E2) for a connected graph.
There are better algorithms to print Euler tour, we will soon be covering them as separate posts.
References:
http://www.math.ku.edu/~jmartin/courses/math105-F11/Lectures/chapter5-part2.pdf
http://en.wikipedia.org/wiki/Eulerian_path#Fleury.27s_algorithm
discussed above
Difference between sums of odd level and even level nodes of a Binary Tree
Given a a Binary Tree, find the difference between the sum of nodes at odd level and the sum of nodes at
even level. Consider root as level 1, left and right children of root as level 2 and so on.
For example, in the following tree, sum of nodes at odd level is (5 + 1 + 4 + 8) which is 18. And sum of nodes
at even level is (2 + 6 + 3 + 7 + 9) which is 27. The output for following tree should be 18 – 27 which is -9.
5
/ \
2 6
/ \ \
1 4 8
/ / \
3 7 9

A straightforward method is to use level order traversal . In the traversal, check level of current node, if it
is odd, increment odd sum by data of current node, otherwise increment even sum. Finally return difference
between odd sum and even sum. See following for implementation of this approach.
C implementation of level order traversal based approach to find the difference.
The problem can also be solved using simple recursive traversal. We can recursively calculate the
required difference as, value of root’s data subtracted by the difference for subtree under left child and the
difference for subtree under right child. Following is C implementation of this approach.

// A recursive program to find difference between sum of nodes at

// odd level and sum at even level
#include <stdio.h>
#include <stdlib.h>
// Binary Tree node

struct node
{
int data;
struct node* left, *right;
};
// A utility function to allocate a new tree node with given data

{
node->data = data;
return (node);
}
// The main function that return difference between odd and even level
// nodes
int getLevelDiff(struct node *root)
{
// Base case
if (root == NULL)
return 0;
// Difference for root is root's data - difference for left subtree

// - difference for right subtree
return root->data - getLevelDiff(root->left) - getLevelDiff(root->right);
}

int main()
{
printf("%d is the required difference\n", getLevelDiff(root));
getchar();
return 0;
}

Output:

-9 is the required difference

Time complexity of both methods is O(n), but the second method is simple and easy to implement.
Merge a linked list into another linked list at alternate positions
Given two linked lists, insert nodes of second list into first list at alternate positions of first list.
For example, if first list is 5->7->17->13->11 and second is 12->10->2->4->6, the first list should become 5-
>12->7->10->17->2->13->4->11->6 and second list should become empty. The nodes of second list should
only be inserted when there are positions available. For example, if the first list is 1->2->3 and second list is
4->5->6->7->8, then first list should become 1->4->2->5->3->6 and second list to 7->8.
Use of extra space is not allowed (Not allowed to create additional nodes), i.e., insertion must be done in-
place. Expected time complexity is O(n) where n is number of nodes in first list.
The idea is to run a loop while there are available positions in first loop and insert nodes of second list by
changing pointers. Following is C implementation of this approach.
// C implementation of above program.

#include <stdio.h>
#include <stdlib.h>
// A nexted list node

struct node
{
int data;
struct node *next;
};

void push(struct node ** head_ref, int new_data)
{
}
/* Utility function to print a singly linked list */

{
{
temp = temp->next;
}
printf("\n");
}
// Main function that inserts nodes of linked list q into p at alternate

// positions. Since head of first list never changes and head of second list
// may change, we need single pointer for first list and double pointer for
// second list.
void merge(struct node *p, struct node **q)
{
struct node *p_curr = p, *q_curr = *q;
struct node *p_next, *q_next;
// While therre are avialable positions in p

while (p_curr != NULL && q_curr != NULL)
{
// Save next pointers
p_next = p_curr->next;
p_next = p_curr->next;
q_next = q_curr->next;
// Make q_curr as next of p_curr

q_curr->next = p_next; // Change next pointer of q_curr
p_curr->next = q_curr; // Change next pointer of p_curr
// Update current pointers for next iteration

p_curr = p_next;
q_curr = q_next;
}
*q = q_curr; // Update head pointer of second list

}

int main()
{
struct node *p = NULL, *q = NULL;
push(&p, 3);
push(&p, 2);
push(&p, 1);
printf("First Linked List:\n");
printList(p);
push(&q, 8);
push(&q, 7);
push(&q, 6);
push(&q, 5);
push(&q, 4);
printf("Second Linked List:\n");
printList(q);
merge(p, &q);
printf("Modified First Linked List:\n");

printList(p);
printf("Modified Second Linked List:\n");

printList(q);
getchar();
return 0;
}

Output:

First Linked List:
1 2 3
Second Linked List:
4 5 6 7 8
Modified First Linked List:
1 4 2 5 3 6
Modified Second Linked List:
7 8

NP-Completeness | Set 1 (Introduction)
We have been writing about efficient algorithms to solve complex problems, like shortest path, Euler graph,
minimum spanning tree, etc. Those were all success stories of algorithm designers. In this post, failure
stories of computer science are discussed.
Can all computational problems be solved by a computer? There are computational problems that
can not be solved by algorithms even with unlimited time. For example Turing Halting problem (Given a
program and an input, whether the program will eventually halt when run with that input, or will run
forever). Alan Turing proved that general algorithm to solve the halting problem for all possible program-
input pairs cannot exist. A key part of the proof is, Turing machine was used as a mathematical definition of
a computer and program (Source Halting Problem).
Status of NP Complete problems is another failure story, NP complete problems are problems whose status
is unknown. No polynomial time algorithm has yet been discovered for any NP complete problem, nor has
anybody yet been able to prove that no polynomial-time algorithm exist for any of them. The interesting part
is, if any one of the NP complete problems can be solved in polynomial time, then all of them can be solved.
What are NP, P, NP-complete and NP-Hard problems?

P is set of problems that can be solved by a deterministic Turing machine in Polynomial time.
NP is set of decision problems that can be solved by a Non-deterministic Turing Machine in Polynomial
time. P is subset of NP (any problem that can be solved by deterministic machine in polynomial time can
also be solved by non-deterministic machine in polynomial time).
Informally, NP is set of decision problems which can be solved by a polynomial time via a “Lucky
Algorithm”, a magical algorithm that always makes a right guess among the given set of choices (Source Ref
1).
NP-complete problems are the hardest problems in NP set. A decision problem L is NP-complete if:
1) L is in NP (Any given solution for NP-complete problems can be verified quickly, but there is no efficient
known solution).
2) Every problem in NP is reducible to L in polynomial time (Reduction is defined below).
A problem is NP-Hard if it follows property 2 mentioned above, doesn’t need to follow property 1. Therefore,
NP-Complete set is also a subset of NP-Hard set.
Decision vs Optimization Problems

NP-completeness applies to the realm of decision problems. It was set up this way because it’s easier to
compare the difficulty of decision problems than that of optimization problems. In reality, though, being
able to solve a decision problem in polynomial time will often permit us to solve the corresponding
optimization problem in polynomial time (using a polynomial number of calls to the decision problem). So,
discussing the difficulty of decision problems is often really equivalent to discussing the difficulty of
optimization problems. (Source Ref 2).
For example, consider the vertex cover problem (Given a graph, find out the minimum sized vertex set that
covers all edges). It is an optimization problem. Corresponding decision problem is, given undirected graph
G and k, is there a vertex cover of size k?
What is Reduction?
Let L1 and L2 be two decision problems. Suppose algorithm A2 solves L2. That is, if y is an input for L2 then
algorithm A 2 will answer Yes or No depending upon whether y belongs to L or not.
2
The idea is to find a transformation from L1 to L2 so that the algorithm A2 can be part of an algorithm A1 to
solve L1.
Learning reduction in general is very important. For example, if we have library functions to solve certain
problem and if we can reduce a new problem to one of the solved problems, we save a lot of time. Consider
the example of a problem where we have to find minimum product path in a given directed graph where
product of path is multiplication of weights of edges along the path. If we have code for Dijkstra’s algorithm
to find shortest path, we can take log of all weights and use Dijkstra’s algorithm to find the minimum product
path rather than writing a fresh code for this new problem.
How to prove that a given problem is NP complete?

From the definition of NP-complete, it appears impossible to prove that a problem L is NP-Complete. By
definition, it requires us to that show every problem in NP is polynomial time reducible to L. Fortunately,
there is an alternate way to prove it. The idea is to take a known NP-Complete problem and reduce it to L.
If polynomial time reduction is possible, we can prove that L is NP-Complete by transitivity of reduction (If
a NP-Complete problem is reducible to L in polynomial time, then all problems are reducible to L in
polynomial time).
What was the first problem proved as NP-Complete?

There must be some first NP-Complete problem proved by definition of NP-Complete problems. SAT
(Boolean satisfiability problem) is the first NP-Complete problem proved by Cook (See CLRS book for
proof).
It is always useful to know about NP-Completeness even for engineers. Suppose you are asked to write an
efficient algorithm to solve an extremely important problem for your company. After a lot of thinking, you
can only come up exponential time approach which is impractical. If you don’t know about NP-
Completeness, you can only say that I could not come with an efficient algorithm. If you know about NP-
Completeness and prove that the problem as NP-complete, you can proudly say that the polynomial time
solution is unlikely to exist. If there is a polynomial time solution possible, then that solution solves a big
problem of computer science many scientists have been trying for years.
We will soon be discussing more NP-Complete problems and their proof for NP-Completeness.
References:
MIT Video Lecture on Computational Complexity
L. Rivest
discussed above
Print Postorder traversal from given Inorder and Preorder traversals
Given Inorder and Preorder traversals of a binary tree, print Postorder traversal.
Example:
Input:
Inorder traversal in[] = {4, 2, 5, 1, 3, 6}
Preorder traversal pre[] = {1, 2, 4, 5, 3, 6}
Output:
Postorder traversal is {4, 5, 2, 6, 3, 1}

Trversals in the above example represents following tree
1
/ \
2 3
/ \ \
4 5 6

A naive method is to first construct the tree, then use simple recursive method to print postorder traversal
of the constructed tree.
We can print postorder traversal without constructing the tree . The idea is, root is always the first
item in preorder traversal and it must be the last item in postorder traversal. We first recursively print left
subtree, then recursively print right subtree. Finally, print root. To find boundaries of left and right subtrees
in pre[] and in[], we search root in in[], all elements before root in in[] are elements of left subtree and all
elements after root are elements of right subtree. In pre[], all elements after index of root in in[] are elements
of right subtree. And elements before index (including the element at index and excluding the first element)
are elements of left subtree.

// C++ program to print postorder traversal from preorder and inorder traversals
#include <iostream>
// A utility function to search x in arr[] of size n

int search(int arr[], int x, int n)
{
for (int i = 0; i < n; i++)
if (arr[i] == x)
return i;
return -1;
}
// Prints postorder traversal from given inorder and preorder traversals

void printPostOrder(int in[], int pre[], int n)
{
// The first element in pre[] is always root, search it
// in in[] to find left and right subtrees
int root = search(in, pre[0], n);
// If left subtree is not empty, print left subtree

if (root != 0)
printPostOrder(in, pre+1, root);
// If right subtree is not empty, print right subtree

if (root != n-1)
printPostOrder(in+root+1, pre+root+1, n-root-1);
// Print root
cout << pre[0] << " ";
}

int main()
{
int in[] = {4, 2, 5, 1, 3, 6};
int pre[] = {1, 2, 4, 5, 3, 6};
int n = sizeof(in)/sizeof(in[0]);
cout << "Postorder traversal " << endl;
printPostOrder(in, pre, n);
return 0;
}

Output
Postorder traversal
4 5 2 6 3 1

Time Complexity: The above function visits every node in array. For every visit, it calls search which takes
O(n) time. Therefore, overall time complexity of the function is O(n2)
discussed above
Find depth of the deepest odd level leaf node
Write a C code to get the depth of the deepest odd level leaf node in a binary tree. Consider that level starts
with 1. Depth of a leaf node is number of nodes on the path from root to leaf (including both leaf and root).
For example, consider the following tree. The deepest odd level node is the node with value 9 and depth of
this node is 5.
1
/ \
2 3
/ / \
4 5 6
\ \
7 8
/ \
9 10
/
11

We strongly recommend you to minimize the browser and try this yourself first.
The idea is to recursively traverse the given binary tree and while traversing, maintain a variable “level”
which will store the current node’s level in the tree. If current node is leaf then check “level” is odd or not. If
level is odd then return it. If current node is not leaf, then recursively find maximum depth in left and right
subtrees, and return maximum of the two depths.
// C program to find depth of the deepest odd level leaf node

#include <stdio.h>
#include <stdlib.h>

int max(int x, int y) { return (x > y)? x : y; }

struct Node
{
int data;
};
// A utility function to allocate a new tree node

{
node->data = data;
return node;
}
// A recursive function to find depth of the deepest odd level leaf

int depthOfOddLeafUtil(Node *root,int level)
{
// Base Case
if (root == NULL)
return 0;
return 0;
// If this node is a leaf and its level is odd, return its level
if (root->left==NULL && root->right==NULL && level&1)
return level;
// If not leaf, return the maximum value from left and right subtrees
return max(depthOfOddLeafUtil(root->left, level+1),
depthOfOddLeafUtil(root->right, level+1));
}
/* Main function which calculates the depth of deepest odd level leaf.
This function mainly uses depthOfOddLeafUtil() */
int depthOfOddLeaf(struct Node *root)
{
int level = 1, depth = 0;
return depthOfOddLeafUtil(root, level);
}

int main()
{
struct Node* root = newNode(1);
root->right->left->right = newNode(7);
root->right->left->right->left = newNode(9);
root->right->right->right->right = newNode(10);
root->right->right->right->right->left = newNode(11);
printf("%d is the required depth\n", depthOfOddLeaf(root));

getchar();
return 0;
}
Output:

5 is the required depth

Time Complexity: The function does a simple traversal of the tree, so the complexity is O(n).
Check if all leaves are at same level
Given a Binary Tree, check if all leaves are at same level or not.
12
/ \
5 7
/ \
3 1
Leaves are at same level
12
/ \
5 7
/
3
Leaves are Not at same level
12
/
5
/ \
3 9
/ /
1 2

The idea is to first find level of the leftmost leaf and store it in a variable leafLevel. Then compare level of all
other leaves with leafLevel, if same, return true, else return false. We traverse the given Binary Tree in
Preorder fashion. An argument leaflevel is passed to all calls. The value of leafLevel is initialized as 0 to
indicate that the first leaf is not yet seen yet. The value is updated when we find first leaf. Level of
subsequent leaves (in preorder) is compared with leafLevel.
// C program to check if all leaves are at same level

#include <stdio.h>
#include <stdlib.h>
// A binary tree node

struct Node
{
int data;
};
// A utility function to allocate a new tree node

{
node->data = data;
return node;
}
/* Recursive function which checks whether all leaves are at same level */
bool checkUtil(struct Node *root, int level, int *leafLevel)
{
// Base case
if (root == NULL) return true;
// If a leaf node is encountered

{
// When a leaf node is found first time
if (*leafLevel == 0)
{
*leafLevel = level; // Set first found leaf's level
return true;
}
// If this is not first leaf node, compare its level with

// first leaf's level
return (level == *leafLevel);
}
// If this node is not leaf, recursively check left and right subtrees
return checkUtil(root->left, level+1, leafLevel) &&
checkUtil(root->right, level+1, leafLevel);
}
/* The main function to check if all leafs are at same level.

It mainly uses checkUtil() */
bool check(struct Node *root)
{
int level = 0, leafLevel = 0;
return checkUtil(root, level, &leafLevel);
}

int main()
{
// Let us create tree shown in thirdt example
struct Node *root = newNode(12);
if (check(root))
printf("Leaves are at same level\n");
else
printf("Leaves are not at same level\n");
getchar();
return 0;
}

Output:


Print Left View of a Binary Tree
Given a Binary Tree, print left view of it. Left view of a Binary Tree is set of nodes visible when tree is visited
from left side. Left view of following tree is 12, 10, 25.
12
/ \
10 30
/ \
25 40

The left view contains all nodes that are first nodes in their levels. A simple solution is to do level order
traversal and print the first node in every level.
The problem can also be solved using simple recursive traversal. We can keep track of level of a node by
passing a parameter to all recursive calls. The idea is to keep track of maximum level also. Whenever we see
a node whose level is more than maximum level so far, we print the node because this is the first node in its
level (Note that we traverse the left subtree before right subtree). Following is C implementation of this
approach.

// C program to print left view of Binary Tree

#include<stdio.h>
#include<stdlib.h>
struct node
{
int data;
};
// A utility function to create a new Binary Tree node

struct node *newNode(int item)
{
temp->data = item;
return temp;
}
// Recursive function to print left view of a binary tree.

void leftViewUtil(struct node *root, int level, int *max_level)
{
// Base Case
if (root==NULL) return;
// If this is the first node of its level

if (*max_level < level)
{
printf("%d\t", root->data);
*max_level = level;
}
// Recur for left and right subtrees

leftViewUtil(root->left, level+1, max_level);
leftViewUtil(root->right, level+1, max_level);
}
// A wrapper over leftViewUtil()

void leftView(struct node *root)
{
int max_level = 0;
leftViewUtil(root, 1, &max_level);
}
// Driver Program to test above functions

int main()
{
leftView(root);
return 0;
}

Output:

12 10 25

This article is contributed by Ramsai Chinthamani. Please write comments if you find anything incorrect, or
Radix Sort
The lower bound for Comparison based sorting algorithm (Merge Sort, Heap Sort, Quick-Sort .. etc) is
Ω(nLogn), i.e., they cannot do better than nLogn.
Counting sort is a linear tine sorting algorithm that sort in O(n+k) time when elements are in range from 1 to
k.
What if the elements are in range from 1 to n 2?

We can’t use counting sort because counting sort will take O(n2) which is worse than comparison based
sorting algorithms. Can we sort such an array in linear time?
Radix Sort is the answer. The idea of Radix Sort is to do digit by digit sort starting from least significant digit
to most significant digit. Radix sort uses counting sort as a subroutine to sort.
The Radix Sort Algorithm

1) Do following for each digit i where i varies from least significant digit to the most significant digit.
………….a) Sort input array using counting sort (or any stable sort) according to the i’th digit.
Example:
Original, unsorted list:
170, 45, 75, 90, 802, 24, 2, 66
Sorting by least significant digit (1s place) gives: [*Notice that we keep 802 before 2, because 802 occurred
before 2 in the original list, and similarly for pairs 170 & 90 and 45 & 75.]
170, 90, 802, 2, 24, 45, 75, 66
Sorting by next digit (10s place) gives: [*Notice that 802 again comes before 2 as 802 comes before 2 in the
previous list.]
802, 2, 24, 45, 66, 170, 75, 90
Sorting by most significant digit (100s place) gives:
2, 24, 45, 66, 75, 90, 170, 802
What is the running time of Radix Sort?

Let there be d digits in input integers. Radix Sort takes O(d*(n+b)) time where b is the base for representing
numbers, for example, for decimal system, b is 10. What is the value of d? If k is the maximum possible
value, then d would be O(logb(k)). So overall time complexity is O((n+b) * logb(k)). Which looks more than
the time complexity of comparison based sorting algorithms for a large k. Let us first limit k. Let k c where c
is a constant. In that case, the complexity becomes O(nLogb(n)). But it still doesn’t beat comparison based
sorting algorithms.
What if we make value of b larger?. What should be the value of b to make the time complexity linear? If we
set b as n, we get the time complexity as O(n). In other words, we can sort an array of integers with range
from 1 to nc if the numbers are represented in base n (or every digit takes log2(n) bits).
Is Radix Sort preferable to Comparison based sorting algorithms like Quick-Sort?

If we have log2n bits for every digit, the running time of Radix appears to be better than Quick Sort for a wide
range of input numbers. The constant factors hidden in asymptotic notation are higher for Radix Sort and
Quick-Sort uses hardware caches more effectively. Also, Radix sort uses counting sort as a subroutine and
counting sort takes extra space to sort numbers.
Implementation of Radix Sort

Following is a simple C++ implementation of Radix Sort. For simplicity, the value of d is assumed to be 10.
We recommend you to see Counting Sort for details of countSort() function in below code.
// C++ implementation of Radix Sort

#include<iostream>
// A utility function to get maximum value in arr[]

{
int mx = arr[0];
for (int i = 1; i < n; i++)
if (arr[i] > mx)
mx = arr[i];
return mx;
}
// A function to do counting sort of arr[] according to

// the digit represented by exp.
void countSort(int arr[], int n, int exp)
{
int output[n]; // output array
int i, count[10] = {0};
// Store count of occurrences in count[]

for (i = 0; i < n; i++)
count[ (arr[i]/exp)%10 ]++;
// Change count[i] so that count[i] now contains actual position of

// this digit in output[]
for (i = 1; i < 10; i++)
count[i] += count[i - 1];
// Build the output array

for (i = n - 1; i >= 0; i--)
{
output[count[ (arr[i]/exp)%10 ] - 1] = arr[i];
count[ (arr[i]/exp)%10 ]--;
}
// Copy the output array to arr[], so that arr[] now

// contains sorted numbers according to curent digit
for (i = 0; i < n; i++)
arr[i] = output[i];
}
// The main function to that sorts arr[] of size n using Radix Sort
void radixsort(int arr[], int n)
{
// Find the maximum number to know number of digits
int m = getMax(arr, n);
// Do counting sort for every digit. Note that instead of passing digit
// number, exp is passed. exp is 10î where i is current digit number
for (int exp = 1; m/exp > 0; exp *= 10)
countSort(arr, n, exp);
}

void print(int arr[], int n)
{
for (int i = 0; i < n; i++)
cout << arr[i] << " ";
cout << arr[i] << " ";
}

int main()
{
int arr[] = {170, 45, 75, 90, 802, 24, 2, 66};
radixsort(arr, n);
print(arr, n);
return 0;
}

Output:

2 24 45 66 75 90 170 802

References:
http://en.wikipedia.org/wiki/Radix_sort
http://alg12.wikischolars.columbia.edu/file/view/RADIX.pdf
MIT Video Lecture
L. Rivest
discussed above
B-Tree | Set 3 (Delete)
It is recommended to refer following posts as prerequisite of this post.
B-Tree | Set 1 (Introduction)

B-Tree | Set 2 (Insert)
B-Tree is a type of a multi-way search tree. So, if you are not familiar with multi-way search trees in general,
it is better to take a look at this video lecture from IIT-Delhi, before proceeding further. Once you get the
basics of a multi-way search tree clear, B-Tree operations will be easier to understand.
Source of the following explanation and algorithm is Introduction to Algorithms 3rd Edition by Clifford
Stein, Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest
Deletion process:
Deletion from a B-tree is more complicated than insertion, because we can delete a key from any node-not
just a leaf—and when we delete a key from an internal node, we will have to rearrange the node’s children.
As in insertion, we must make sure the deletion doesn’t violate the B-tree properties. Just as we had to
ensure that a node didn’t get too big due to insertion, we must ensure that a node doesn’t get too small
during deletion (except that the root is allowed to have fewer than the minimum number t-1 of keys). Just as
a simple insertion algorithm might have to back up if a node on the path to where the key was to be inserted
was full, a simple approach to deletion might have to back up if a node (other than the root) along the path to
where the key is to be deleted has the minimum number of keys.
The deletion procedure deletes the key k from the subtree rooted at x. This procedure guarantees that
whenever it calls itself recursively on a node x, the number of keys in x is at least the minimum degree t .
Note that this condition requires one more key than the minimum required by the usual B-tree conditions,
so that sometimes a key may have to be moved into a child node before recursion descends to that child.
This strengthened condition allows us to delete a key from the tree in one downward pass without having to
“back up” (with one exception, which we’ll explain). You should interpret the following specification for
deletion from a B-tree with the understanding that if the root node x ever becomes an internal node having
no keys (this situation can occur in cases 2c and 3b then we delete x, and x’s only child x.c1 becomes the new
root of the tree, decreasing the height of the tree by one and preserving the property that the root of the tree
contains at least one key (unless the tree is empty).
We sketch how deletion works with various cases of deleting keys from a B-tree.
1. If the key k is in node x and x is a leaf, delete the key k from x.
2. If the key k is in node x and x is an internal node, do the following.
a) If the child y that precedes k in node x has at least t keys, then find the predecessor k0 of k in the sub-
tree rooted at y. Recursively delete k0, and replace k by k0 in x. (We can find k0 and delete it in a single
downward pass.)
b) If y has fewer than t keys, then, symmetrically, examine the child z that follows k in node x. If z has at
least t keys, then find the successor k0 of k in the subtree rooted at z. Recursively delete k0, and replace k by
k0 in x. (We can find k0 and delete it in a single downward pass.)
c) Otherwise, if both y and z have only t-1 keys, merge k and all of z into y, so that x loses both k and the
pointer to z, and y now contains 2t-1 keys. Then free z and recursively delete k from y.
3. If the key k is not present in internal node x, determine the root x.c(i) of the appropriate subtree that must
contain k, if k is in the tree at all. If x.c(i) has only t-1 keys, execute step 3a or 3b as necessary to guarantee
that we descend to a node containing at least t keys. Then finish by recursing on the appropriate child of x.
a) If x.c(i) has only t-1 keys but has an immediate sibling with at least t keys, give x.c(i) an extra key by
moving a key from x down into x.c(i), moving a key from x.c(i) ’s immediate left or right sibling up into x,
and moving the appropriate child pointer from the sibling into x.c(i).
b) If x.c(i) and both of x.c(i)’s immediate siblings have t-1 keys, merge x.c(i) with one sibling, which
involves moving a key from x down into the new merged node to become the median key for that node.
Since most of the keys in a B-tree are in the leaves, deletion operations are most often used to delete keys
from leaves. The recursive delete procedure then acts in one downward pass through the tree, without
having to back up. When deleting a key in an internal node, however, the procedure makes a downward pass
through the tree but may have to return to the node from which the key was deleted to replace the key with
its predecessor or successor (cases 2a and 2b).
The following figures from CLRS book explain the deletion porcess.
Implementation:
Following is C++ implementation of deletion process.
/* The following program performs deletion on a B-Tree. It contains functions

specific for deletion along with all the other functions provided in the
previous articles on B-Trees. See http://www.geeksforgeeks.org/b-tree-set-1-
introduction-2/
for previous article.
The deletion function has been compartmentalized into 8 functions for ease
of understanding and clarity
The following functions are exclusive for deletion

In class BTreeNode:
1) remove
2) removeFromLeaf
3) removeFromNonLeaf
4) getPred
5) getSucc
6) borrowFromPrev
7) borrowFromNext
8) merge
9) findKey
In class BTree:
1) remove
The removal of a key from a B-Tree is a fairly complicated process. The program handle
s
all the 6 different cases that might arise while removing a key.
Testing: The code has been tested using the B-Tree provided in the CLRS book( included
in the main function ) along with other cases.
Reference: CLRS3 - Chapter 18 - (499-502)

It is advised to read the material in CLRS before taking a look at the code. */
#include<iostream>
// A BTree node
class BTreeNode
{
public:

void traverse();

// A function that returns the index of the first key that is greater
// or equal to k
int findKey(int k);
// A utility function to insert a new key in the subtree rooted with

// this node. The assumption is, the node must be non-full when this
void insertNonFull(int k);
// A utility function to split the child y of this node. i is index

// of y in child array C[]. The Child y must be full when this
void splitChild(int i, BTreeNode *y);
// A wrapper function to remove the key k in subtree rooted with

// this node.
void remove(int k);
// A function to remove the key present in idx-th position in

// this node which is a leaf
void removeFromLeaf(int idx);
// A function to remove the key present in idx-th position in

// this node which is a non-leaf node
void removeFromNonLeaf(int idx);
// A function to get the predecessor of the key- where the key

// is present in the idx-th position in the node
int getPred(int idx);
// A function to get the successor of the key- where the key

// is present in the idx-th position in the node
int getSucc(int idx);
// A function to fill up the child node present in the idx-th

// position in the C[] array if that child has less than t-1 keys
void fill(int idx);
// A function to borrow a key from the C[idx-1]-th node and place

// it in C[idx]th node
void borrowFromPrev(int idx);
// A function to borrow a key from the C[idx+1]-th node and place it

// in C[idx]th node
void borrowFromNext(int idx);
// A function to merge idx-th child of the node with (idx+1)th child of
// the node
void merge(int idx);
// Make BTree friend of this so that we can access private members of

// this class in BTree functions
friend class BTree;
};
class BTree
{
public:

BTree(int _t)
{
root = NULL;
t = _t;
}
void traverse()
{
if (root != NULL) root->traverse();
}

{
return (root == NULL)? NULL : root->search(k);
}

void insert(int k);
// The main function that removes a new key in thie B-Tree

void remove(int k);
};
BTreeNode::BTreeNode(int t1, bool leaf1)

{
t = t1;
leaf = leaf1;


n = 0;
}
// A utility function that returns the index of the first key that is
// greater than or equal to k
int BTreeNode::findKey(int k)
{
int idx=0;
while (idx<n && keys[idx] < k)
++idx;
return idx;
return idx;
}
// A function to remove the key k from the sub-tree rooted with this node
void BTreeNode::remove(int k)
{
int idx = findKey(k);
// The key to be removed is present in this node

if (idx < n && keys[idx] == k)
{
// If the node is a leaf node - removeFromLeaf is called

// Otherwise, removeFromNonLeaf function is called
if (leaf)
removeFromLeaf(idx);
else
removeFromNonLeaf(idx);
}
else
{
// If this node is a leaf node, then the key is not present in tree
if (leaf)
{
cout << "The key "<< k <<" is does not exist in the tree\n";
return;
}
// The key to be removed is present in the sub-tree rooted with this node
// The flag indicates whether the key is present in the sub-tree rooted
// with the last child of this node
bool flag = ( (idx==n)? true : false );
// If the child where the key is supposed to exist has less that t keys,
// we fill that child
if (C[idx]->n < t)
fill(idx);
// If the last child has been merged, it must have merged with the previous
// child and so we recurse on the (idx-1)th child. Else, we recurse on the
// (idx)th child which now has atleast t keys
if (flag && idx > n)
C[idx-1]->remove(k);
else
C[idx]->remove(k);
}
return;
}
// A function to remove the idx-th key from this node - which is a leaf node
void BTreeNode::removeFromLeaf (int idx)
{
// Move all the keys after the idx-th pos one place backward
for (int i=idx+1; i<n; ++i)
keys[i-1] = keys[i];
// Reduce the count of keys

n--;
return;
}
// A function to remove the idx-th key from this node - which is a non-leaf node
// A function to remove the idx-th key from this node - which is a non-leaf node
void BTreeNode::removeFromNonLeaf(int idx)
{
int k = keys[idx];
// If the child that precedes k (C[idx]) has atleast t keys,

// find the predecessor 'pred' of k in the subtree rooted at
// C[idx]. Replace k by pred. Recursively delete pred
// in C[idx]
if (C[idx]->n >= t)
{
int pred = getPred(idx);
keys[idx] = pred;
C[idx]->remove(pred);
}
// If the child C[idx] has less that t keys, examine C[idx+1].

// If C[idx+1] has atleast t keys, find the successor 'succ' of k in
// the subtree rooted at C[idx+1]
// Replace k by succ
// Recursively delete succ in C[idx+1]
else if (C[idx+1]->n >= t)
{
int succ = getSucc(idx);
keys[idx] = succ;
C[idx+1]->remove(succ);
}
// If both C[idx] and C[idx+1] has less that t keys,merge k and all of C[idx+1]
// into C[idx]
// Now C[idx] contains 2t-1 keys
// Free C[idx+1] and recursively delete k from C[idx]
else
{
merge(idx);
C[idx]->remove(k);
}
return;
}
// A function to get predecessor of keys[idx]

int BTreeNode::getPred(int idx)
{
// Keep moving to the right most node until we reach a leaf
BTreeNode *cur=C[idx];
while (!cur->leaf)
cur = cur->C[cur->n];
// Return the last key of the leaf

return cur->keys[cur->n-1];
}
int BTreeNode::getSucc(int idx)

{
// Keep moving the left most node starting from C[idx+1] until we reach a leaf
BTreeNode *cur = C[idx+1];
while (!cur->leaf)
cur = cur->C[0];
// Return the first key of the leaf

return cur->keys[0];
}
// A function to fill child C[idx] which has less than t-1 keys
void BTreeNode::fill(int idx)
{
// If the previous child(C[idx-1]) has more than t-1 keys, borrow a key
// from that child
if (idx!=0 && C[idx-1]->n>=t)
borrowFromPrev(idx);
// If the next child(C[idx+1]) has more than t-1 keys, borrow a key
// from that child
else if (idx!=n && C[idx+1]->n>=t)
borrowFromNext(idx);
// Merge C[idx] with its sibling

// If C[idx] is the last child, merge it with with its previous sibling
// Otherwise merge it with its next sibling
else
{
if (idx != n)
merge(idx);
else
merge(idx-1);
}
return;
}
// A function to borrow a key from C[idx-1] and insert it

// into C[idx]
void BTreeNode::borrowFromPrev(int idx)
{
BTreeNode *child=C[idx];
BTreeNode *sibling=C[idx-1];
// The last key from C[idx-1] goes up to the parent and key[idx-1]
// from parent is inserted as the first key in C[idx]. Thus, the loses
// sibling one key and child gains one key
// Moving all key in C[idx] one step ahead

for (int i=child->n-1; i>=0; --i)
child->keys[i+1] = child->keys[i];
// If C[idx] is not a leaf, move all its child pointers one step ahead
if (!child->leaf)
{
for(int i=child->n; i>=0; --i)
child->C[i+1] = child->C[i];
}
// Setting child's first key equal to keys[idx-1] from the current node
child->keys[0] = keys[idx-1];
// Moving sibling's last child as C[idx]'s first child

if (!leaf)
child->C[0] = sibling->C[sibling->n];
// Moving the key from the sibling to the parent

// This reduces the number of keys in the sibling
keys[idx-1] = sibling->keys[sibling->n-1];
child->n += 1;
sibling->n -= 1;
return;
}
// A function to borrow a key from the C[idx+1] and place

// it in C[idx]
void BTreeNode::borrowFromNext(int idx)
{
BTreeNode *child=C[idx];
BTreeNode *sibling=C[idx+1];
// keys[idx] is inserted as the last key in C[idx]

child->keys[(child->n)] = keys[idx];
// Sibling's first child is inserted as the last child

// into C[idx]
if (!(child->leaf))
child->C[(child->n)+1] = sibling->C[0];
//The first key from sibling is inserted into keys[idx]

keys[idx] = sibling->keys[0];
// Moving all keys in sibling one step behind

for (int i=1; i<sibling->n; ++i)
sibling->keys[i-1] = sibling->keys[i];
// Moving the child pointers one step behind

if (!sibling->leaf)
{
for(int i=1; i<=sibling->n; ++i)
sibling->C[i-1] = sibling->C[i];
}
// Increasing and decreasing the key count of C[idx] and C[idx+1]

// respectively
child->n += 1;
sibling->n -= 1;
return;
}
// A function to merge C[idx] with C[idx+1]

// C[idx+1] is freed after merging
void BTreeNode::merge(int idx)
{
BTreeNode *child = C[idx];
BTreeNode *sibling = C[idx+1];
// Pulling a key from the current node and inserting it into (t-1)th
// position of C[idx]
child->keys[t-1] = keys[idx];
// Copying the keys from C[idx+1] to C[idx] at the end

for (int i=0; i<sibling->n; ++i)
child->keys[i+t] = sibling->keys[i];
// Copying the child pointers from C[idx+1] to C[idx]

if (!child->leaf)
{
for(int i=0; i<=sibling->n; ++i)
child->C[i+t] = sibling->C[i];
}
// Moving all keys after idx in the current node one step before -
// Moving all keys after idx in the current node one step before -
// to fill the gap created by moving keys[idx] to C[idx]
for (int i=idx+1; i<n; ++i)
keys[i-1] = keys[i];
// Moving the child pointers after (idx+1) in the current node one
// step before
for (int i=idx+2; i<=n; ++i)
C[i-1] = C[i];
// Updating the key count of child and the current node

child->n += sibling->n+1;
n--;
// Freeing the memory occupied by sibling

delete(sibling);
return;
}

void BTree::insert(int k)
{
// If tree is empty
if (root == NULL)
{
// Allocate memory for root
root = new BTreeNode(t, true);
root->keys[0] = k; // Insert key
root->n = 1; // Update number of keys in root
}
else // If tree is not empty
{
// If root is full, then tree grows in height
if (root->n == 2*t-1)
{
// Allocate memory for new root
BTreeNode *s = new BTreeNode(t, false);
// Make old root as child of new root

s->C[0] = root;
// Split the old root and move 1 key to the new root
s->splitChild(0, root);
// New root has two children now. Decide which of the

// two children is going to have new key
int i = 0;
if (s->keys[0] < k)
i++;
s->C[i]->insertNonFull(k);
// Change root
root = s;
}
else // If root is not full, call insertNonFull for root
}
}
// A utility function to insert a new key in this node

// The assumption is, the node must be non-full when this
void BTreeNode::insertNonFull(int k)
{
// Initialize index as index of rightmost element
int i = n-1;
// If this is a leaf node

if (leaf == true)
{
// The following loop does two things
// a) Finds the location of new key to be inserted
// b) Moves all greater keys to one place ahead
{
keys[i+1] = keys[i];
i--;
}
// Insert the new key at found location

keys[i+1] = k;
n = n+1;
}
else // If this node is not leaf
{
// Find the child which is going to have the new key
i--;
// See if the found child is full

if (C[i+1]->n == 2*t-1)
{
// If the child is full, then split it
splitChild(i+1, C[i+1]);
// After split, the middle key of C[i] goes up and

// C[i] is splitted into two. See which of the two
// is going to have the new key
if (keys[i+1] < k)
i++;
}
C[i+1]->insertNonFull(k);
}
}
// A utility function to split the child y of this node

// Note that y must be full when this function is called
void BTreeNode::splitChild(int i, BTreeNode *y)
{
// Create a new node which is going to store (t-1) keys
// of y
BTreeNode *z = new BTreeNode(y->t, y->leaf);
z->n = t - 1;
// Copy the last (t-1) keys of y to z

for (int j = 0; j < t-1; j++)
z->keys[j] = y->keys[j+t];
// Copy the last t children of y to z

if (y->leaf == false)
{
for (int j = 0; j < t; j++)
z->C[j] = y->C[j+t];
}
// Reduce the number of keys in y

y->n = t - 1;
// Since this node is going to have a new child,
// create space of new child
for (int j = n; j >= i+1; j--)
C[j+1] = C[j];
// Link the new child to this node

C[i+1] = z;
// A key of y will move to this node. Find location of

// new key and move all greater keys one space ahead
for (int j = n-1; j >= i; j--)
keys[j+1] = keys[j];
// Copy the middle key of y to this node

keys[i] = y->keys[t-1];
// Increment count of keys in this node

n = n + 1;
}

{
int i;
for (i = 0; i < n; i++)
{
if (leaf == false)
C[i]->traverse();
cout << " " << keys[i];
}

if (leaf == false)
C[i]->traverse();
}

{
int i = 0;
i++;

if (keys[i] == k)
return this;

if (leaf == true)
return NULL;

}
void BTree::remove(int k)
{
if (!root)
{
{
cout << "The tree is empty\n";
return;
}
// Call the remove function for root

root->remove(k);
// If the root node has 0 keys, make its first child as the new root
// if it has a child, otherwise set root as NULL
if (root->n==0)
{
BTreeNode *tmp = root;
if (root->leaf)
root = NULL;
else
root = root->C[0];
// Free the old root

delete tmp;
}
return;
}

int main()
{
BTree t(3); // A B-Tree with minium degree 3
t.insert(1);
t.insert(3);
t.insert(7);
t.insert(10);
t.insert(11);
t.insert(13);
t.insert(14);
t.insert(15);
t.insert(18);
t.insert(16);
t.insert(19);
t.insert(24);
t.insert(25);
t.insert(26);
t.insert(21);
t.insert(4);
t.insert(5);
t.insert(20);
t.insert(22);
t.insert(2);
t.insert(17);
t.insert(12);
t.insert(6);
cout << "Traversal of tree constructed is\n";

t.traverse();
cout << endl;
t.remove(6);
cout << "Traversal of tree after removing 6\n";
t.traverse();
cout << endl;
t.remove(13);
t.traverse();
t.traverse();
cout << endl;
t.remove(7);
t.traverse();
cout << endl;
t.remove(4);
t.traverse();
cout << endl;
t.remove(2);
t.traverse();
cout << endl;
t.remove(16);
t.traverse();
cout << endl;
return 0;
}

Output:

Traversal of tree constructed is
1 2 3 4 5 6 7 10 11 12 13 14 15 16 17 18 19 20 21 22 24 25 26
Traversal of tree after removing 6
1 2 3 4 5 7 10 11 12 13 14 15 16 17 18 19 20 21 22 24 25 26
1 2 3 4 5 7 10 11 12 14 15 16 17 18 19 20 21 22 24 25 26
1 2 3 4 5 10 11 12 14 15 16 17 18 19 20 21 22 24 25 26
1 2 3 5 10 11 12 14 15 16 17 18 19 20 21 22 24 25 26
1 3 5 10 11 12 14 15 16 17 18 19 20 21 22 24 25 26
1 3 5 10 11 12 14 15 17 18 19 20 21 22 24 25 26

This article is contributed by Balasubramanian.N . Please write comments if you find anything incorrect,
Dynamic Programming | Set 36 (Maximum Product Cutting)
Given a rope of length n meters, cut the rope in different parts of integer lengths in a way that maximizes
product of lengths of all parts. You must make at least one cut. Assume that the length of rope is more than 2
meters.
Examples:
Input: n = 2
Output: 1 (Maximum obtainable product is 1*1)
Input: n = 3
Input: n = 4
Input: n = 5
Input: n = 10
Output: 36 (Maximum obtainable product is 3*3*4)

This problem is similar to Rod Cutting Problem. We can get the maximum product by making a cut at
different positions and comparing the values obtained after a cut. We can recursively call the same function
for a piece obtained after a cut.
Let maxProd(n) be the maximum product for a rope of length n. maxProd(n) can be written as following.
maxProd(n) = max(i*(n-i), maxProdRec(n-i)*i) for all i in {1, 2, 3 .. n}
Following is simple recursive C++ implementation of the problem. The implementation simply follows the

// A Naive Recursive method to find maxium product

#include <iostream>
// Utility function to get the maximum of two and three integers

int max(int a, int b, int c) { return max(a, max(b, c));}
// The main function that returns maximum product obtainable

// from a rope of length n
int maxProd(int n)
{
// Base cases
if (n == 0 || n == 1) return 0;
// Make a cut at different places and take the maximum of all

int max_val = 0;
for (int i = 1; i < n; i++)
max_val = max(max_val, i*(n-i), maxProd(n-i)*i);
// Return the maximum of all values

return max_val;
}

int main()
{
cout << "Maximum Product is " << maxProd(10);
return 0;
}

Output:

Maximum Product is 36

Considering the above implementation, following is recursion tree for a Rope of length 5.
mP() ---> maxProd()
mP(5)
/ / \ \
/ / \ \
mP(4) mP(3) mP(2) mP(1)
/ | \ / \ |
/ | \ / \ |
mP(3) mP(2) mP(1) mP(2) mP(1) mP(1)
/ \ | |
/ \ | |
mP(2) mP(1) mP(1) mP(1)

In the above partial recursion tree, mP(3) is being solved twice. We can see that there are many subproblems
which are solved again and again. Since same suproblems are called again, this problem has Overlapping
Subprolems property. So the problem has both properties (see this and this) of a dynamic programming
problem. Like other typical Dynamic Programming(DP) problems, recomputations of same subproblems
can be avoided by constructing a temporary array val[] in bottom up manner.
// A Dynamic Programming solution for Max Product Problem

int maxProd(int n)
{
int val[n+1];
val[0] = val[1] = 0;

// Build the table val[] in bottom up manner and return
// the last entry from the table
for (int i = 1; i <= n; i++)
{
int max_val = 0;
for (int j = 1; j <= i/2; j++)
max_val = max(max_val, (i-j)*j, j*val[i-j]);
val[i] = max_val;
}
return val[n];
}

Time Complexity of the Dynamic Programming solution is O(n^2) and it requires O(n) extra space.
A Tricky Solution:
If we see some examples of this problems, we can easily observe following pattern.
The maximum product can be obtained be repeatedly cutting parts of size 3 while size is greater than 4,
keeping the last part as size of 2 or 3 or 4. For example, n = 10, the maximum product is obtained by 3, 3, 4.
For n = 11, the maximum product is obtained by 3, 3, 3, 2. Following is C++ implementation of this
approach.

#include <iostream>
/* The main function that teturns the max possible product */

int maxProd(int n)
{
// n equals to 2 or 3 must be handled explicitly
if (n == 2 || n == 3) return (n-1);
// Keep removing parts of size 3 while n is greater than 4

int res = 1;
while (n > 4)
{
n -= 3;
res *= 3; // Keep multiplying 3 to res
}
return (n * res); // The last part multiplied by previous parts
}

int main()
{
cout << "Maximum Product is " << maxProd(10);
return 0;
}

Output:

Maximum Product is 36

discussed above
Self Organizing List | Set 1 (Introduction)
The worst case search time for a sorted linked list is O(n). With a Balanced Binary Search Tree, we can skip
almost half of the nodes after one comparison with root. For a sorted array, we have random access and we
can apply Binary Search on arrays.
One idea to make search faster for Linked Lists is Skip List. Another idea (which is discussed in this post) is
to place more frequently accessed items closer to head.. There can be two possibilities. offline (we know the
complete search sequence in advance) and online (we don’t know the search sequence).
In case of offline, we can put the nodes according to decreasing frequencies of search (The element having
maximum search count is put first). For many practical applications, it may be difficult to obtain search
sequence in advance. A Self Organizing list reorders its nodes based on searches which are done. The idea is
to use locality of reference (In a typical database, 80% of the access are to 20% of the items). Following are
different strategies used by Self Organizing Lists.
1) Move-to-Front Method: Any node searched is moved to the front. This strategy is easy to implement,
but it may over-reward infrequently accessed items as it always move the item to front.
2) Count Method: Each node stores count of the number of times it was searched. Nodes are ordered by
decreasing count. This strategy requires extra space for storing count.
3) Transpose Method: Any node searched is swapped with the preceding node. Unlike Move-to-front,
this method does not adapt quickly to changing access patterns.
Competitive Analysis:
The worst case time complexity of all methods is O(n). In worst case, the searched element is always the last
element in list. For average case analysis, we need probability distribution of search sequences which is not
available many times.
For online strategies and algorithms like above, we have a totally different way of analyzing them called
competitive analysis where performance of an online algorithm is compared to the performance of an
optimal offline algorithm (that can view the sequence of requests in advance). Competitive analysis is used in
many practical algorithms like caching, disk paging, high performance computers. The best thing about
competitive analysis is, we don’t need to assume anything about probability distribution of input. The Move-
to-front method is 4-competitive, means it never does more than a factor of 4 operations than offline
algorithm (See the MIT video lecture for proof).
We will soon be discussing implementation and proof of the analysis given in the video lecture.
References:
http://en.wikipedia.org/wiki/Self-organizing_list
MIT Video Lecture
http://www.eecs.yorku.ca/course_archive/2003-04/F/2011/2011A/DatStr_071_SOLists.pdf
http://en.wikipedia.org/wiki/Competitive_analysis_(online_algorithm)
to share more information about the topic discussed above
Add all greater values to every node in a given BST
Given a Binary Search Tree (BST), modify it so that all greater values in the given BST are added to every
node. For example, consider the following BST.
50
/ \
30 70
/ \ / \
20 40 60 80
The above tree should be modified to following
260
/ \
330 150
/ \ / \
350 300 210 80

A simple method for solving this is to find sum of all greater values for every node. This method would take
O(n^2) time.
We can do it using a single traversal . The idea is to use following BST property. If we do reverse Inorder
traversal of BST, we get all nodes in decreasing order. We do reverse Inorder traversal and keep track of the
sum of all nodes visited so far, we add this sum to every node.
// C program to add all greater values in every node of BST

#include<stdio.h>
#include<stdlib.h>
struct node
{
int data;
};
// A utility function to create a new BST node

{
temp->data = item;
return temp;
}
// Recursive function to add all greater values in every node

void modifyBSTUtil(struct node *root, int *sum)
{
// Base Case

modifyBSTUtil(root->right, sum);
// Now *sum has sum of nodes in right subtree, add

// Now *sum has sum of nodes in right subtree, add
// root->data to sum and update root->data
*sum = *sum + root->data;
root->data = *sum;
// Recur for left subtree

modifyBSTUtil(root->left, sum);
}
// A wrapper over modifyBSTUtil()

void modifyBST(struct node *root)
{
int sum = 0;
modifyBSTUtil(root, &sum);
}
// A utility function to do inorder traversal of BST

{
if (root != NULL)
{
}
}
/* A utility function to insert a new node with given data in BST */

{
/* If the tree is empty, return a new node */
if (node == NULL) return newNode(data);
/* Otherwise, recur down the tree */

node->left = insert(node->left, data);
else
node->right = insert(node->right, data);

return node;
}

int main()
{
/* Let us create following BST
50
/ \
30 70
/ \ / \
20 40 60 80 */
insert(root, 30);
insert(root, 20);
insert(root, 40);
insert(root, 70);
insert(root, 60);
insert(root, 80);
modifyBST(root);
// print inoder tarversal of the modified BST

inorder(root);
inorder(root);
return 0;
}

Output

350 330 300 260 210 150 80

Time Complexity: O(n) where n is number of nodes in the given BST.
As a side note, we can also use reverse Inorder traversal to find kth largest element in a BST.
Longest Path in a Directed Acyclic Graph
Given a Weighted Directed Acyclic Graph (DAG) and a source vertex s in it, find the longest distances from s
to all other vertices in the given graph.
The longest path problem for a general graph is not as easy as the shortest path problem because the longest
path problem doesn’t have optimal substructure property. In fact, the Longest Path problem is NP-Hard for
a general graph. However, the longest path problem has a linear time solution for directed acyclic graphs.
The idea is similar to linear time solution for shortest path in a directed acyclic graph., we use Tological
Sorting.
We initialize distances to all vertices as minus infinite and distance to source as 0, then we find a
topological
sorting of the graph. Topological Sorting of a graph represents a linear ordering of the graph (See below,
figure (b) is a linear representation of figure (a) ). Once we have topological order (or linear representation),
we one by one process all vertices in topological order. For every vertex being processed, we update distances
of its adjacent using distance of current vertex.
Following figure shows step by step process of finding longest paths.
Following is complete algorithm for finding longest distances.

1) Initialize dist[] = {NINF, NINF, ….} and dist[s] = 0 where s is the source vertex. Here NINF means
negative infinite.
2) Create a toplogical order of all vertices.
3) Do following for every vertex u in topological order.
………..Do following for every adjacent vertex v of u
………………if (dist[v] // A C++ program to find single source longest distances in a DAG #include
<iostream> #include <list> #include <stack> #include <limits.h> #define NINF INT_MIN using
namespace std; // Graph is represented using adjacency list. Every node of adjacency list // contains vertex
number of the vertex to which edge connects. It also // contains weight of the edge class AdjListNode { int v;
int weight; public: AdjListNode(int _v, int _w) { v = _v; weight = _w;} int getV() { return v; } int getWeight()
{ return weight; } }; // Class to represent a graph using adjacency list representation class Graph { int V; //
No. of vertices’ // Pointer to an array containing adjacency lists list<AdjListNode> *adj; // A function used
by longestPath void topologicalSortUtil(int v, bool visited[], stack<int> &Stack); public: Graph(int V); //
Constructor // function to add an edge to graph void addEdge(int u, int v, int weight); // Finds longest
distances from given source vertex void longestPath(int s); }; Graph::Graph(int V) // Constructor { this->V =
V; adj = new list<AdjListNode>[V]; } void Graph::addEdge(int u, int v, int weight) { AdjListNode node(v,
weight); adj[u].push_back(node); // Add v to u’s list } // A recursive function used by longestPath. See
below link for details // http://www.geeksforgeeks.org/topological-sorting/ void
Graph::topologicalSortUtil(int v, bool visited[], stack<int> &Stack) { // Mark the current node as visited
visited[v] = true; // Recur for all the vertices adjacent to this vertex list<AdjListNode>::iterator i; for (i =
adj[v].begin(); i != adj[v].end(); ++i) { AdjListNode node = *i; if (!visited[node.getV()])
topologicalSortUtil(node.getV(), visited, Stack); } // Push current vertex to stack which stores topological
sort Stack.push(v); } // The function to find longest distances from a given vertex. It uses // recursive
topologicalSortUtil() to get topological sorting. void Graph::longestPath(int s) { stack<int> Stack; int
dist[V]; // Mark all the vertices as not visited bool *visited = new bool[V]; for (int i = 0; i < V; i++) visited[i]
= false; // Call the recursive helper function to store Topological Sort // starting from all vertices one by one
for (int i = 0; i < V; i++) if (visited[i] == false) topologicalSortUtil(i, visited, Stack); // Initialize distances to
all vertices as infinite and distance // to source as 0 for (int i = 0; i < V; i++) dist[i] = NINF; dist[s] = 0; //
Process vertices in topological order while (Stack.empty() == false) { // Get the next vertex from topological
order int u = Stack.top(); Stack.pop(); // Update distances of all adjacent vertices
list<AdjListNode>::iterator i; if (dist[u] != NINF) { for (i = adj[u].begin(); i != adj[u].end(); ++i) if (dist[i-
>getV()] < dist[u] + i->getWeight()) dist[i->getV()] = dist[u] + i->getWeight(); } } // Print the calculated
longest distances for (int i = 0; i < V; i++) (dist[i] == NINF)? cout << "INF ": cout << dist[i] << " "; } //
Driver program to test above functions int main() { // Create a graph given in the above diagram. Here
vertex numbers are // 0, 1, 2, 3, 4, 5 with following mappings: // 0=r, 1=s, 2=t, 3=x, 4=y, 5=z Graph g(6);
g.addEdge(0, 1, 5); g.addEdge(0, 2, 3); g.addEdge(1, 3, 6); g.addEdge(1, 2, 2); g.addEdge(2, 4, 4);
g.addEdge(2, 5, 2); g.addEdge(2, 3, 7); g.addEdge(3, 5, 1); g.addEdge(3, 4, -1); g.addEdge(4, 5, -2); int s = 1;
cout << "Following are longest distances from source vertex " << s <<" \n"; g.longestPath(s); return 0; }
Output:

Following are longest distances from source vertex 1
INF 0 2 9 8 10

Time Complexity: Time complexity of topological sorting is O(V+E). After finding topological order, the
algorithm process all vertices and for every vertex, it runs a loop for all adjacent vertices. Total adjacent
vertices in a graph is O(E). So the inner loop runs O(V+E) times. Therefore, overall time complexity of this
algorithm is O(V+E).
Exercise: The above solution print longest distances, extend the code to print paths also.
discussed above
Remove all nodes which don’t lie in any path with sum>= k
Given a binary tree, a complete path is defined as a path from root to a leaf. The sum of all nodes on that path
is defined as the sum of that path. Given a number K, you have to remove (prune the tree) all nodes which
don’t lie in any path with sum>=k.
Note: A node can be part of multiple paths. So we have to delete it only in case when all paths from it have
sum less than K.
Consider the following Binary Tree

1
/ \
2 3
/ \ / \
4 5 6 7
/ \ / /
8 9 12 10
/ \ \
13 14 11
/
15
For input k = 20, the tree should be changed to following

(Nodes with values 6 and 8 are deleted)
1
/ \
2 3
/ \ \
4 5 7
\ / /
9 12 10
/ \ \
13 14 11
/
15
For input k = 45, the tree should be changed to following.

1
/
2
/
4
\
9
\
14
/
15
The idea is to traverse the tree and delete nodes in bottom up manner. While traversing the tree, recursively
calculate the sum of nodes from root to leaf node of each path. For each visited node, checks the total
calculated sum against given sum “k”. If sum is less than k, then free(delete) that node (leaf node) and
return the sum back to the previous node. Since the path is from root to leaf and nodes are deleted in bottom
up manner, a node is deleted only when all of its descendants are deleted. Therefore, when a node is deleted,
it must be a leaf in the current Binary Tree.
#include <stdio.h>
#include <stdlib.h>

int max(int l, int r) { return (l > r ? l : r); }

struct Node
{
int data;
};
// A utility function to create a new Binary Tree node with given data
{
node->data = data;
return node;
}
// print the tree in LVR (Inorder traversal) way.

void print(struct Node *root)
{
if (root != NULL)
{
print(root->left);
print(root->right);
}
}
/* Main function which truncates the binary tree. */

struct Node *pruneUtil(struct Node *root, int k, int *sum)
{
// Base Case
if (root == NULL) return NULL;
// Initialize left and right sums as sum from root to

// this node (including this node)
int lsum = *sum + (root->data);
int rsum = lsum;
// Recursively prune left and right subtrees

root->left = pruneUtil(root->left, k, &lsum);
root->right = pruneUtil(root->right, k, &rsum);
// Get the maximum of left and right sums

*sum = max(lsum, rsum);
// If maximum is smaller than k, then this node

// must be deleted
if (*sum < k)
{
free(root);
root = NULL;
}
return root;
}
// A wrapper over pruneUtil()

struct Node *prune(struct Node *root, int k)
{
int sum = 0;
return pruneUtil(root, k, &sum);
}

int main()
{
int k = 45;
root->right->right->left->right = newNode(11);
root->left->left->right->left = newNode(13);
root->left->left->right->right = newNode(14);
root->left->left->right->right->left = newNode(15);
printf("Tree before truncation\n");

print(root);
root = prune(root, k); // k is 45
printf("\n\nTree after truncation\n");

print(root);
return 0;
}

Output:

Tree before truncation
8 4 13 9 15 14 2 12 5 1 6 3 10 11 7
Tree after truncation

4 9 15 14 2 1

Time Complexity: O(n), the solution does a single traversal of given Binary Tree.
A Simpler Solution:
The above code can be simplified using the fact that nodes are deleted in bottom up manner. The idea is to
keep reducing the sum when traversing down. When we reach a leaf and sum is greater than the leaf’s data,
then we delete the leaf. Note that deleting nodes may convert a non-leaf node to a leaf node and if the data
for the converted leaf node is less than the current sum, then the converted leaf should also be deleted.
Thanks to vicky for suggesting this solution in below comments.
#include <stdio.h>
#include <stdlib.h>

struct Node
{
int data;
};
// A utility function to create a new Binary

// Tree node with given data
{
struct Node* node =
(struct Node*) malloc(sizeof(struct Node));
node->data = data;
return node;
}
// print the tree in LVR (Inorder traversal) way.

{
if (root != NULL)
{
print(root->left);
print(root->right);
}
}
/* Main function which truncates the binary tree. */

struct Node *prune(struct Node *root, int sum)
{
// Base Case

root->left = prune(root->left, sum - root->data);
root->right = prune(root->right, sum - root->data);
// If we reach leaf whose data is smaller than sum,

// we delete the leaf. An important thing to note
// is a non-leaf node can become leaf when its
// chilren are deleted.
if (root->left==NULL && root->right==NULL)
{
if (root->data < sum)
{
free(root);
return NULL;
}
}
return root;
}
int main()
{
int k = 45;
root->left->left->right->right->left = newNode(15);
printf("Tree before truncation\n");

print(root);
root = prune(root, k); // k is 45
printf("\n\nTree after truncation\n");

print(root);
return 0;
}

Output:

Tree before truncation
8 4 13 9 15 14 2 12 5 1 6 3 10 11 7
Tree after truncation

4 9 15 14 2 1

Find maximum number of edge disjoint paths between two vertices
Given a directed graph and two vertices in it, source ‘s’ and destination ‘t’, find out the maximum number of
edge disjoint paths from s to t. Two paths are said edge disjoint if they don’t share any edge.
There can be maximum two edge disjoint paths from source 0 to destination 7 in the above graph. Two edge
disjoint paths are highlighted below in red and blue colors are 0-2-6-7 and 0-3-6-5-7.
Note that the paths may be different, but the maximum number is same. For example, in the above diagram,
another possible set of paths is 0-1-2-6-7 and 0-3-6-5-7 respectively.
This problem can be solved by reducing it to maximum flow problem. Following are steps.
1) Consider the given source and destination as source and sink in flow network. Assign unit capacity to
each edge.
2) Run Ford-Fulkerson algorithm to find the maximum flow from source to sink.
3) The maximum flow is equal to the maximum number of edge-disjoint paths.
When we run Ford-Fulkerson, we reduce the capacity by a unit. Therefore, the edge can not be used again. So
the maximum flow is equal to the maximum number of edge-disjoint paths.
Following is C++ implementation of the above algorithm. Most of the code is taken from here.
// C++ program to find maximum number of edge disjoint paths

#include <iostream>
#include <limits.h>
#include <string.h>
#include <queue>

#define V 8

bool bfs(int rGraph[V][V], int s, int t, int parent[])
{
bool visited[V];

// as visited
queue <int> q;
q.push(s);
visited[s] = true;
parent[s] = -1;

while (!q.empty())
{
int u = q.front();
q.pop();

{
{
q.push(v);
parent[v] = u;
visited[v] = true;
}
}
}

// true, else false
}
// Returns tne maximum number of edge-disjoint paths from s to t.

// This function is copy of forFulkerson() discussed at http://goo.gl/wtQ4Ks
int findDisjointPaths(int graph[V][V], int s, int t)
{
int u, v;

int rGraph[V][V]; // Residual graph where rGraph[i][j] indicates
// residual capacity of edge from i to j (if there
// is an edge. If rGraph[i][j] is 0, then there is not)
for (u = 0; u < V; u++)
for (v = 0; v < V; v++)
int max_flow = 0; // There is no flow initially

{
// Find minimum residual capacity of the edges along the

{
u = parent[v];
}

// along the path
{
u = parent[v];
}
// Add path flow to overall flow

max_flow += path_flow;
}
// Return the overall flow (max_flow is equal to maximum

// number of edge-disjoint paths)
return max_flow;
}

int main()
{
int graph[V][V] = { {0, 1, 1, 1, 0, 0, 0, 0},
{0, 0, 1, 0, 0, 0, 0, 0},
{0, 0, 0, 1, 0, 0, 1, 0},
{0, 0, 0, 0, 0, 0, 1, 0},
{0, 0, 1, 0, 0, 0, 0, 1},
{0, 1, 0, 0, 0, 0, 0, 1},
{0, 0, 0, 0, 0, 1, 0, 1},
{0, 0, 0, 0, 0, 0, 0, 0}
};
int s = 0;
int t = 7;
cout << "There can be maximum " << findDisjointPaths(graph, s, t)
<< " edge-disjoint paths from " << s <<" to "<< t ;
return 0;
}

Output:
There can be maximum 2 edge-disjoint paths from 0 to 7

Time Complexity: Same as time complexity of Edmonds-Karp implementation of Ford-Fulkerson (See

time complexity discussed here)
References:
http://www.win.tue.nl/~nikhil/courses/2012/2WO08/max-flow-applications-4up.pdf
discussed above
Extract Leaves of a Binary Tree in a Doubly Linked List
Given a Binary Tree, extract all leaves of it in a D oubly Linked List (DLL). Note that the DLL need to be
created in-place. Assume that the node structure of DLL and Binary Tree is same, only the meaning of left
and right pointers are different. In DLL, left means previous pointer and right means next pointer.
Let the following be input binary tree

1
/ \
2 3
/ \ \
4 5 6
/ \ / \
7 8 9 10
Output:
Doubly Linked List
785910
Modified Tree:
1
/ \
2 3
/ \
4 6

We need to traverse all leaves and connect them by changing their left and right pointers. We also need to
remove them from Binary Tree by changing left or right pointers in parent nodes. There can be many ways
to solve this. In the following implementation, we add leaves at the beginning of current linked list and
update head of the list using pointer to head pointer. Since we insert at the beginning, we need to process
leaves in reverse order. For reverse order, we first traverse the right subtree then the left subtree. We use
return values to update left or right pointers in parent nodes.
// C program to extract leaves of a Binary Tree in a Doubly Linked List

#include <stdio.h>
#include <stdlib.h>
// Structure for tree and linked list

struct Node
{
int data;
};
// Main function which extracts all leaves from given Binary Tree.
// The function returns new root of Binary Tree (Note that root may change
// if Binary Tree has only one node). The function also sets *head_ref as
// head of doubly linked list. left pointer of tree is used as prev in DLL
// and right pointer is used as next
struct Node* extractLeafList(struct Node *root, struct Node **head_ref)
{
// Base cases

{
// This node is going to be added to doubly linked list
// of leaves, set right pointer of this node as previous
// head of DLL. We don't need to set left pointer as left
// is already NULL
root->right = *head_ref;
// Change left pointer of previous head

if (*head_ref != NULL) (*head_ref)->left = root;
// Change head of linked list

*head_ref = root;
return NULL; // Return new root

}
// Recur for right and left subtrees

root->right = extractLeafList(root->right, head_ref);
root->left = extractLeafList(root->left, head_ref);
return root;
}
// Utility function for allocating node for Binary Tree.

{
struct Node* node = (struct Node*)malloc(sizeof(struct Node));
node->data = data;
return node;
}
// Utility function for printing tree in In-Order.

{
if (root != NULL)
{
print(root->left);
print(root->right);
}
}
// Utility function for printing double linked list.

void printList(struct Node *head)
{
while (head)
{
head = head->right;
}
}

int main()
{
struct Node *head = NULL;
printf("Inorder Trvaersal of given Tree is:\n");

print(root);
root = extractLeafList(root, &head);
printf("\nExtracted Double Linked list is:\n");

printList(head);
printf("\nInorder traversal of modified tree is:\n");

print(root);
return 0;
}
Output:

Inorder Trvaersal of given Tree is:
7 4 8 2 5 1 3 9 6 10
Extracted Double Linked list is:
7 8 5 9 10
Inorder traversal of modified tree is:
4 2 1 3 6

Time Complexity: O(n), the solution does a single traversal of given Binary Tree.
Find the first non-repeating character from a stream of characters
Given a stream of characters, find the first non-repeating character from stream. You need to tell the first
non-repeating character in O(1) time at any moment.
If we follow the first approach discussed here, then we need to store the stream so that we can traverse it one
more time to find the first non-repeating character at any moment. If we use extended approach discussed in
the same post, we need to go through the count array every time first non-repeating element is queried. We
can find the first non-repeating character from stream at any moment without traversing any array.
We strongly recommend you to minimize the browser and try it yourself first.
The idea is to use a DLL (Doubly Linked List) to efficiently get the first non-repeating character from a
stream. The DLL contains all non-repeating characters in order, i.e., the head of DLL contains first non-
repeating character, the second node contains the second non-repeating and so on.
We also maintain two arrays: one array is to maintain characters that are already visited two or more times,
we call it repeated[], the other array is array of pointers to linked list nodes, we call it inDLL[]. The size of
both arrays is equal to alphabet size which is typically 256.
1) Create an empty DLL. Also create two arrays inDLL[] and repeated[] of size 256.
inDLL is an array of pointers to DLL nodes. repeated[] is a boolean array,
repeated[x] is true if x is repeated two or more times, otherwise false.
inDLL[x] contains pointer to a DLL node if character x is present in DLL,
otherwise NULL.
2) Initialize all entries of inDLL[] as NULL and repeated[] as false.
3) To get the first non-repeating character, return character at head of DLL.
4) Following are steps to process a new character 'x' in stream.

a) If repeated[x] is true, ignore this character (x is already repeated two
or more times in the stream)
b) If repeated[x] is false and inDLL[x] is NULL (x is seen first time)
Append x to DLL and store address of new DLL node in inDLL[x].
c) If repeated[x] is false and inDLL[x] is not NULL (x is seen second time)
Get DLL node of x using inDLL[x] and remove the node. Also, mark inDLL[x]
as NULL and repeated[x] as true.

Note that appending a new node to DLL is O(1) operation if we maintain tail pointer. Removing a node from
DLL is also O(1). So both operations, addition of new character and finding first non-repeating character
take O(1) time.
// A C++ program to find first non-repeating character from a stream of characters

#include <iostream>
// A linked list node

struct node
{
char a;
struct node *next, *prev;
};
// A utility function to append a character x at the end of DLL.

// A utility function to append a character x at the end of DLL.
// Note that the function may change head and tail pointers, that
// is why pointers to these pointers are passed.
void appendNode(struct node **head_ref, struct node **tail_ref, char x)
{
struct node *temp = new node;
temp->a = x;
temp->prev = temp->next = NULL;
{
*head_ref = *tail_ref = temp;
return;
}
(*tail_ref)->next = temp;
temp->prev = *tail_ref;
*tail_ref = temp;
}
// A utility function to remove a node 'temp' fromt DLL. Note that the
// function may change head and tail pointers, that is why pointers to
// these pointers are passed.
void removeNode(struct node **head_ref, struct node **tail_ref,
struct node *temp)
{
return;
if (*head_ref == temp)
if (*tail_ref == temp)
*tail_ref = (*tail_ref)->prev;
if (temp->next != NULL)
temp->next->prev = temp->prev;
if (temp->prev != NULL)
temp->prev->next = temp->next;
delete(temp);
}
void findFirstNonRepeating()
{
// inDLL[x] contains pointer to a DLL node if x is present in DLL.
// If x is not present, then inDLL[x] is NULL
struct node *inDLL[MAX_CHAR];
// repeated[x] is true if x is repeated two or more times. If x is

// not seen so far or x is seen only once. then repeated[x] is false
bool repeated[MAX_CHAR];
// Initialize the above two arrays

struct node *head = NULL, *tail = NULL;
for (int i = 0; i < MAX_CHAR; i++)
{
inDLL[i] = NULL;
repeated[i] = false;
}
// Let us consider following stream and see the process

char stream[] = "geeksforgeeksandgeeksquizfor";
for (int i = 0; stream[i]; i++)
{
char x = stream[i];
cout << "Reading " << x << " from stream \n";
// We process this character only if it has not occurred or occurred
// only once. repeated[x] is true if x is repeated twice or more.s
if (!repeated[x])
{
// If the character is not in DLL, then add this at the end of DLL.
if (inDLL[x] == NULL)
{
appendNode(&head, &tail, stream[i]);
inDLL[x] = tail;
}
else // Otherwise remove this caharacter from DLL
{
removeNode(&head, &tail, inDLL[x]);
inDLL[x] = NULL;
repeated[x] = true; // Also mark it as repeated
}
}
// Print the current first non-repeating character from stream

if (head != NULL)
cout << "First non-repeating character so far is " << head->a << endl;
}
}

int main()
{
findFirstNonRepeating();
return 0;
}

Output:

Reading g from stream
First non-repeating character so far is g
Reading e from stream
Reading k from stream
Reading s from stream
Reading f from stream
Reading o from stream
Reading r from stream
First non-repeating character so far is k
First non-repeating character so far is s
First non-repeating character so far is f
Reading a from stream
Reading n from stream
Reading d from stream
Reading q from stream
Reading u from stream
Reading i from stream
Reading z from stream
Reading f from stream
First non-repeating character so far is o
Reading o from stream
First non-repeating character so far is r
Reading r from stream
First non-repeating character so far is a

Recursively remove all adjacent duplicates
Given a string, recursively remove adjacent duplicate characters from string. The output string should not
have any adjacent duplicates. See following examples.
Input: azxxzy
Output: ay
First "azxxzy" is reduced to "azzy". The string "azzy" contains duplicates,
so it is further reduced to "ay".
Input: geeksforgeeg
Output: gksfor
First "geeksforgeeg" is reduced to "gksforgg". The string "gksforgg" contains
duplicates, so it is further reduced to "gksfor".
Input: caaabbbaacdddd
Output: Empty String
Input: acaaabbbacdddd
Output: acac

A simple approach would be to run the input string through multiple passes. In every pass remove all
adjacent duplicates from left to right. Stop running passes when there are no duplicates. The worst time
complexity of this method would be O(n^2).
We can remove all duplicates in O(n) time.

1) Start from the leftmost character and remove duplicates at left corner if there are any.
2) The first character must be different from its adjacent now. Recur for string of length n-1 (string without
first character).
3) Let the string obtained after reducing right substring of length n-1 be rem_str. There are three possible
cases
……..a) If first character of rem_str matches with the first character of original string, remove the first
character from rem_str.
……..b) Else if the last removed character in recursive calls is same as the first character of the original string.
Ignore the first character of original string and return rem_str.
……..c) Else, append the first character of the original string at the beginning of rem_str.
4) Return rem_str.
#include <iostream>
#include <string.h>
// Recursively removes adjacent duplicates from str and returns new

// string. las_removed is a pointer to last_removed character
char* removeUtil(char *str, char *last_removed)
{
// If length of string is 1 or 0
if (str[0] == '\0' || str[1] == '\0')
return str;
// Remove leftmost same characters and recur for remaining string

if (str[0] == str[1])
if (str[0] == str[1])
{
*last_removed = str[0];
while (str[1] && str[0] == str[1])
str++;
str++;
return removeUtil(str, last_removed);
}
// At this point, the first character is definiotely different from its

// adjacent. Ignore first character and recursively remove characters from
// remaining string
char* rem_str = removeUtil(str+1, last_removed);
// Check if the first character of the rem_string matches with the

// first character of the original string
if (rem_str[0] && rem_str[0] == str[0])
{
*last_removed = str[0];
return (rem_str+1); // Remove first character
}
// If remaining string becomes empty and last removed character

// is same as first character of original string. This is needed
// for a string like "acbbcddc"
if (rem_str[0] == '\0' && *last_removed == str[0])
return rem_str;
// If the two first characters of str and rem_str don't match, append
// first character of str before the first character of rem_str.
rem_str--;
rem_str[0] = str[0];
return rem_str;
}
char *remove(char *str)

{
char last_removed = '\0';
return removeUtil(str, &last_removed);
}

int main()
{
char str1[] = "geeksforgeeg";
cout << remove(str1) << endl;
char str2[] = "azxxxzy";

char str3[] = "caaabbbaac";

char str4[] = "gghhg";

char str5[] = "aaaacddddcappp";

char str6[] = "aaaaaaaaaa";

char str7[] = "qpaaaaadaaaaadprq";

char str8[] = "acaaabbbacdddd";
char str9[] = "acbbcddc";

return 0;
}

Output:
gksfor
ay
g
a
qrq
acac
a

Time Complexity: The time complexity of the solution can be written as T(n) = T(n-k) + O(k) where n is
length of the input string and k is the number of first characters which are same. Solution of the recurrence is
O(n)
Thanks to Prachi Bodke for suggesting this problem and initial solution. Please write comments if you find
Detect cycle in an undirected graph
Given an undirected graph, how to check if there is a cycle in the graph? For example, the following graph
has a cycle 1-0-2-1.
We have discussed cycle detection for directed graph. We have also discussed a union-find algorithm for
cycle detection in undirected graphs. The time complexity of the union-find algorithm is O(ELogV). Like
directed graphs, we can use DFS to detect cycle in an undirected graph in O(V+E) time. We do a DFS
traversal of the given graph. For every visited vertex ‘v’, if there is an adjacent ‘u’ such that u is already
visited and u is not parent of v, then there is a cycle in graph. If we don’t find such an adjacent for any vertex,
we say that there is no cycle. The assumption of this approach is that there are no parallel edges between any
two vertices.

// A C++ Program to detect cycle in an undirected graph
#include<iostream>
#include <list>
#include <limits.h>
// Class for an undirected graph

class Graph
{
bool isCyclicUtil(int v, bool visited[], int parent);
public:
bool isCyclic(); // returns true if there is a cycle
};
Graph::Graph(int V)
{
this->V = V;
}

{
adj[w].push_back(v); // Add v to w’s list.
}
// A recursive function that uses visited[] and parent to detect

// cycle in subgraph reachable from vertex v.
bool Graph::isCyclicUtil(int v, bool visited[], int parent)
{
visited[v] = true;
{
// If an adjacent is not visited, then recur for that adjacent
if (!visited[*i])
{
if (isCyclicUtil(*i, visited, v))
return true;
}
// If an adjacent is visited and not parent of current vertex,

// then there is a cycle.
else if (*i != parent)
return true;
}
return false;
}
// Returns true if the graph contains a cycle, else false.

bool Graph::isCyclic()
{
// Mark all the vertices as not visited and not part of recursion
// stack
for (int i = 0; i < V; i++)
visited[i] = false;
// Call the recursive helper function to detect cycle in different

// DFS trees
for (int u = 0; u < V; u++)
if (!visited[u]) // Don't recur for u if it is already visited
if (isCyclicUtil(u, visited, -1))
return true;
return false;
}

int main()
{
Graph g1(5);
g1.addEdge(1, 0);
g1.addEdge(0, 2);
g1.addEdge(2, 0);
g1.addEdge(0, 3);
g1.addEdge(3, 4);
g1.isCyclic()? cout << "Graph contains cycle\n":
cout << "Graph doesn't contain cycle\n";
Graph g2(3);
g2.addEdge(0, 1);
g2.addEdge(1, 2);
g2.isCyclic()? cout << "Graph contains cycle\n":
cout << "Graph doesn't contain cycle\n";
return 0;
}
Output:

Graph doesn't contain cycle

Time Complexity: The program does a simple DFS Traversal of graph and graph is represented using
adjacency list. So the time complexity is O(V+E)
Exercise: Can we use BFS to detect cycle in an undirected graph in O(V+E) time? What about directed
graphs?
discussed above
Move all zeroes to end of array
Given an array of random numbers, Push all the zero’s of a given array to the end of the array. For example,
if the given arrays is {1, 9, 8, 4, 0, 0, 2, 7, 0, 6, 0}, it should be changed to {1, 9, 8, 4, 2, 7, 6, 0, 0, 0, 0}. The
order of all other elements should be same. Expected time complexity is O(n) and extra space is O(1).
There can be many ways to solve this problem. Following is a simple and interesting way to solve this
problem.
Traverse the given array ‘arr’ from left to right. While traversing, maintain count of non-zero elements in
array. Let the count be ‘count’. For every non-zero element arr[i], put the element at ‘arr[count]’ and
increment ‘count’. After complete traversal, all non-zero elements have already been shifted to front end and
‘count’ is set as index of first 0. Now all we need to do is that run a loop which makes all elements zero from
‘count’ till end of the array.
// A C++ program to move all zeroes at the end of array

#include <iostream>
// Function which pushes all zeros to end of an array.

void pushZerosToEnd(int arr[], int n)
{
int count = 0; // Count of non-zero elements
// Traverse the array. If element encountered is non-zero, then

// replace the element at index 'count' with this element
for (int i = 0; i < n; i++)
if (arr[i] != 0)
arr[count++] = arr[i]; // here count is incremented
// Now all non-zero elements have been shifted to front and 'count' is
// set as index of first 0. Make all elements 0 from count to end.
while (count < n)
arr[count++] = 0;
}

int main()
{
int arr[] = {1, 9, 8, 4, 0, 0, 2, 7, 0, 6, 0, 9};
pushZerosToEnd(arr, n);
cout << "Array after pushing all zeros to end of array :\n";
for (int i = 0; i < n; i++)
cout << arr[i] << " ";
return 0;
}

Output:

Array after pushing all zeros to end of array :
1 9 8 4 2 7 6 9 0 0 0 0

Time Complexity: O(n) where n is number of elements in input array.
How to check if a given number is Fibonacci number?
Given a number ‘n’, how to check if n is a Fibonacci number.
A simple way is to generate Fibonacci numbers until the generated number is greater than or equal to ‘n’.
Following is an interesting property about Fibonacci numbers that can also be used to check if a given
number is Fibonacci or not.
2
A number is Fibonacci if and only if one or both of (5*n + 4) or (5*n2 – 4) is a perfect square (Source:
Wiki). Following is a simple program based on this concept.
// C++ program to check if x is a perfect square

#include <iostream>
#include <math.h>
// A utility function that returns true if x is perfect square

bool isPerfectSquare(int x)
{
int s = sqrt(x);
return (s*s == x);
}
// Returns true if n is a Fibinacci Number, else false

bool isFibonacci(int n)
{
// n is Fibinacci if one of 5*n*n + 4 or 5*n*n - 4 or both
// is a perferct square
return isPerfectSquare(5*n*n + 4) ||
isPerfectSquare(5*n*n - 4);
}
// A utility function to test above functions

int main()
{
for (int i = 1; i <= 10; i++)
isFibonacci(i)? cout << i << " is a Fibonacci Number \n":
cout << i << " is a not Fibonacci Number \n" ;
return 0;
}

Output:
1 is a Fibonacci Number
4 is a not Fibonacci Number

Find number of pairs such that x^y > y^x
Given two arrays X[] and Y[] of positive integers, find number of pairs such that x^y > y^x where x is an
element from X[] and y is an element from Y[].
Examples:
Input: X[] = {2, 1, 6}, Y = {1, 5}

Output: 3
// There are total 3 pairs where pow(x, y) is greater than pow(y, x)
// Pairs are (2, 1), (2, 5) and (6, 1)
Input: X[] = {10, 19, 18}, Y[] = {11, 15, 9};

Output: 2
// There are total 2 pairs where pow(x, y) is greater than pow(y, x)
// Pairs are (10, 11) and (10, 15)

The brute force solution is to consider each element of X[] and Y[], and check whether the given
condition satisfies or not. Time Complexity of this solution is O(m*n) where m and n are sizes of given
arrays.
Following is C++ code based on brute force solution.
int countPairsBruteForce(int X[], int Y[], int m, int n)

{
int ans = 0;
for (int i = 0; i < m; i++)
for (int j = 0; j < n; j++)
if (pow(X[i], Y[j]) > pow(Y[j], X[i]))
ans++;
return ans;
}

Efficient Solution:
The problem can be solved in O(nLogn + mLogn) time. The trick here is, if y > x then x^y > y^x with some
exceptions. Following are simple steps based on this trick.
1) Sort array Y[].

2) For every x in X[], find the index idx of smallest number greater than x (also called ceil of x) in Y[] using
binary search or we can use the inbuilt function upper_bound() in algorithm library.
3) All the numbers after idx satisfy the relation so just add (n-idx) to the count.
Base Cases and Exceptions:

Following are exceptions for x from X[] and y from Y[]
If x = 0, then the count of pairs for this x is 0.
If x = 1, then the count of pairs for this x is equal to count of 0s in Y[].
The following cases must be handled separately as they don’t follow the general rule that x smaller than y
means x^y is greater than y^x.
a) x = 2, y = 3 or 4
b) x = 3, y = 2
Note that the case where x = 4 and y = 2 is not there
Following diagram shows all exceptions in tabular form. The value 1 indicates that the corresponding (x, y)
form a valid pair.
Following is C++ implementation. In the following implementation, we pre-process the Y array and count 0,
1, 2, 3 and 4 in it, so that we can handle all exceptions in constant time. The array NoOfY[] is used to store
the counts.
#include<iostream>
#include<algorithm>
// This function return count of pairs with x as one element

// of the pair. It mainly looks for all values in Y[] where
// x ^ Y[i] > Y[i] ^ x
int count(int x, int Y[], int n, int NoOfY[])
{
// If x is 0, then there cannot be any value in Y such that
// x^Y[i] > Y[i]^x
if (x == 0) return 0;
// If x is 1, then the number of pais is equal to number of

// zeroes in Y[]
if (x == 1) return NoOfY[0];
// Find number of elements in Y[] with values greater than x

// upper_bound() gets address of first greater element in Y[0..n-1]
int* idx = upper_bound(Y, Y + n, x);
int ans = (Y + n) - idx;
// If we have reached here, then x must be greater than 1,

// increase number of pairs for y=0 and y=1
ans += (NoOfY[0] + NoOfY[1]);
// Decrease number of pairs for x=2 and (y=4 or y=3)

if (x == 2) ans -= (NoOfY[3] + NoOfY[4]);
// Increase number of pairs for x=3 and y=2

if (x == 3) ans += NoOfY[2];
return ans;
}
// The main function that returns count of pairs (x, y) such that
// x belongs to X[], y belongs to Y[] and x^y > y^x
int countPairs(int X[], int Y[], int m, int n)
{
{
// To store counts of 0, 1, 2, 3 and 4 in array Y
int NoOfY[5] = {0};
for (int i = 0; i < n; i++)
if (Y[i] < 5)
NoOfY[Y[i]]++;
// Sort Y[] so that we can do binary search in it

sort(Y, Y + n);
int total_pairs = 0; // Initialize result
// Take every element of X and count pairs with it

for (int i=0; i<m; i++)
total_pairs += count(X[i], Y, n, NoOfY);
return total_pairs;
}

int main()
{
int X[] = {2, 1, 6};
int Y[] = {1, 5};
int m = sizeof(X)/sizeof(X[0]);
int n = sizeof(Y)/sizeof(Y[0]);
cout << "Total pairs = " << countPairs(X, Y, m, n);
return 0;
}

Output:

Total pairs = 3

Time Complexity : Let m and n be the sizes of arrays X[] and Y[] respectively. The sort step takes
O(nLogn) time. Then every element of X[] is searched in Y[] using binary search. This step takes O(mLogn)
time. Overall time complexity is O(nLogn + mLogn).
This article is contributed by Shubham Mittal. Please write comments if you find anything incorrect, or
Analysis of Algorithms | Set 3 (Asymptotic Notations)
We have discussed Asymptotic Analysis, and Worst, Average and Best Cases of Algorithms. The main idea of
asymptotic analysis is to have a measure of efficiency of algorithms that doesn’t depend on machine specific
constants, and doesn’t require algorithms to be implemented and time taken by programs to be compared.
Asymptotic notations are mathematical tools to represent time complexity of algorithms for asymptotic
analysis. The following 3 asymptotic notations are mostly used to represent time complexity of algorithms.
1) Θ Notation: The theta notation bounds a functions from above and below, so it defines exact asymptotic
behavior.
A simple way to get Theta notation of an expression is to drop low order terms and ignore leading constants.
For example, consider the following expression.
3n3 + 6n2 + 6000 = Θ(n3)
Dropping lower order terms is always fine because there will always be a n0 after which Θ(n3) beats Θn2)
irrespective of the constants involved.
For a given function g(n), we denote Θ(g(n)) is following set of functions.
Θ((g(n)) = {f(n): there exist positive constants c1, c2 and n0 such that
0 = n0}

The above definition means, if f(n) is theta of g(n), then the value f(n) is always between c1*g(n) and c2*g(n)
for large values of n (n >= n0). The definition of theta also requires that f(n) must be non-negative for values
of n greater than n0.
2) Big O Notation: The Big O notation defines an upper bound of an algorithm, it bounds a function only
from above. For example, consider the case of Insertion Sort. It takes linear time in best case and quadratic
time in worst case. We can safely say that the time complexity of Insertion sort is O(n^2). Note that O(n^2)
also covers linear time.
If we use Θ notation to represent time complexity of Insertion sort, we have to use two statements for best
and worst cases:
1. The worst case time complexity of Insertion Sort is Θ(n^2).
2. The best case time complexity of Insertion Sort is Θ(n).
The Big O notation is useful when we only have upper bound on time complexity of an algorithm. Many
times we easily find an upper bound by simply looking at the algorithm.
O(g(n)) = { f(n): there exist positive constants c and n0 such that

0 = n0}

3) Ω Notation: Just as Big O notation provides an asymptotic upper bound on a function, Ω notation
provides an asymptotic lower bound.
Ω Notationbest case performance of an algorithm is generally not useful, the Omega notation is the least
used notation among all three.
For a given function g(n), we denote by Ω(g(n)) the set of functions.
Ω (g(n)) = {f(n): there exist positive constants c and n0 such that

0 = n0}.

Let us consider the same Insertion sort example here. The time complexity of Insertion Sort can be written as
Ω(n), but it is not a very useful information about insertion sort, as we are generally interested in worst case
and sometimes in average case.
Exercise:
Which of the following statements is/are valid?
1. Time Complexity of QuickSort is Θ(n^2)
2. Time Complexity of QuickSort is O(n^2)
3. For any two functions f(n) and g(n), we have f(n) = Θ(g(n)) if and only if f(n) = O(g(n)) and f(n) = Ω(g(n)).
4. Time complexity of all computer algorithms can be written as Ω(1)
References:
Lec 1 | MIT (Introduction to Algorithms)
L. Rivest
Travelling Salesman Problem | Set 1 (Naive and Dynamic Programming)
Travelling Salesman Problem (TSP): Given a set of cities and distance between every pair of cities, the
problem is to find the shortest possible route that visits every city exactly once and returns to the starting
point.
Note the difference between Hamiltonian Cycle and TSP. The Hamiltoninan cycle problem is to find if there
exist a tour that visits every city exactly once. Here we know that Hamiltonian Tour exists (because the graph
is complete) and in fact many such tours exist, the problem is to find a minimum weight Hamiltonian Cycle.
For example, consider the graph shown in figure on right side. A TSP tour in the graph is 1-2-4-3-1. The cost
of the tour is 10+25+30+15 which is 80.
The problem is a famous NP hard problem. There is no polynomial time know solution for this problem.
Following are different solutions for the traveling salesman problem.
Naive Solution:
1) Consider city 1 as the starting and ending point.
2) Generate all (n-1)! Permutations of cities.
3) Calculate cost of every permutation and keep track of minimum cost permutation.
4) Return the permutation with minimum cost.
Time Complexity: Ω(n!)
Dynamic Programming:
Let the given set of vertices be {1, 2, 3, 4,….n}. Let us consider 1 as starting and ending point of output. For
every other vertex i (other than 1), we find the minimum cost path with 1 as the starting point, i as the ending
point and all vertices appearing exactly once. Let the cost of this path be cost(i), the cost of corresponding
Cycle would be cost(i) + dist(i, 1) where dist(i, 1) is the distance from i to 1. Finally, we return the minimum
of all [cost(i) + dist(i, 1)] values. This looks simple so far. Now the question is how to get cost(i)?
To calculate cost(i) using Dynamic Programming, we need to have some recursive relation in terms of sub-
problems. Let us define a term C(S, i) be the cost of the minimum cost path visiting each vertex in set S
exactly once, starting at 1 and ending at i.
We start with all subsets of size 2 and calculate C(S, i) for all subsets where S is the subset, then we calculate
C(S, i) for all subsets S of size 3 and so on. Note that 1 must be present in every subset.
If size of S is 2, then S must be {1, i},

C(S, i) = dist(1, i)
Else if size of S is greater than 2.
C(S, i) = min { C(S-{i}, j) + dis(j, i)} where j belongs to S, j != i and j != 1.

For a set of size n, we consider n-2 subsets each of size n-1 such that all subsets don’t have nth in them.
Using the above recurrence relation, we can write dynamic programming based solution. There are at most
n 2 n
O(n*2n) subproblems, and each one takes linear time to solve. The total running time is therefore O(n*2
2 n).
The time complexity is much less than O(n!), but still exponential. Space required is also exponential. So this
approach is also infeasible even for slightly higher number of vertices.
We will soon be discussing approximate algorithms for travelling salesman problem.
References:
http://www.lsi.upc.edu/~mjserna/docencia/algofib/P07/dynprog.pdf
http://www.cs.berkeley.edu/~vazirani/algorithms/chap6.pdf
discussed above
Travelling Salesman Problem | Set 2 (Approximate using MST)
We introduced Travelling Salesman Problem and discussed Naive and Dynamic Programming Solutions for
the problem in the previous post,. Both of the solutions are infeasible. In fact, there is no polynomial time
solution available for this problem as the problem is a known NP-Hard problem. There are approximate
algorithms to solve the problem though. The approximate algorithms work only if the problem instance
satisfies Triangle-Inequality.
Triangle-Inequality: The least distant path to reach a vertex j from i is always to reach j directly from i,
rather than through some other vertex k (or vertices), i.e., dis(i, j) is always less than or equal to dis(i, k) +
dist(k, j). The Triangle-Inequality holds in many practical situations.
When the cost function satisfies the triangle inequality, we can design an approximate algorithm for TSP that
returns a tour whose cost is never more than twice the cost of an optimal tour. The idea is to use Minimum
Spanning Tree (MST). Following is the MST based algorithm.
Algorithm:
1) Let 1 be the starting and ending point for salesman.
2) Construct MST from with 1 as root using Prim’s Algorithm.
3) List vertices visited in preorder walk of the constructed MST and add 1 at the end.
Let us consider the following example. The first diagram is the given graph. The second diagram shows MST
constructed with 1 as root. The preorder traversal of MST is 1-2-4-3. Adding 1 at the end gives 1-2-4-3-1
which is the output of this algorithm.
In this case, the approximate algorithm produces the optimal tour, but it may not produce optimal tour in all
cases.
How is this algorithm 2-approximate? The cost of the output produced by the above algorithm is
never more than twice the cost of best possible output. Let us see how is this guaranteed by the above
algorithm.
Let us define a term full walk to understand this. A full walk is lists all vertices when they are first visited in
preorder, it also list vertices when they are returned after a subtree is visited in preorder. The full walk of
above tree would be 1-2-1-4-1-3-1.
Following are some important facts that prove the 2-approximateness.
1) The cost of best possible Travelling Salesman tour is never less than the cost of MST. (The definition of
MST says, it is a minimum cost tree that connects all vertices).
2) The total cost of full walk is at most twice the cost of MST (Every edge of MST is visited at-most twice)
3) The output of the above algorithm is less than the cost of full walk. In above algorithm, we print preorder
walk as output. In prreorder walk, two or more edges of full walk are replaced with a single edge. For
example, 2-1 and 1-4 are replaced by 1 edge 2-4. So if the graph follows triangle inequality, then this is always
true.
From the above three statements, we can conclude that the cost of output produced by the approximate
algorithm is never more than twice the cost of best possible solution.
We have discussed a very simple 2-approximate algorithm for the travelling salesman problem. There are
other better approximate algorithms for the problem. For example Christofides algorithm is 1.5 approximate
algorithm. We will soon be discussing these algorithms as separate posts.
References:
L. Rivest
http://www.personal.kent.edu/~rmuhamma/Algorithms/MyAlgorithms/AproxAlgor/TSP/tsp.htm
discussed above
Johnson’s algorithm for All-pairs shortest paths
The problem is to find shortest paths between every pair of vertices in a given weighted directed Graph and
weights may be negative. We have discussed Floyd Warshall Algorithm for this problem. Time complexity of
Floyd Warshall Algorithm is Θ(V3). Using Johnson’s algorithm, we can find all pair shortest paths in
O(V2log V + VE) time. Johnson’s algorithm uses both Dijkstra and Bellman-Ford as subroutines.
If we apply Dijkstra’s Single Source shortest path algorithm for every vertex, considering every vertex as
source, we can find all pair shortest paths in O(V*VLogV) time. So using Dijkstra’s single source shortest
path seems to be a better option than Floyd Warshell, but the problem with Dijkstra’s algorithm is, it doesn’t
work for negative weight edge.
The idea of Johnson’s algorithm is to re-weight all edges and make them all positive, then apply Dijkstra’s
algorithm for every vertex.
How to transform a given graph to a graph with all non-negative weight edges?
One may think of a simple approach of finding the minimum weight edge and adding this weight to all edges.
Unfortunately, this doesn’t work as there may be different number of edges in different paths (See this for an
example). If there are multiple paths from a vertex u to v, then all paths must be increased by same amount,
so that the shortest path remains the shortest in the transformed graph.
The idea of Johnson’s algorithm is to assign a weight to every vertex. Let the weight assigned to vertex u be
h[u]. We reweight edges using vertex weights. For example, for an edge (u, v) of weight w(u, v), the new
weight becomes w(u, v) + h[u] – h[v]. The great thing about this reweighting is, all set of paths between any
two vertices are increased by same amount and all negative weights become non-negative. Consider any path
between two vertices s and t, weight of every path is increased by h[s] – h[t], all h[] values of vertices on path
from s to t cancel each other.
How do we calculate h[] values? Bellman-Ford algorithm is used for this purpose. Following is the complete
algorithm. A new vertex is added to the graph and connected to all existing vertices. The shortest distance
values from new vertex to all existing vertices are h[] values.
Algorithm:
1) Let the given graph be G. Add a new vertex s to the graph, add edges from new vertex to all vertices of G.
Let the modified graph be G’.
2) Run Bellman-Ford algorithm on G’ with s as source. Let the distances calculated by Bellman-Ford be
h[0], h[1], .. h[V-1]. If we find a negative weight cycle, then return. Note that the negative weight cycle cannot
be created by new vertex s as there is no edge to s. All edges are from s.
3) Reweight the edges of original graph. For each edge (u, v), assign the new weight as “original weight +
h[u] – h[v]”.
4) Remove the added vertex s and run Dijkstra’s algorithm for every vertex.
How does the transformation ensure nonnegative weight edges?

The following property is always true about h[] values as they are shortest distances.
h[v]
The property simply means, shortest distance from s to v must be smaller than or equal t
o shortest distance from s to u plus weight of edge (u, v). The new weights are w(u, v)
+ h[u] - h[v]. The value of the new weights must be greater than or equal to zero becau
se of the inequality "h[v] Example:
Let us consider the following graph.

We add a source s and add edges from s to all vertices of the original graph. In the fo
llowing diagram s is 4.
We calculate the shortest distances from 4 to all other vertices using Bellman-Ford
algorithm. The shortest distances from 4 to 0, 1, 2 and 3 are 0, -5, -1 and 0 respective
ly, i.e., h[] = {0, -5, -1, 0}. Once we get these distances, we remove the source
vertex 4 and reweight the edges using following formula. w(u, v) = w(u, v) + h[u] - h[v
].
Since all weights are positive now, we can run Dijkstra's shortest path algorithm for ev
ery vertex as source.
Time Complexity: The main steps in algorithm are Bellman Ford Algorithm called once and
Dijkstra called V times. Time complexity of Bellman Ford is O(VE) and time complexity o
f Dijkstra is O(VLogV). So overall time complexity is O(V 2log V + VE).
The time complexity of Johnson's algorithm becomes same as Floyd Warshell when the graph
s is complete (For a complete graph E = O(V2). But for sparse graphs, the algorithm perf
orms much better than Floyd Warshell.
References:
Introduction to Algorithms 3rd Edition by Clifford Stein, Thomas H. Cormen, Charles E. L

eiserson, Ronald L. Rivest
http://www.youtube.com/watch?v=b6LOHvCzmkI
http://www.youtube.com/watch?v=TV2Z6nbo1ic
http://en.wikipedia.org/wiki/Johnson%27s_algorithm
http://www.youtube.com/watch?v=Sygq1e0xWnM

Given n line segments, find if any two segments intersect
We have discussed the problem to detect if two given line segments intersect or not. In this post, we extend
the problem. Here we are given n line segments and we need to find out if any two line segments intersect or
not.
Naive Algorithm A naive solution to solve this problem is to check every pair of lines and check if the pair
intersects or not. We can check two line segments in O(1) time. Therefore, this approach takes O(n2).
Sweep Line Algorithm: We can solve this problem in O(nLogn) time using Sweep Line Algorithm. The
algorithm first sorts the end points along the x axis from left to right, then it passes a vertical line through all
points from left to right and checks for intersections. Following are detailed steps.
1) Let there be n given lines. There must be 2n end points to represent the n lines. Sort all points according
to x coordinates. While sorting maintain a flag to indicate whether this point is left point of its line or right
point.
2) Start from the leftmost point. Do following for every point

…..a) If the current point is a left point of its line segment, check for intersection of its line segment with the
segments just above and below it. And add its line to active line segments (line segments for which left end
point is seen, but right end point is not seen yet). Note that we consider only those neighbors which are still
active.
….b) If the current point is a right point, remove its line segment from active list and check whether its two
active neighbors (points just above and below) intersect with each other.
The step 2 is like passing a vertical line from all points starting from the leftmost point to the rightmost
point. That is why this algorithm is called Sweep Line Algorithm. The Sweep Line technique is useful in
many other geometric algorithms like calculating the 2D Voronoi diagram
What data structures should be used for efficient implementation?

In step 2, we need to store all active line segments. We need to do following operations efficiently:
a) Insert a new line segment
b) Delete a line segment
c) Find predecessor and successor according to y coordinate values
The obvious choice for above operations is Self-Balancing Binary Search Tree like AVL Tree, Red Black Tree.
With a Self-Balancing BST, we can do all of the above operations in O(Logn) time.
Also, in step 1, instead of sorting, we can use min heap data structure. Building a min heap takes O(n) time
and every extract min operation takes O(Logn) time (See this).
PseudoCode:
The following pseudocode doesn’t use heap. It simply sort the array.

sweepLineIntersection(Points[0..2n-1]):
1. Sort Points[] from left to right (according to x coordinate)
2. Create an empty Self-Balancing BST T. It will contain all active line

Segments ordered by y coordinate.
// Process all 2n points

3. for i = 0 to 2n-1
// If this point is left end of its line

if (Points[i].isLeft)
T.insert(Points[i].line()) // Insert into the tree
// Check if this points intersects with its predecessor and successor

if ( doIntersect(Points[i].line(), T.pred(Points[i].line()) )
return true
if ( doIntersect(Points[i].line(), T.succ(Points[i].line()) )
return true
else // If it's a right end of its line

// Check if its predecessor and successor intersect with each other
if ( doIntersect(T.pred(Points[i].line(), T.succ(Points[i].line()))
return true
T.delete(Points[i].line()) // Delete from tree
4. return False

Example:
Let us consider the following example taken from here. There are 5 line segments 1, 2, 3, 4 and 5. The
dotted green lines show sweep lines.
Following are steps followed by the algorithm. All points from left to right are processed one by one. We
maintain a self-balancing binary search tree.
Left end point of line segment 1 is processed: 1 is inserted into the Tree. The tree contains 1. No intersection.
Left end point of line segment 2 is processed: Intersection of 1 and 2 is checked. 2 is inserted into the Tree.
No intersection. The tree contains 1, 2.
Left end point of line segment 3 is processed: Intersection of 3 with 1 is checked. No intersection. 3 is
inserted into the Tree. The tree contains 2, 1, 3.
Right end point of line segment 1 is processed: 1 is deleted from the Tree. Intersection of 2 and 3 is checked.
Intersection of 2 and 3 is reported. The tree contains 2, 3. Note that the above pseudocode returns at this
point. We can continue from here to report all intersection points.
Left end point of line segment 4 is processed: Intersections of line 4 with lines 2 and 3 are checked. No
intersection. 4 is inserted into the Tree. The tree contains 2, 4, 3.
Left end point of line segment 5 is processed: Intersection of 5 with 3 is checked. No intersection. 4 is
inserted into the Tree. The tree contains 2, 4, 3, 5.
Right end point of line segment 5 is processed: 5 is deleted from the Tree. The tree contains 2, 4, 3.
Right end point of line segment 4 is processed: 4 is deleted from the Tree. The tree contains 2, 4, 3.
Intersection of 2 with 3 is checked. Intersection of 2 with 3 is reported. The tree contains 2, 3. Note that
the intersection of 2 and 3 is reported again. We can add some logic to check for duplicates.
Right end point of line segment 2 and 3 are processed: Both are deleted from tree and tree becomes
empty.
Time Complexity: The first step is sorting which takes O(nLogn) time. The second step process 2n points
and for processing every point, it takes O(Logn) time. Therefore, overall time complexity is O(nLogn)
References:
http://www.cs.uiuc.edu/~jeffe/teaching/373/notes/x06-sweepline.pdf
http://www.youtube.com/watch?v=dePDHVovJlE
http://www.eecs.wsu.edu/~cook/aa/lectures/l25/node10.html
discussed above.
Graph Coloring | Set 1 (Introduction and Applications)
Graph coloring problem is to assign colors to certain elements of a graph subject to certain constraints.
Vertex coloring is the most common graph coloring problem. The problem is, given m colors, find a way
of coloring the vertices of a graph such that no two adjacent vertices are colored using same color. The other
graph coloring problems like Edge Coloring (No vertex is incident to two edges of same color) and Face
Coloring (Geographical Map Coloring) can be transformed into vertex coloring.
Chromatic Number: The smallest number of colors needed to color a graph G is called its chromatic
number. For example, the following can be colored minimum 3 colors.
The problem to find chromatic number of a given graph is NP Complete.
Applications of Graph Coloring:
The graph coloring problem has huge number of applications.
1) Making Schedule or Time Table: Suppose we want to make am exam schedule for a university. We
have list different subjects and students enrolled in every subject. Many subjects would have common
students (of same batch, some backlog students, etc). How do we schedule the exam so that no two exams
with a common student are scheduled at same time? How many minimum time slots are needed to
schedule all exams? This problem can be represented as a graph where every vertex is a subject and an edge
between two vertices mean there is a common student. So this is a graph coloring problem where minimum
number of time slots is equal to the chromatic number of the graph.
2) Mobile Radio Frequency Assignment : When frequencies are assigned to towers, frequencies
assigned to all towers at the same location must be different. How to assign frequencies with this constraint?
What is the minimum number of frequencies needed? This problem is also an instance of graph coloring
problem where every tower represents a vertex and an edge between two towers represents that they are in
range of each other.
3) Suduku: Suduku is also a variation of Graph coloring problem where every cell represents a vertex.
There is an edge between two vertices if they are in same row or same column or same block.
4) Register Allocation: In compiler optimization, register allocation is the process of assigning a large
number of target program variables onto a small number of CPU registers. This problem is also a graph
coloring problem.
5) Bipartite Graphs: We can check if a graph is Bipartite or not by colowing the graph using two colors. If
a given graph is 2-colorable, then it is Bipartite, otherwise not. See this for more details.
6) Map Coloring: Geographical maps of countries or states where no two adjacent cities cannot be
assigned same color. Four colors are sufficient to color any map (See Four Color Theorem)
There can be many more applications: For example the below reference video lecture has a case study
at 1:18.
Akamai runs a network of thousands of servers and the servers are used to distribute content on Internet.
They install a new software or update existing softwares pretty much every week. The update cannot be
deployed on every server at the same time, because the server may have to be taken down for the install.
Also, the update should not be done one at a time, because it will take a lot of time. There are sets of servers
that cannot be taken down together, because they have certain critical functions. This is a typical scheduling
application of graph coloring problem. It turned out that 8 colors were good enough to color the graph of
75000 nodes. So they could install updates in 8 passes.
We will soon be discussing different ways to solve the graph coloring problem.
References:
Lec 6 | MIT 6.042J Mathematics for Computer Science, Fall 2010 | Video Lecture
discussed above
Graph Coloring | Set 2 (Greedy Algorithm)
We introduced graph coloring and applications in previous post. As discussed in the previous post, graph
coloring is widely used. Unfortunately, there is no efficient algorithm available for coloring a graph with
minimum number of colors as the problem is a known NP Complete problem. There are approximate
algorithms to solve the problem though. Following is the basic Greedy Algorithm to assign colors. It doesn’t
guarantee to use minimum colors, but it guarantees an upper bound on the number of colors. The basic
algorithm never uses more than d+1 colors where d is the maximum degree of a vertex in the given graph.
Basic Greedy Coloring Algorithm:

1. Color first vertex with first color.
2. Do following for remaining V-1 vertices.
a) Consider the currently picked vertex and color it with the
lowest numbered color that has not been used on any previously
colored vertices adjacent to it. If all previously used colors
appear on vertices adjacent to v, assign a new color to it.

Following is C++ implementation of the above Greedy Algorithm.
// A C++ program to implement greedy algorithm for graph coloring

#include <iostream>
#include <list>

class Graph
{
public:
Graph(int V) { this->V = V; adj = new list<int>[V]; }

// Prints greedy coloring of the vertices

void greedyColoring();
};

{
}
// Assigns colors (starting from 0) to all vertices and prints

// the assignment of colors
void Graph::greedyColoring()
{
int result[V];
// Assign the first color to first vertex

result[0] = 0;
// Initialize remaining V-1 vertices as unassigned
for (int u = 1; u < V; u++)
result[u] = -1; // no color is assigned to u
// A temporary array to store the available colors. True

// value of available[cr] would mean that the color cr is
// assigned to one of its adjacent vertices
bool available[V];
for (int cr = 0; cr < V; cr++)
available[cr] = false;
// Assign colors to remaining V-1 vertices

for (int u = 1; u < V; u++)
{
// Process all adjacent vertices and flag their colors
// as unavailable
if (result[*i] != -1)
available[result[*i]] = true;
// Find the first available color

int cr;
for (cr = 0; cr < V; cr++)
if (available[cr] == false)
break;
result[u] = cr; // Assign the found color
// Reset the values back to false for the next iteration

if (result[*i] != -1)
available[result[*i]] = false;
}
// print the result

for (int u = 0; u < V; u++)
cout << "Vertex " << u << " ---> Color "
<< result[u] << endl;
}

int main()
{
Graph g1(5);
g1.addEdge(0, 1);
g1.addEdge(0, 2);
g1.addEdge(1, 2);
g1.addEdge(1, 3);
g1.addEdge(2, 3);
g1.addEdge(3, 4);
cout << "Coloring of Graph 1 \n";
g1.greedyColoring();
Graph g2(5);
g2.addEdge(0, 1);
g2.addEdge(0, 2);
g2.addEdge(1, 2);
g2.addEdge(1, 4);
g2.addEdge(2, 4);
g2.addEdge(4, 3);
cout << "\nColoring of Graph 2 \n";
g2.greedyColoring();
return 0;
}

Output:

Coloring of Graph 1
Vertex 0 ---> Color 0
Coloring of Graph 2

Time Complexity: O(V^2 + E) in worst case.
Analysis of Basic Algorithm

The above algorithm doesn’t always use minimum number of colors. Also, the number of colors used
sometime depend on the order in which vertices are processed. For example, consider the following two
graphs. Note that in graph on right side, vertices 3 and 4 are swapped. If we consider the vertices 0, 1, 2, 3, 4
in left graph, we can color the graph using 3 colors. But if we consider the vertices 0, 1, 2, 3, 4 in right graph,
we need 4 colors.

So the order in which the vertices are picked is important. Many people have suggested different ways to find
an ordering that work better than the basic algorithm on average. The most common is Welsh–Powell
Algorithm which considers vertices in descending order of degrees.
How does the basic algorithm guarantee an upper bound of d+1?

Here d is the maximum degree in the given graph. Since d is maximum degree, a vertex cannot be attached
to more than d vertices. When we color a vertex, at most d colors could have already been used by its
adjacent. To color this vertex, we need to pick the smallest numbered color that is not used by the adjacent
vertices. If colors are numbered like 1, 2, …., then the value of such smallest number must be between 1 to
d+1 (Note that d numbers are already picked by adjacent vertices).
This can also be proved using induction. See this video lecture for proof.
We will soon be discussing some interesting facts about chromatic number and graph coloring.
discussed above
Find the maximum distance covered using n bikes
There are n bikes and each can cover 100 km when fully fueled. What is the maximum amount of distance
you can go using n bikes? You may assume that all bikes are similar and a bike takes 1 litre to cover 1 km.
You have n bikes and using one bike you can only cover 100 km. so if n bikes start from same point and run
simultaneously you can go only 100 km. Let’s think bit differently, trick is when you want to cover
maximum distance, you should always try to waste minimum fuel. Minimum wastage of fuel means to run
minimum number of bikes. Instead of parallel running of n bikes, you can think of serially running them.
That means if you transfer some amount of fuel from last bike to another bikes and throw the last bike i.e.,
don’t run the last bike after certain point. But the question is, after what distance the fuel transfer has to be
done so that the maximum distance is covered and fuel tank of remaining bikes do not overflow. Let us take
following base cases and then generalize the solution.
Base Case 1: There is one bike This is simple, we can cover 100 kms only.
Base Case 2: There are two bikes: What is the maximum distance we can cover when there are 2 bikes?
To maximize the distance, we must drop second bike at some point and transfer its fuel to first bike. Let we
do the transfer after x kms.
Total distance covered = Distance covered by 100 ltr in first bike +
Distance covered by fuel transferred from first bike.

Remaining fuel in second bike is 100 – x. If we transfer this much fuel to first bike, then the total distance
would become 100 + 100 – x which is 200 – x. So our task is to maximize 200-x. The constraint is, 100 – x
must be less than or equal to the space created in first bike after x kms, i.e., 100 – x Base Case 3: There are
three bikes:
Let the first transfer is done after x kms. After x distance all bikes contain 100-x amount of fuel. If we take
100-x amount of fuel from 3rd bike and distribute it among 1st and 2nd bike so that fuel tanks of 1st and 2nd
bikes get full. So 100-x #include <stdio.h> // Returns maximum distance that can be traveled by n bikes and
given fuel // in every bike double maxDistance(int n, int fuel) { // dist_covered is the result of this function
double dist_covered = 0; while (n > 0) { // after ever fuel/n km we are discarding one bike and filling // all
the other bikes with fuel/n liters of fuel i.e. to their // maximum limit (100 litre) dist_covered +=
(double)fuel / n; n -= 1; // reduce number of bikes } return dist_covered; } // Driver program to test above
function int main() { int n = 3; // number of bikes int fuel = 100; printf("Maximum distance possible with
%d bikes is %f", n, maxDistance(n, fuel)); return 0; }
Output:

Maximum distance possible with 3 bikes is 183.333333

This article is contributed by Shamik Mitra. Please write comments if you find anything incorrect, or you
Closest Pair of Points | O(nlogn) Implementation
We are given an array of n points in the plane, and the problem is to find out the closest pair of points in the
array. This problem arises in a number of applications. For example, in air-traffic control, you may want to
monitor planes that come too close together, since this may indicate a possible collision. Recall the following
formula for distance between two points p and q.
We have discussed a divide and conquer solution for this problem. The time complexity of the
implementation provided in the previous post is O(n (Logn)^2). In this post, we discuss an implementation
with time complexity as O(nLogn).
Following is a recap of the algorithm discussed in the previous post.
1) We sort all points according to x coordinates.
2) Divide all points in two halves.
3) Recursively find the smallest distances in both subarrays.
4) Take the minimum of two smallest distances. Let the minimum be d.
5) Create an array strip[] that stores all points which are at most d distance away from the middle line
dividing the two sets.
6) Find the smallest distance in strip[].
7) Return the minimum of d and the smallest distance calculated in above step 6.
The great thing about the above approach is, if the array strip[] is sorted according to y coordinate, then we
can find the smallest distance in strip[] in O(n) time. In the implementation discussed in previous post,
strip[] was explicitly sorted in every recursive call that made the time complexity O(n (Logn)^2), assuming
that the sorting step takes O(nLogn) time.
In this post, we discuss an implementation where the time complexity is O(nLogn). The idea is to presort all
points according to y coordinates. Let the sorted array be Py[]. When we make recursive calls, we need to
divide points of Py[] also according to the vertical line. We can do that by simply processing every point and
comparing its x coordinate with x coordinate of middle line.
Following is C++ implementation of O(nLogn) approach.
// A divide and conquer program in C++ to find the smallest distance from a
// given set of points.
#include <iostream>
#include <float.h>
#include <stdlib.h>
#include <math.h>
// A structure to represent a Point in 2D plane

struct Point
{
int x, y;
};

// Needed to sort array of points according to X coordinate

int compareX(const void* a, const void* b)
{
return (p1->x - p2->x);
}
// Needed to sort array of points according to Y coordinate
int compareY(const void* a, const void* b)
{
return (p1->y - p2->y);
}
// A utility function to find the distance between two points

float dist(Point p1, Point p2)
{
return sqrt( (p1.x - p2.x)*(p1.x - p2.x) +
(p1.y - p2.y)*(p1.y - p2.y)
);
}
// A Brute Force method to return the smallest distance between two points
// in P[] of size n
float bruteForce(Point P[], int n)
{
float min = FLT_MAX;
for (int i = 0; i < n; ++i)
for (int j = i+1; j < n; ++j)
if (dist(P[i], P[j]) < min)
min = dist(P[i], P[j]);
return min;
}
// A utility function to find minimum of two float values

float min(float x, float y)
{
}
// A utility function to find the distance beween the closest points of

// strip of given size. All points in strip[] are sorted accordint to
// y coordinate. They all have an upper bound on minimum distance as d.
// Note that this method seems to be a O(n^2) method, but it's a O(n)
// method as the inner loop runs at most 6 times
float stripClosest(Point strip[], int size, float d)
{
float min = d; // Initialize the minimum distance as d
// Pick all points one by one and try the next points till the difference
// between y coordinates is smaller than d.
// This is a proven fact that this loop runs at most 6 times
for (int j = i+1; j < size && (strip[j].y - strip[i].y) < min; ++j)
if (dist(strip[i],strip[j]) < min)
min = dist(strip[i], strip[j]);
return min;
}
// A recursive function to find the smallest distance. The array Px contains

// all points sorted according to x coordinates and Py contains all points
// sorted according to y coordinates
float closestUtil(Point Px[], Point Py[], int n)
{
// If there are 2 or 3 points, then use brute force
if (n <= 3)
return bruteForce(Px, n);

int mid = n/2;
Point midPoint = Px[mid];
// Divide points in y sorted array around the vertical line.

// Assumption: All x coordinates are distinct.
Point Pyl[mid+1]; // y sorted points on left of vertical line
Point Pyr[n-mid-1]; // y sorted points on right of vertical line
int li = 0, ri = 0; // indexes of left and right subarrays
for (int i = 0; i < n; i++)
{
if (Py[i].x <= midPoint.x)
Pyl[li++] = Py[i];
else
Pyr[ri++] = Py[i];
}
// Consider the vertical line passing through the middle point

// calculate the smallest distance dl on left of middle point and
// dr on right side
float dl = closestUtil(Px, Pyl, mid);
float dr = closestUtil(Px + mid, Pyr, n-mid);
// Find the smaller of two distances

float d = min(dl, dr);
// Build an array strip[] that contains points close (closer than d)

// to the line passing through the middle point
Point strip[n];
int j = 0;
for (int i = 0; i < n; i++)
if (abs(Py[i].x - midPoint.x) < d)
strip[j] = Py[i], j++;
// Find the closest points in strip. Return the minimum of d and closest
// distance is strip[]
return min(d, stripClosest(strip, j, d) );
}

// This method mainly uses closestUtil()
float closest(Point P[], int n)
{
Point Px[n];
Point Py[n];
for (int i = 0; i < n; i++)
{
Px[i] = P[i];
Py[i] = P[i];
}
qsort(Px, n, sizeof(Point), compareX);

qsort(Py, n, sizeof(Point), compareY);
// Use recursive function closestUtil() to find the smallest distance

return closestUtil(Px, Py, n);
return closestUtil(Px, Py, n);
}

int main()
{
Point P[] = {{2, 3}, {12, 30}, {40, 50}, {5, 1}, {12, 10}, {3, 4}};
int n = sizeof(P) / sizeof(P[0]);
cout << "The smallest distance is " << closest(P, n);
return 0;
}
Output:

The smallest distance is 1.41421

Time Complexity:Let Time complexity of above algorithm be T(n). Let us assume that we use a O(nLogn)
sorting algorithm. The above algorithm divides all points in two sets and recursively calls for two sets. After
dividing, it finds the strip in O(n) time. Also, it takes O(n) time to divide the Py array around the mid vertical
line. Finally finds the closest points in strip in O(n) time. So T(n) can expressed as follows
T(n) = 2T(n/2) + O(n) + O(n) + O(n)
T(n) = 2T(n/2) + O(n)
T(n) = T(nLogn)
References:
http://www.cs.umd.edu/class/fall2013/cmsc451/Lects/lect10.pdf
http://www.youtube.com/watch?v=vS4Zn1a9KUc
http://www.youtube.com/watch?v=T3T7T8Ym20M
http://en.wikipedia.org/wiki/Closest_pair_of_points_problem
discussed above
Deepest left leaf node in a binary tree
Given a Binary Tree, find the deepest leaf node that is left child of its parent. For example, consider the
following tree. The deepest left leaf node is the node with value 9.
1
/ \
2 3
/ / \
4 5 6
\ \
7 8
/ \
9 10

The idea is to recursively traverse the given binary tree and while traversing, maintain “level” which will
store the current node’s level in the tree. If current node is left leaf, then check if its level is more than the
level of deepest left leaf seen so far. If level is more then update the result. If current node is not leaf, then
recursively find maximum depth in left and right subtrees, and return maximum of the two depths. Thanks
to Coder011 for suggesting this approach.
// A C++ program to find the deepest left leaf in a given binary tree
#include <stdio.h>
#include <iostream>
struct Node
{
int val;
};
Node *newNode(int data)

{
Node *temp = new Node;
temp->val = data;
return temp;
}
// A utility function to find deepest leaf node.

// lvl: level of current node.
// maxlvl: pointer to the deepest left leaf node found so far
// isLeft: A bool indicate that this node is left child of its parent
// resPtr: Pointer to the result
void deepestLeftLeafUtil(Node *root, int lvl, int *maxlvl,
bool isLeft, Node **resPtr)
{
// Base case
if (root == NULL)
return;
// Update result if this node is left leaf and its level is more
// than the maxl level of the current result
// than the maxl level of the current result
if (isLeft && !root->left && !root->right && lvl > *maxlvl)
{
*resPtr = root;
*maxlvl = lvl;
return;
}

deepestLeftLeafUtil(root->left, lvl+1, maxlvl, true, resPtr);
deepestLeftLeafUtil(root->right, lvl+1, maxlvl, false, resPtr);
}
// A wrapper over deepestLeftLeafUtil().

Node* deepestLeftLeaf(Node *root)
{
int maxlevel = 0;
Node *result = NULL;
deepestLeftLeafUtil(root, 0, &maxlevel, false, &result);
return result;
}

int main()
{
Node* root = newNode(1);
Node *result = deepestLeftLeaf(root);

if (result)
cout << "The deepest left child is " << result->val;
else
cout << "There is no left leaf in the given tree";
return 0;
}

Output:

The deepest left child is 9

Russian Peasant Multiplication
Given two integers, write a function to multiply them without using multiplication operator.
There are many other ways to multiply two numbers (For example, see this). One interesting method is the
Russian peasant algorithm. The idea is to double the first number and halve the second number repeatedly
till the second number doesn’t become 1. In the process, whenever the second number become odd, we add
the first number to result (result is initialized as 0)
The following is simple algorithm.
Let the two given numbers be 'a' and 'b'

1) Initialize result 'res' as 0.
2) Do following while 'b' is greater than 0
a) If 'b' is odd, add 'a' to 'res'
b) Double 'a' and halve 'b'
3) Return 'res'.

#include <iostream>
// A method to multiply two numbers using Russian Peasant method

unsigned int russianPeasant(unsigned int a, unsigned int b)
{
int res = 0; // initialize result
// While second number doesn't become 1

while (b > 0)
{
// If second number becomes odd, add the first number to result
if (b & 1)
res = res + a;
// Double the first number and halve the second number

a = a << 1;
b = b >> 1;
}
return res;
}

int main()
{
cout << russianPeasant(18, 1) << endl;
cout << russianPeasant(20, 12) << endl;
return 0;
}

Output:

18
240

How does this work?

The value of a*b is same as (a*2)*(b/2) if b is even, otherwise the value is same as ((a*2)*(b/2) + a). In the
while loop, we keep multiplying ‘a’ with 2 and keep dividing ‘b’ by 2. If ‘b’ becomes odd in loop, we add ‘a’ to
‘res’. When value of ‘b’ becomes 1, the value of ‘res’ + ‘a’, gives us the result.
Note that when ‘b’ is a power of 2, the ‘res’ would remain 0 and ‘a’ would have the multiplication. See the
reference for more information.
Reference:
http://mathforum.org/dr.math/faq/faq.peasant.html
This article is compiled by Shalki Agarwal. Please write comments if you find anything incorrect, or you
Some interesting shortest path questions | Set 1
Question 1: Given a directed weighted graph. You are also given the shortest path from a
source vertex ‘s’ to a destination vertex ‘t’. If weight of every edge is increased by 10 units,
does the shortest path remain same in the modified graph?
The shortest path may change. The reason is, there may be different number of edges in different paths from
s to t. For example, let shortest path be of weight 15 and has 5 edges. Let there be another path with 2 edges
and total weight 25. The weight of the shortest path is increased by 5*10 and becomes 15 + 50. Weight of the
other path is increased by 2*10 and becomes 25 + 20. So the shortest path changes to the other path with
weight as 45.
Question 2: This is similar to above question. Does the shortest path change when weights
of all edges are multiplied by 10?
If we multiply all edge weights by 10, the shortest path doesn’t change. The reason is simple, weights of all
paths from s to t get multiplied by same amount. The number of edges on a path doesn’t matter. It is like
changing unit of weights.
Question 3: Given a directed graph where every edge has weight as either 1 or 2, find the
shortest path from a given source vertex ‘s’ to a given destination vertex ‘t’. Expected time
complexity is O(V+E).
If we apply Dijkstra’s shortest path algorithm, we can get a shortest path in O(E + VLogV) time. How to do it
in O(V+E) time? The idea is to use BFS . One important observation about BFS is, the path used in BFS
always has least number of edges between any two vertices. So if all edges are of same weight, we can use
BFS to find the shortest path. For this problem, we can modify the graph and split all edges of weight 2 into
two edges of weight 1 each. In the modified graph, we can use BFS to find the shortest path. How is this
approach O(V+E)? In worst case, all edges are of weight 2 and we need to do O(E) operations to split all
edges, so the time complexity becomes O(E) + O(V+E) which is O(V+E).
Question 4: Given a directed acyclic weighted graph, how to find the shortest path from a
source s to a destination t in O(V+E) time?
See: Shortest Path in Directed Acyclic Graph
More Questions See following links for more questions.

http://algs4.cs.princeton.edu/44sp/
http://geeksquiz.com/graph-shortest-paths/
discussed above.
Find next right node of a given key
Given a Binary tree and a key in the binary tree, find the node right to the given key. If there is no node on
right side, then return NULL. Expected time complexity is O(n) where n is the number of nodes in the given
binary tree.
For example, consider the following Binary Tree. Output for 2 is 6, output for 4 is 5. Output for 10, 6 and 5 is
NULL.
10
/ \
2 6
/ \ \
8 4 5

Solution: The idea is to do level order traversal of given Binary Tree. When we find the given key, we just
check if the next node in level order traversal is of same level, if yes, we return the next node, otherwise
return NULL.
/* Program to find next right of a given key */

#include <iostream>
#include <queue>

struct node
{
int key;
};
// Method to find next right of given key k, it returns NULL if k is

// not present in tree or k is the rightmost node of its level
node* nextRight(node *root, int k)
{
// Base Case
if (root == NULL)
return 0;
// Create an empty queue for level order tarversal

queue<node *> qn; // A queue to store node addresses
queue<int> ql; // Another queue to store node levels
int level = 0; // Initialize level as 0
// Enqueue Root and its level

qn.push(root);
ql.push(level);
// A standard BFS loop

while (qn.size())
{
// dequeue an node from qn and its level from ql
node *node = qn.front();
node *node = qn.front();
level = ql.front();
qn.pop();
ql.pop();
// If the dequeued node has the given key k

if (node->key == k)
{
// If there are no more items in queue or given node is
// the rightmost node of its level, then return NULL
if (ql.size() == 0 || ql.front() != level)
return NULL;
// Otherwise return next node from queue of nodes

return qn.front();
}
// Standard BFS steps: enqueue children of this node

{
qn.push(node->left);
ql.push(level+1);
}
{
qn.push(node->right);
ql.push(level+1);
}
}
// We reach here if given key x doesn't exist in tree

return NULL;
}

node* newNode(int key)
{
temp->key = key;
return temp;
}
// A utility function to test above functions

void test(node *root, int k)
{
node *nr = nextRight(root, k);
if (nr != NULL)
cout << "Next Right of " << k << " is " << nr->key << endl;
else
cout << "No next right node found for " << k << endl;
}

int main()
{
// Let us create binary tree given in the above example
test(root, 10);
test(root, 10);
test(root, 2);
test(root, 6);
test(root, 5);
test(root, 8);
test(root, 4);
return 0;
}

Output:

No next right node found for 10
Next Right of 2 is 6

Time Complexity: The above code is a simple BFS traversal code which visits every enqueue and dequeues
a node at most once. Therefore, the time complexity is O(n) where n is the number of nodes in the given
binary tree.
Exercise: Write a function to find left node of a given node. If there is no node on the left side, then return
NULL.
discussed above
Generate all unique partitions of an integer
Given a positive integer n, generate all possible unique ways to represent n as sum of positive integers.
Input: n = 2
Output:
2
1 1
Input: n = 3
Output:
3
2 1
1 1 1
Note: 2+1 and 1+2 are considered as duplicates.
Input: n = 4
Output:
4
3 1
2 2
2 1 1
1 1 1 1

Solution: We print all partition in sorted order and numbers within a partition are also printed in sorted
order (as shown in the above examples). The idea is to get next partition using the values in current
partition. We store every partition in an array p[]. We initialize p[] as n where n is the input number. In
every iteration. we first print p[] and then update p[] to store the next partition. So the main problem is to
get next partition from a given partition.
Steps to get next partition from current partition

We are given current partition in p[] and its size. We need to update p[] to store next partition. Values in p[]
must be sorted in non-increasing order.
1) Find the rightmost non-one value in p[] and store the count of 1’s encountered before a non-one value in a
variable rem_val (It indicates sum of values on right side to be updated). Let the index of non-one value be k.
2) Decrease the value of p[k] by 1 and increase rem_val by 1. Now there may be two cases:
a) If p[k] is more than or equal to rem_val. This is a simple case (we have the sorted order in new
partition). Put rem_val at p[k+1] and p[0…k+1] is our new partition.
b) Else (This is a interesting case, take initial p[] as {3, 1, 1, 1}, p[k] is decreased from 3 to 2, rem_val is
increased from 3 to 4, the next partition should be {2, 2, 2}).
Copy p[k] to next position, increment k and reduce count by p[k] while p[k] is less than rem_val. Finally,
put rem_val at p[k+1] and p[0…k+1] is our new partition. This step is like dividing rem_val in terms of p[k]
(4 is divided in 2’s).
#include<iostream>
// A utility function to print an array p[] of size 'n'

// A utility function to print an array p[] of size 'n'
void printArray(int p[], int n)
{
for (int i = 0; i < n; i++)
cout << p[i] << " ";
cout << endl;
}
void printAllUniqueParts(int n)
{
int p[n]; // An array to store a partition
int k = 0; // Index of last element in a partition
p[k] = n; // Initialize first partition as number itself
// This loop first prints current partition, then generates next

// partition. The loop stops when the current partition has all 1s
while (true)
{
// print current partition
printArray(p, k+1);
// Generate next partition
// Find the rightmost non-one value in p[]. Also, update the

// rem_val so that we know how much value can be accommodated
int rem_val = 0;
while (k >= 0 && p[k] == 1)
{
rem_val += p[k];
k--;
}
// if k < 0, all the values are 1 so there are no more partitions

if (k < 0) return;
// Decrease the p[k] found above and adjust the rem_val

p[k]--;
rem_val++;
// If rem_val is more, then the sorted order is violeted. Divide

// rem_val in differnt values of size p[k] and copy these values at
// different positions after p[k]
while (rem_val > p[k])
{
p[k+1] = p[k];
rem_val = rem_val - p[k];
k++;
}
// Copy rem_val to next position and increment position

p[k+1] = rem_val;
k++;
}
}

int main()
{
cout << "All Unique Partitions of 2 \n";
printAllUniqueParts(2);
cout << "\nAll Unique Partitions of 3 \n";

cout << "\nAll Unique Partitions of 4 \n";
return 0;
}

Output:

All Unique Partitions of 2
2
1 1

3
2 1
1 1 1

4
3 1
2 2
2 1 1
1 1 1 1

This article is contributed by Hariprasad NG. Please write comments if you find anything incorrect, or you
Print all possible paths from top left to bottom right of a mXn matrix
The problem is to print all the possible paths from top left to bottom right of a mXn matrix with the
constraints that from each cell you can either move only to right or down .
The algorithm is a simple recursive algorithm, from each cell first print all paths by going down and then
print all paths by going right. Do this recursively for each cell encountered.
#include<iostream>
/* mat: Pointer to the starting of mXn matrix

i, j: Current position of the robot (For the first call use 0,0)
m, n: Dimentions of given the matrix
pi: Next index to be filed in path array
*path[0..pi-1]: The path traversed by robot till now (Array to hold the
path need to have space for at least m+n elements) */
void printAllPathsUtil(int *mat, int i, int j, int m, int n, int *path, int pi)
{
// Reached the bottom of the matrix so we are left with
// only option to move right
if (i == m - 1)
{
for (int k = j; k < n; k++)
path[pi + k - j] = *((mat + i*n) + k);
for (int l = 0; l < pi + n - j; l++)
cout << path[l] << " ";
cout << endl;
return;
}
// Reached the right corner of the matrix we are left with

// only the downward movement.
if (j == n - 1)
{
for (int k = i; k < m; k++)
path[pi + k - i] = *((mat + k*n) + j);
for (int l = 0; l < pi + m - i; l++)
cout << path[l] << " ";
cout << endl;
return;
}
// Add the current cell to the path being generated

path[pi] = *((mat + i*n) + j);
// Print all the paths that are possible after moving down
printAllPathsUtil(mat, i+1, j, m, n, path, pi + 1);
// Print all the paths that are possible after moving right
printAllPathsUtil(mat, i, j+1, m, n, path, pi + 1);
// Print all the paths that are possible after moving diagonal
// printAllPathsUtil(mat, i+1, j+1, m, n, path, pi + 1);
}
// The main function that prints all paths from top left to bottom right
// in a matrix 'mat' of size mXn
void printAllPaths(int *mat, int m, int n)
void printAllPaths(int *mat, int m, int n)
{
int *path = new int[m+n];
printAllPathsUtil(mat, 0, 0, m, n, path, 0);
}
// Driver program to test abve functions

int main()
{
int mat[2][3] = { {1, 2, 3}, {4, 5, 6} };
printAllPaths(*mat, 2, 3);
return 0;
}

Output:

1 4 5 6
1 2 5 6
1 2 3 6

Note that in the above code, the last line of printAllPathsUtil() is commented, If we uncomment this line, we
get all the paths from the top left to bottom right of a nXm matrix if the diagonal movements are also
allowed. And also if moving to some of the cells are not permitted then the same code can be improved by
passing the restriction array to the above function and that is left as an exercise.
Count all distinct pairs with difference equal to k
Given an integer array and a positive integer k, count all distinct pairs with difference equal to k.
Examples:
Input: arr[] = {1, 5, 3, 4, 2}, k = 3

Output: 2
There are 2 pairs with difference 3, the pairs are {1, 4} and {5, 2}
Input: arr[] = {8, 12, 16, 4, 0, 20}, k = 4

Output: 5
There are 5 pairs with difference 4, the pairs are {0, 4}, {4, 8},
{8, 12}, {12, 16} and {16, 20}

Method 1 (Simple)
A simple solution is to consider all pairs one by one and check difference between every pair. Following
program implements the simple solution. We run two loops: the outer loop picks the first element of pair,
the inner loop looks for the other element. This solution doesn’t work if there are duplicates in array as the
requirement is to count only distinct pairs.
/* A simple program to count pairs with difference k*/

#include<iostream>
int countPairsWithDiffK(int arr[], int n, int k)

{
int count = 0;

// Pick all elements one by one
for (int i = 0; i < n; i++)
{
// See if there is a pair of this picked element
for (int j = i+1; j < n; j++)
if (arr[i] - arr[j] == k || arr[j] - arr[i] == k )
count++;
}
return count;
}

int main()
{
int arr[] = {1, 5, 3, 4, 2};
int k = 3;
cout << "Count of pairs with given diff is "
<< countPairsWithDiffK(arr, n, k);
return 0;
}

Output:

Count of pairs with given diff is 2

Time Complexity of O(n2)

We can find the count in O(nLogn) time using a O(nLogn) sorting algorithm like Merge Sort, Heap Sort, etc.
1) Initialize count as 0
2) Sort all numbers in increasing order.
3) Remove duplicates from array.
4) Do following for each element arr[i]
a) Binary Search for arr[i] + k in subarray from i+1 to n-1.
b) If arr[i] + k found, increment count.
5) Return count.

/* A sorting based program to count pairs with difference k*/

#include <iostream>
/* Standard binary search function */

int binarySearch(int arr[], int low, int high, int x)
{
if (high >= low)
{
if (x == arr[mid])
return mid;
if (x > arr[mid])
return binarySearch(arr, (mid + 1), high, x);
else
return binarySearch(arr, low, (mid -1), x);
}
return -1;
}
/* Returns count of pairs with difference k in arr[] of size n. */

{
int count = 0, i;
sort(arr, arr+n); // Sort array elements
/* code to remove duplicates from arr[] */

// Pick a first element point
for (i = 0; i < n-1; i++)
if (binarySearch(arr, i+1, n-1, arr[i] + k) != -1)
count++;
return count;
}

Output:


Time complexity: The first step (sorting) takes O(nLogn) time. The second step runs binary search n times,
so the time complexity of second step is also O(nLogn). Therefore, overall time complexity is O(nLogn). The
second step can be optimized to O(n), see this.
Method 3 (Use Self-balancing BST)

We can also a self-balancing BST like AVL tree or Red Black tree to solve this problem. Following is detailed
algorithm.

1) Initialize count as 0.
2) Insert all elements of arr[] in an AVL tree. While inserting,
ignore an element if already present in AVL tree.
3) Do following for each element arr[i].
a) Search for arr[i] + k in AVL tree, if found then increment count.
b) Search for arr[i] - k in AVL tree, if found then increment count.
c) Remove arr[i] from AVL tree.

Time complexity of above solution is also O(nLogn) as search and delete operations take O(Logn) time for a
self-balancing binary search tree.

We can also use hashing to achieve the average time complexity as O(n) for many cases.

1) Initialize count as 0.
2) Insert all distinct elements of arr[] in a hash map. While inserting,
ignore an element if already present in the hash map.
3) Do following for each element arr[i].
a) Look for arr[i] + k in the hash map, if found then increment count.
b) Look for arr[i] - k in the hash map, if found then increment count.
c) Remove arr[i] from hash table.

A very simple case where hashing works in O(n) time is the case where range of values is very small. For
example, in the following implementation, range of numbers is assumed to be 0 to 99999. A simple hashing
technique to use values as index can be used.
/* An efficient program to count pairs with difference k when the range

numbers is small */
#define MAX 100000
{
int count = 0; // Initialize count
// Initialize empty hashmap.

bool hashmap[MAX] = {false};
// Insert array elements to hashmap

for (int i = 0; i < n; i++)
hashmap[arr[i]] = true;
for (int i = 0; i < n; i++)

{
int x = arr[i];
if (x - k >= 0 && hashmap[x - k])
count++;
if (x + k < MAX && hashmap[x + k])
count++;
hashmap[x] = false;
}
return count;
}

Sort the array arr

Take two pointers, l and r, both pointing to 1st element
Take the difference arr[r] – arr[l]
If value diff is K, increment count and move both pointers to next element
if value diff > k, move l to next element
if value diff < k, move r to next element
return count
/* A sorting based program to count pairs with difference k*/

#include <iostream>

/* Returns count of pairs with difference k in arr[] of size n. */
{
int count = 0;
sort(arr, arr+n); // Sort array elements
int l = 0;
int r = 0;
while(r < n)
{
if(arr[r] - arr[l] == k)
{
count++;
l++;
r++;
}
else if(arr[r] - arr[l] > k)
l++;
else // arr[r] - arr[l] < sum
r++;
}
return count;
}

int main()
{
int arr[] = {1, 5, 3, 4, 2};
int k = 3;
cout << "Count of pairs with given diff is "
<< countPairsWithDiffK(arr, n, k);
return 0;
}

Output:


Time Complexity: O(nlogn)
discussed above
Count all possible paths from top left to bottom right of a mXn matrix
The problem is to count all the possible paths from top left to bottom right of a mXn matrix with the
constraints that from each cell you can either move only to right or down
We have discussed a solution to print all possible paths, counting all paths is easier. Let NumberOfPaths(m,
n) be the count of paths to reach row number m and column number n in the matrix, NumberOfPaths(m, n)
can be recursively written as following.
#include <iostream>
// Returns count of possible paths to reach cell at row number m and column
// number n from the topmost leftmost cell (cell at 1, 1)
int numberOfPaths(int m, int n)
{
// If either given row number is first or given column number is first
if (m == 1 || n == 1)
return 1;
// If diagonal movements are allowed then the last addition

// is required.
return numberOfPaths(m-1, n) + numberOfPaths(m, n-1);
// + numberOfPaths(m-1,n-1);
}
int main()
{
cout << numberOfPaths(3, 3);
return 0;
}

Output:
The time complexity of above recursive solution is exponential. There are many overlapping subproblems.
We can draw a recursion tree for numberOfPaths(3, 3) and see many overlapping subproblems. The
recursion tree would be similar to Recursion tree for Longest Common Subsequence problem.
So this problem has both properties (see this and this) of a dynamic programming problem. Like other
constructing a temporary array count[][] in bottom up manner using the above recursive formula.

#include <iostream>
// Returns count of possible paths to reach cell at row number m and column
// number n from the topmost leftmost cell (cell at 1, 1)
int numberOfPaths(int m, int n)
{
// Create a 2D table to store results of subproblems
int count[m][n];
// Count of paths to reach any cell in first column is 1

for (int i = 0; i < m; i++)
count[i][0] = 1;
// Count of paths to reach any cell in first column is 1

for (int j = 0; j < n; j++)
count[0][j] = 1;
// Calculate count of paths for other cells in bottom-up manner using

// the recursive solution
for (int i = 1; i < m; i++)
{
for (int j = 1; j < n; j++)
// By uncommenting the last part the code calculatest he total

// possible paths if the diagonal Movements are allowed
count[i][j] = count[i-1][j] + count[i][j-1]; //+ count[i-1][j-1];
}
return count[m-1][n-1];
}

int main()
{
cout << numberOfPaths(3, 3);
return 0;
}

Output:
Time complexity of the above dynamic programming solution is O(mn).
Note the count can also be calculated using the formula (m-1 + n-1)!/(m-1)!(n-1)! as mentioned in the
comments of this article.
Pairwise swap elements of a given linked list by changing links
Given a singly linked list, write a function to swap elements pairwise. For example, if the linked list is 1->2-
>3->4->5->6->7 then the function should change it to 2->1->4->3->6->5->7, and if the linked list is 1->2-
>3->4->5->6 then the function should change it to 2->1->4->3->6->5
This problem has been discussed here. The solution provided there swaps data of nodes. If data contains
many fields, there will be many swap operations. So changing links is a better idea in general. Following is a
C implementation that changes links instead of swapping data.
/* This program swaps the nodes of linked list rather than swapping the
field from the nodes.
Imagine a case where a node contains many fields, there will be plenty
of unnecessary swap calls. */
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>

struct node
{
int data;
struct node *next;
};
/* Function to pairwise swap elements of a linked list */

void pairWiseSwap(struct node **head)
{
// If linked list is empty or there is only one node in list
if (*head == NULL || (*head)->next == NULL)
return;
// Initialize previous and current pointers

struct node *prev = *head;
struct node *curr = (*head)->next;
*head = curr; // Change head before proceeeding
// Traverse the list

while (true)
{
struct node *next = curr->next;
curr->next = prev; // Change next of current as previous node
// If next NULL or next is the last node

if (next == NULL || next->next == NULL)
{
prev->next = next;
break;
}
// Change next of previous to next next

prev->next = next->next;
// Update previous and curr

prev = next;
curr = prev->next;
}
}
{
/* allocate node */



}

{
while(node != NULL)
{
node = node->next;
}
}

int main()
{

1->2->3->4->5->6->7 */
push(&start, 7);
push(&start, 6);
push(&start, 5);
push(&start, 4);
push(&start, 3);
push(&start, 2);
push(&start, 1);

printList(start);
pairWiseSwap(&start);

printList(start);
getchar();
return 0;
}

Output:

Linked list before calling pairWiseSwap() 1 2 3 4 5 6 7

Linked list after calling pairWiseSwap() 2 1 4 3 6 5 7

Time Complexity: Time complexity of the above program is O(n) where n is the number of nodes in a given
linked list. The while loop does a traversal of the given linked list.
Following is recursive implementation of the same approach. We change first two nodes and recur for
the remaining list. Thanks to geek and omer salem for suggesting this method.
/* This program swaps the nodes of linked list rather than swapping the
field from the nodes.
Imagine a case where a node contains many fields, there will be plenty
of unnecessary swap calls. */
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>

struct node
{
int data;
struct node *next;
};
/* Function to pairwise swap elements of a linked list.

It returns head of the modified list, so return value
of this node must be assigned */
struct node *pairWiseSwap(struct node* head)
{
// Base Case: The list is empty or has only one node
if (head == NULL || head->next == NULL)
return head;
// Store head of list after two nodes

struct node* remaing = head->next->next;
// Change head
struct node* newhead = head->next;
// Change next of second node

head->next->next = head;
// Recur for remaining list and change next of head

head->next = pairWiseSwap(remaing);
// Return new head of modified list

return newhead;
}

{
/* allocate node */


}

{
while(node != NULL)
{
node = node->next;
}
}

int main()
{

1->2->3->4->5->6->7 */
push(&start, 7);
push(&start, 6);
push(&start, 5);
push(&start, 4);
push(&start, 3);
push(&start, 2);
push(&start, 1);

printList(start);
start = pairWiseSwap(start); // NOTE THIS CHANGE

printList(start);
return 0;
}

Linked list before calling pairWiseSwap() 1 2 3 4 5 6 7

Linked list after calling pairWiseSwap() 2 1 4 3 6 5 7

This article is contributed by Gautam Kumar. Please write comments if you find anything incorrect, or
Splay Tree | Set 1 (Search)
The worst case time complexity of Binary Search Tree (BST) operations like search, delete, insert is O(n).
The worst case occurs when the tree is skewed. We can get the worst case time complexity as O(Logn) with
AVL and Red-Black Trees.
Can we do better than AVL or Red-Black trees in practical situations?

Like AVL and Red-Black Trees, Splay tree is also self-balancing BST. The main idea of splay tree is to bring
the recently accessed item to root of the tree, this makes the recently searched item to be accessible in O(1)
time if accessed again. The idea is to use locality of reference (In a typical application, 80% of the access are
to 20% of the items). Imagine a situation where we have millions or billions of keys and only few of them are
accessed frequently, which is very likely in many practical applications.
All splay tree operations run in O(log n) time on average, where n is the number of entries in the tree. Any
single operation can take Theta(n) time in the worst case.
Search Operation
The search operation in Splay tree does the standard BST search, in addition to search, it also splays (move a
node to the root). If the search is successful, then the node that is found is splayed and becomes the new
root. Else the last node accessed prior to reaching the NULL is splayed and becomes the new root.
There are following cases for the node being accessed.
1) Node is root We simply return the root, don’t do anything else as the accessed node is already root.
2) Zig: Node is child of root (the node has no grandparent). Node is either a left child of root (we do a
right rotation) or node is a right child of its parent (we do a left rotation).
T1, T2 and T3 are subtrees of the tree rooted with y (on left side) or x (on right side)
y x
/ \ Zig (Right Rotation) / \
x T3 – - – - – - – - - -> T1 y
/ \
3) Node has both parent and grandparent. There can be following subcases.
........3.a) Zig-Zig and Zag-Zag Node is left child of parent and parent is also left ch
ild of grand parent (Two right rotations) OR node is right child of its parent and parent
is also right child of grand parent (Two Left Rotations).

Zig-Zig (Left Left Case):
G P X
/ \ / \ / \
P T4 rightRotate(G) X G rightRotate(P) T1 P
/ \ ============> / \ / \ ============> / \
X T3 T1 T2 T3 T4 T2 G
/ \ / \
T1 T2 T3 T4
Zag-Zag (Right Right Case):

G P X
/ \ / \ / \
T1 P leftRotate(G) G X leftRotate(P) P T4
/ \ ============> / \ / \ ============> / \
T2 X T1 T2 T3 T4 G T3
/ \ / \
T3 T4 T1 T2

........3.b) Zig-Zag and Zag-Zig Node is left child of parent and parent is right child
of grand parent (Left Rotation followed by right rotation) OR node is right child of its
parent and parent is left child of grand parent (Right Rotation followed by left
rotation).

Zig-Zag (Left Right Case):
G G X
/ \ / \ / \
P T4 leftRotate(P) X T4 rightRotate(G) P G
/ \ ============> / \ ============> / \ / \
T1 X P T3 T1 T2 T3 T4
/ \ / \
T2 T3 T1 T2
Zag-Zig (Right Left Case):

G G X
/ \ / \ / \
T1 P rightRotate(P) T1 X leftRotate(P) G P
/ \ =============> / \ ============> / \ / \
X T4 T2 P T1 T2 T3 T4
/ \ / \
T2 T3 T3 T4
Example:

100 100 [20]
/ \ / \ \
50 200 50 200 50
/ search(20) / search(20) / \
40 ======> [20] ========> 30 100
/ 1. Zig-Zig \ 2. Zig-Zig \ \
30 at 40 30 at 100 40 200
/ \
[20] 40
The important thing to note is, the search or splay operation not only brings the search
ed key to root, but also balances the BST. For example in above case, height of BST is r
educed by 1.
Implementation:

// The code is adopted from http://goo.gl/SDH9hH
#include<stdio.h>
#include<stdlib.h>
// An AVL tree node

struct node
{
int key;
};
{
node->key = key;
return (node);
}

struct node *rightRotate(struct node *x)
{
struct node *y = x->left;
x->left = y->right;
y->right = x;
return y;
}

{
x->right = y->left;
y->left = x;
return y;
}
// This function brings the key at root if key is present in tree.

// If key is not present, then it brings the last accessed item at
// root. This function modifies the tree and returns the new root
struct node *splay(struct node *root, int key)
{
// Base cases: root is NULL or key is present at root
if (root == NULL || root->key == key)
return root;
// Key lies in left subtree

{
// Key is not in tree, we are done
if (root->left == NULL) return root;
// Zig-Zig (Left Left)

if (root->left->key > key)
{
// First recursively bring the key as root of left-left
root->left->left = splay(root->left->left, key);
// Do first rotation for root, second rotation is done after else

root = rightRotate(root);
}
else if (root->left->key < key) // Zig-Zag (Left Right)
{
// First recursively bring the key as root of left-right
root->left->right = splay(root->left->right, key);
// Do first rotation for root->left

if (root->left->right != NULL)
}
// Do second rotation for root
return (root->left == NULL)? root: rightRotate(root);
}
else // Key lies in right subtree
{
if (root->right == NULL) return root;
// Zag-Zig (Right Left)

if (root->right->key > key)
{
// Bring the key as root of right-left
root->right->left = splay(root->right->left, key);
// Do first rotation for root->right

if (root->right->left != NULL)
}
else if (root->right->key < key)// Zag-Zag (Right Right)
{
// Bring the key as root of right-right and do first rotation
root->right->right = splay(root->right->right, key);
root = leftRotate(root);
}

return (root->right == NULL)? root: leftRotate(root);
}
}
// The search function for Splay tree. Note that this function
// returns the new root of Splay Tree. If key is present in tree
// then, it is moved to root.
struct node *search(struct node *root, int key)
{
return splay(root, key);
}

{
if (root != NULL)
{
}
}

int main()
{
root->left->left->left->left = newNode(20);
root = search(root, 20);

printf("Preorder traversal of the modified Splay tree is \n");
preOrder(root);
return 0;
return 0;
}

Output:
Preorder traversal of the modified Splay tree is

20 50 30 40 100 200
Summary
1) Splay trees have excellent locality properties. Frequently accessed items are easy
to find. Infrequent items are out of way.
2) All splay tree operations take O(Logn) time on average. Splay trees can be
rigorously shown to run in O(log n) average time per operation, over any sequence of ope
rations (assuming we start from an empty tree)
3) Splay trees are simpler compared to AVL and Red-Black Trees as no extra field is
required in every tree node.
4) Unlike AVL tree, a splay tree can change even with read-only operations like search.
Applications of Splay Trees
Splay trees have become the most widely used basic data structure invented in the last 3
0 years, because they're the fastest type of balanced search tree for many applications.
Splay trees are used in Windows NT (in the virtual memory, networking, and file system c
ode), the gcc compiler and GNU C++ library, the sed string editor, Fore Systems network
routers, the most popular implementation of Unix malloc, Linux loadable kernel modules,
and in much other software (Source: http://www.cs.berkeley.edu/~jrs/61b/lec/36)
We will soon be discussing insert and delete operations on splay trees.
References:
http://www.cs.berkeley.edu/~jrs/61b/lec/36
http://www.cs.cornell.edu/courses/cs3110/2009fa/recitations/rec-splay.html
http://courses.cs.washington.edu/courses/cse326/01au/lectures/SplayTrees.ppt

Splay Tree | Set 2 (Insert)
It is recommended to refer following post as prerequisite of this post.
Splay Tree | Set 1 (Search)
As discussed in the previous post, Splay tree is a self-balancing data structure where the last accessed key is
always at root. The insert operation is similar to Binary Search Tree insert with additional steps to make sure
that the newly inserted key becomes the new root.
Following are different cases to insert a key k in splay tree.
1) Root is NULL: We simply allocate a new node and return it as root.
2) Splay the given key k. If k is already present, then it becomes the new root. If not present, then last
accessed leaf node becomes the new root.
3) If new root’s key is same as k, don’t do anything as k is already present.
4) Else allocate memory for new node and compare root’s key with k.
…….4.a) If k is smaller than root’s key, make root as right child of new node, copy left child of root as left
child of new node and make left child of root as NULL.
…….4.b) If k is greater than root’s key, make root as left child of new node, copy right child of root as right
child of new node and make right child of root as NULL.
5) Return new node as new root of tree.
Example:

100 [20] 25
/ \ \ / \
50 200 50 20 50
/ insert(25) / \ insert(25) / \
40 ======> 30 100 ========> 30 100
/ 1. Splay(25) \ \ 2. insert 25 \ \
30 40 200 40 200
/
[20]

// This code is adopted from http://algs4.cs.princeton.edu/33balanced/SplayBST.java.html

#include<stdio.h>
#include<stdlib.h>
// An AVL tree node

struct node
{
int key;
};
{
node->key = key;
return (node);
}

struct node *rightRotate(struct node *x)
{
struct node *y = x->left;
x->left = y->right;
y->right = x;
return y;
}

{
x->right = y->left;
y->left = x;
return y;
}
// This function brings the key at root if key is present in tree.

// If key is not present, then it brings the last accessed item at
// root. This function modifies the tree and returns the new root
struct node *splay(struct node *root, int key)
{
// Base cases: root is NULL or key is present at root
return root;
// Key lies in left subtree

{
if (root->left == NULL) return root;
// Zig-Zig (Left Left)

if (root->left->key > key)
{
// First recursively bring the key as root of left-left
root->left->left = splay(root->left->left, key);
// Do first rotation for root, second rotation is done after else

}
else if (root->left->key < key) // Zig-Zag (Left Right)
{
// First recursively bring the key as root of left-right
root->left->right = splay(root->left->right, key);
// Do first rotation for root->left

if (root->left->right != NULL)
}

return (root->left == NULL)? root: rightRotate(root);
}
else // Key lies in right subtree
{
if (root->right == NULL) return root;
// Zig-Zag (Right Left)

if (root->right->key > key)
{
// Bring the key as root of right-left
root->right->left = splay(root->right->left, key);
// Do first rotation for root->right

if (root->right->left != NULL)
}
else if (root->right->key < key)// Zag-Zag (Right Right)
{
// Bring the key as root of right-right and do first rotation
root->right->right = splay(root->right->right, key);
}

return (root->right == NULL)? root: leftRotate(root);
}
}
// Function to insert a new key k in splay tree with given root

struct node *insert(struct node *root, int k)
{
// Simple Case: If tree is empty
if (root == NULL) return newNode(k);
// Bring the closest leaf node to root

root = splay(root, k);
// If key is already present, then return

if (root->key == k) return root;
// Otherwise allocate memory for new node

struct node *newnode = newNode(k);
// If root's key is greater, make root as right child

// of newnode and copy the left child of root to newnode
if (root->key > k)
{
newnode->right = root;
newnode->left = root->left;
root->left = NULL;
}
// If root's key is smaller, make root as left child

// of newnode and copy the right child of root to newnode
else
{
newnode->left = root;
newnode->right = root->right;
root->right = NULL;
}
return newnode; // newnode becomes new root

}

{
{
if (root != NULL)
{
}
}

int main()
{
printf("Preorder traversal of the modified Splay tree is \n");
preOrder(root);
return 0;
}

Output:

Preorder traversal of the modified Splay tree is
25 20 50 30 40 100 200

Sum of all the numbers that are formed from root to leaf paths
Given a binary tree, where every node value is a Digit from 1-9 .Find the sum of all the numbers which are
formed from root to leaf paths.
For example consider the following Binary Tree.
6
/ \
3 5
/ \ \
2 5 4
/ \
7 4
There are 4 leaves, hence 4 root to leaf paths:
Path Number
6->3->2 632
6->3->5->7 6357
6->3->5->4 6354
6->5>4 654
Answer = 632 + 6357 + 6354 + 654 = 13997

The idea is to do a preorder traversal of the tree. In the preorder traversal, keep track of the value calculated
till the current node, let this value be val. For every node, we update the val as val*10 plus node’s data.
// C program to find sum of all paths from root to leaves

#include <stdio.h>
#include <stdlib.h>
struct node
{
int data;
};
// function to allocate new node with given data

{
node->data = data;
return (node);
}
// Returns sum of all root to leaf paths. The first parameter is root
// of current subtree, the second parameter is value of the number formed
// by nodes from root to this node
int treePathsSumUtil(struct node *root, int val)
{
// Base case
if (root == NULL) return 0;
// Update val
val = (val*10 + root->data);
// if current node is leaf, return the current value of val
return val;
// recur sum of values for left and right subtree

return treePathsSumUtil(root->left, val) +
treePathsSumUtil(root->right, val);
}
// A wrapper function over treePathsSumUtil()

int treePathsSum(struct node *root)
{
// Pass the initial value as 0 as there is nothing above root
return treePathsSumUtil(root, 0);
}
// Driver function to test the above functions

int main()
{
root->right->right= newNode(7);
printf("Sum of all paths is %d", treePathsSum(root));
return 0;
}

Output:

Sum of all paths is 13997

Time Complexity: The above code is a simple preorder traversal code which visits every exactly once.
Therefore, the time complexity is O(n) where n is the number of nodes in the given binary tree.
This article is contributed by Ramchand R. Please write comments if you find anything incorrect, or you
Suffix Array | Set 1 (Introduction)
We strongly recommend to read following post on suffix trees as a pre-requisite for this post.
Pattern Searching | Set 8 (Suffix Tree Introduction)
A suffix array is a sorted array of all suffixes of a given string . The definition is similar to Suffix
Tree which is compressed trie of all suffixes of the given text. Any suffix tree based algorithm can be replaced
with an algorithm that uses a suffix array enhanced with additional information and solves the same
problem in the same time complexity (Source Wiki).
A suffix array can be constructed from Suffix tree by doing a DFS traversal of the suffix tree. In fact Suffix
array and suffix tree both can be constructed from each other in linear time.
Advantages of suffix arrays over suffix trees include improved space requirements, simpler linear time
construction algorithms (e.g., compared to Ukkonen’s algorithm) and improved cache locality (Source: Wiki)
Example:

Let the given string be "banana".
0 banana 5 a
1 anana Sort the Suffixes 3 ana
2 nana ----------------> 1 anana
3 ana alphabetically 0 banana
4 na 4 na
5 a 2 nana
So the suffix array for "banana" is {5, 3, 1, 0, 4, 2}

Naive method to build Suffix Array

A simple method to construct suffix array is to make an array of all suffixes and then sort the array.
Following is implementation of simple method.
// Naive algorithm for building suffix array of a given text

#include <iostream>
#include <cstring>
// Structure to store information of a suffix

struct suffix
{
int index;
char *suff;
};
// A comparison function used by sort() to compare two suffixes

int cmp(struct suffix a, struct suffix b)
{
return strcmp(a.suff, b.suff) < 0? 1 : 0;
}
// This is the main function that takes a string 'txt' of size n as an

// argument, builds and return the suffix array for the given string
int *buildSuffixArray(char *txt, int n)
{
// A structure to store suffixes and their indexes
struct suffix suffixes[n];
// Store suffixes and their indexes in an array of structures.

// The structure is needed to sort the suffixes alphabatically
// and maintain their old indexes while sorting
for (int i = 0; i < n; i++)
{
suffixes[i].index = i;
suffixes[i].suff = (txt+i);
}
// Sort the suffixes using the comparison function

// defined above.
sort(suffixes, suffixes+n, cmp);
// Store indexes of all sorted suffixes in the suffix array

int *suffixArr = new int[n];
for (int i = 0; i < n; i++)
suffixArr[i] = suffixes[i].index;
// Return the suffix array

return suffixArr;
}
// A utility function to print an array of given size

{
for(int i = 0; i < n; i++)
cout << arr[i] << " ";
cout << endl;
}

int main()
{
char txt[] = "banana";
int *suffixArr = buildSuffixArray(txt, n);
cout << "Following is suffix array for " << txt << endl;
printArr(suffixArr, n);
return 0;
}

Output:

Following is suffix array for banana
5 3 1 0 4 2

The time complexity of above method to build suffix array is O(n2Logn) if we consider a O(nLogn) algorithm
used for sorting. The sorting step itself takes O(n2Logn) time as every comparison is a comparison of two
strings and the comparison takes O(n) time.
There are many efficient algorithms to build suffix array. We will soon be covering them as separate posts.
Search a pattern using the built Suffix Array

To search a pattern in a text, we preprocess the text and build a suffix array of the text. Since we have a sorted
array of all suffixes, Binary Search can be used to search. Following is the search function. Note that the
function doesn’t report all occurrences of pattern, it only report one of them.

// This code only contains search() and main. To make it a complete running
// above code or see http://ideone.com/1Io9eN

// A suffix array based search function to search a given pattern
// 'pat' in given text 'txt' using suffix array suffArr[]
void search(char *pat, char *txt, int *suffArr, int n)
{
int m = strlen(pat); // get length of pattern, needed for strncmp()
// Do simple binary search for the pat in txt using the

// built suffix array
int l = 0, r = n-1; // Initilize left and right indexes
while (l <= r)
{
// See if 'pat' is prefix of middle suffix in suffix array
int mid = l + (r - l)/2;
int res = strncmp(pat, txt+suffArr[mid], m);
// If match found at the middle, print it and return

if (res == 0)
{
cout << "Pattern found at index " << suffArr[mid];
return;
}
// Move to left half if pattern is alphabtically less than

// the mid suffix
if (res < 0) r = mid - 1;
// Otherwise move to right half

else l = mid + 1;
}
// We reach here if return statement in loop is not executed

cout << "Pattern not found";
}

int main()
{
char txt[] = "banana"; // text
char pat[] = "nan"; // pattern to be searched in text
// Build suffix array

int *suffArr = buildSuffixArray(txt, n);
// search pat in txt using the built suffix array

search(pat, txt, suffArr, n);
return 0;
}

Output:


The time complexity of the above search function is O(mLogn). There are more efficient algorithms to search
pattern once the suffix array is built. In fact there is a O(m) suffix array based algorithm to search a pattern.
We will soon be discussing efficient algorithm for search.
Applications of Suffix Array

Suffix array is an extremely useful data structure, it can be used for a wide range of problems. Following are
some famous problems where Suffix array can be used.
1) Pattern Searching
2) Finding the longest repeated substring
3) Finding the longest common substring
4) Finding the longest palindrome in a string
See this for more problems where Suffix arrays can be used.
This post is a simple introduction. There is a lot to cover in Suffix arrays. We have discussed
a O(nLogn)
algorithm for Suffix Array construction here. We will soon be discussing more efficient suffix array
algorithms.
References:
http://www.stanford.edu/class/cs97si/suffix-array.pdf
http://en.wikipedia.org/wiki/Suffix_array
discussed above
How to swap two numbers without using a temporary variable?
Given two variables, x and y, swap two variables without using a third variable.
Method 1 (Using Arithmetic Operators)

The idea is to get sum in one of the two given numbers. The numbers can then be swapped using the sum
and subtraction from sum.
#include <stdio.h>
int main()
{
int x = 10, y = 5;
// Code to swap 'x' and 'y'

x = x + y; // x now becomes 15
y = x - y; // y becomes 10
x = x - y; // x becomes 5
printf("After Swapping: x = %d, y = %d", x, y);
return 0;
}

Output:

After Swapping: x = 5, y = 10

Multiplication and division can also be used for swapping.
#include <stdio.h>
int main()
{
int x = 10, y = 5;
// Code to swap 'x' and 'y'

x = x * y; // x now becomes 50
y = x / y; // y becomes 10
x = x / y; // x becomes 5
return 0;
}

Output:


Method 2 (Using Bitwise XOR)
The bitwise XOR operator can be used to swap two variables. The XOR of two numbers x and y returns a
number which has all the bits as 1 wherever bits of x and y differ. For example XOR of 10 (In Binary 1010)
and 5 (In Binary 0101) is 1111 and XOR of 7 (0111) and 5 (0101) is (0010).
#include <stdio.h>
int main()
{
int x = 10, y = 5;
// Code to swap 'x' (1010) and 'y' (0101)

x = x ^ y; // x now becomes 15 (1111)
y = x ^ y; // y becomes 10 (1010)
x = x ^ y; // x becomes 5 (0101)
return 0;
}

Output:


Problems with above methods

1) The multiplication and division based approach doesn’ work if one of the numbers is 0 as the product
becomes 0 irrespective of the other number.
2) Both Arithmetic solutions may cause arithmetic overflow. If x and y are too large, addition and
multiplication may go out of integer range.
3) When we use pointers to variable and make a function swap, all of the above methods fail when both
pointers point to the same variable. Let’s take a look what will happen in this case if both are pointing to the
same variable.
// Bitwise XOR based method

x = x ^ x; // x becomes 0
x = x ^ x; // x remains 0
x = x ^ x; // x remains 0
// Arithmetic based method

x = x + x; // x becomes 2x
x = x – x; // x becomes 0
x = x – x; // x remains 0
Let us see the following program.

#include <stdio.h>
void swap(int *xp, int *yp)
{
*xp = *xp ^ *yp;
*yp = *xp ^ *yp;
*xp = *xp ^ *yp;
}
int main()
{
int x = 10;
swap(&x, &x);
printf("After swap(&x, &x): x = %d", x);
return 0;
}

Output:

After swap(&x, &x): x = 0

Swapping a variable with itself may needed in many standard algorithms. For example see this
implementation of QuickSort where we may swap a variable with itself. The above problem can be avoided
by putting a condition before the swapping.
#include <stdio.h>
void swap(int *xp, int *yp)
{
if (xp == yp) // Check if the two addresses are same
return;
*xp = *xp + *yp;
*yp = *xp - *yp;
*xp = *xp - *yp;
}
int main()
{
int x = 10;
swap(&x, &x);
printf("After swap(&x, &x): x = %d", x);
return 0;
}

Output:

After swap(&x, &x): x = 10

discussed above
Red-Black Tree | Set 1 (Introduction)
Red-Black Tree is a self-balancing Binary Search Tree (BST) where every node follows following rules.
1) Every node has a color either red or black.
2) Root of tree is always black.
3) There are no two adjacent red nodes (A red node cannot have a red parent or red child).
4) Every path from root to a NULL node has same number of black nodes.
Why Red-Black Trees?

Most of the BST operations (e.g., search, max, min, insert, delete.. etc) take O(h) time where h is the height
of the BST. The cost of these operations may become O(n) for a skewed Binary tree. If we make sure that
height of the tree remains O(Logn) after every insertion and deletion, then we can guarantee an upper bound
of O(Logn) for all these operations. The height of a Red Black tree is always O(Logn) where n is the number
of nodes in the tree.
Comparison with AVL Tree

The AVL trees are more balanced compared to Red Black Trees, but they may cause more rotations during
insertion and deletion. So if your application involves many frequent insertions and deletions, then Red
Black trees should be preferred. And if the insertions and deletions are less frequent and search is more
frequent operation, then AVL tree should be preferred over Red Black Tree.
How does a Red-Black Tree ensure balance?

A simple example to understand balancing is, a chain of 3 nodes is not possible in red black tree. We can try
any combination of colors and see all of them violate Red-Black tree property.

A chain of 3 nodes is nodes is not possible in Red-Black Trees.
Following are NOT Red-Black Trees
30 30 30
/ \ / \ / \
20 NIL 20 NIL 20 NIL
/ \ / \ / \
10 NIL 10 NIL 10 NIL
Violates Violates Violates
Property 4. Property 4 Property 3
Following are different possible Red-Black Trees with above 3 keys

20 20
/ \ / \
10 30 10 30
/ \ / \ / \ / \
NIL NIL NIL NIL NIL NIL NIL NIL

From the above examples, we get some idea how Red-Black trees ensure balance. Following is an important
fact about balancing in Red-Black Trees.
Every Red Black Tree with n nodes has height <= 2Log2(n+1)
This can be proved using following facts:

1) For a general Binary Tree, let k be the minimum number of nodes on all root to NULL paths, then n >= 2k
– 1 (Ex. If k is 3, then n is atleast 7). This expression can also be written as k <= 2Log2(n+1)
2) From property 4 of Red-Black trees and above claim, we can say in a Red-Black Tree with n nodes, there
is a root to leaf path with at-most Log2(n+1) black nodes.
3) From property 3 of Red-Black trees, we can claim that the number black nodes in a Red-Black tree is at
least n/2 where n is total number of nodes.
From above 2 points, we can conclude the fact that Red Black Tree with n nodes has height <= 2Log2(n+1)
In this post, we introduced Red-Black trees and discussed how balance is ensured. The hard part is to
maintain balance when keys are added and removed. We will soon be discussing insertion and deletion
operations in coming posts on Red-Black tree.
Exercise:
1) Is it possible to have all black nodes in a Red-Black tree?
2) Draw a Red-Black Tree that is not an AVL tree structure wise?
Insertion and Deletion

Red Black Tree Insertion
Red-Black Tree Deletion
References:
L. Rivest
http://en.wikipedia.org/wiki/Red%E2%80%93black_tree
Video Lecture on Red-Black Tree by Tim Roughgarden
MIT Video Lecture on Red-Black Tree
MIT Lecture Notes on Red Black Tree
discussed above.
Analysis of Algorithms | Set 4 (Analysis of Loops)
We have discussed Asymptotic Analysis, Worst, Average and Best Cases and Asymptotic Notations in
previous posts. In this post, analysis of iterative programs with simple examples is discussed.
1) O(1): Time complexity of a function (or set of statements) is considered as O(1) if it doesn’t contain loop,
recursion and call to any other non-constant time function.

// set of non-recursive and non-loop statements

For example swap() function has O(1) time complexity.

A loop or recursion that runs a constant number of times is also considered as O(1). For example the
following loop is O(1).

// Here c is a constant
for (int i = 1; i

2) O(n): Time Complexity of a loop is considered as O(n) if the loop variables is increme
nted / decremented by a constant amount. For example following functions have O(n) time
complexity.
// Here c is a positive integer constant

for (int i = 1; i 0; i -= c) {
// some O(1) expressions
}
3) O(nc): Time complexity of nested loops is equal to the number of times the innermost s
tatement is executed. For example the following sample loops have O(n 2) time complexity

for (int i = 1; i <=n; i += c) {
for (int j = 1; j <=n; j += c) {
}
}
for (int i = n; i > 0; i += c) {

for (int j = i+1; j <=n; j += c) {
}
For example Selection sort and Insertion Sort have O(n2) time complexity.
4) O(Logn) Time Complexity of a loop is considered as O(Logn) if the loop variables is di

vided / multiplied by a constant amount.
for (int i = 1; i <=n; i *= c) {

for (int i = 1; i <=n; i *= c) {
}
for (int i = n; i > 0; i /= c) {
}
For example Binary Search(refer iterative implementation) has O(Logn) time complexity.
5) O(LogLogn) Time Complexity of a loop is considered as O(LogLogn) if the loop variables

is reduced / increased exponentially by a constant amount.
// Here c is a constant greater than 1

for (int i = 2; i <=n; i = pow(i, c)) {
}
//Here fun is sqrt or cuberoot or any other constant root
for (int i = n; i > 0; i = fun(i)) {
}
See this for more explanation.
How to combine time complexities of consecutive loops?
When there are consecutive loops, we calculate time complexity as sum of time
complexities of individual loops.

for (int i = 1; i <=m; i += c) {
}
for (int i = 1; i <=n; i += c) {
}
Time complexity of above code is O(m) + O(n) which is O(m+n)
If m == n, the time complexity becomes O(2n) which is O(n).

How to calculate time complexity when there are many if, else statements inside loops?
As discussed here, worst case time complexity is the most useful among best, average and
worst. Therefore we need to consider worst case. We evaluate the situation when values
in if-else conditions cause maximum number of statements to be executed.
For example consider the linear search function where we consider the case when element
is present at the end or not present at all.
When the code is too complex to consider all if-else cases, we can get an upper bound by
ignoring if else and other complex control statements.

How to calculate time complexity of recursive functions?
Time complexity of a recursive function can be written as a mathematical recurrence

relation. To calculate time complexity, we must know how to solve recurrences. We will s
oon be discussing recurrence solving techniques as a separate post.
Quiz on Analysis of Algorithms

Analysis of Algorithm | Set 4 (Solving Recurrences)
In the previous post, we discussed analysis of loops. Many algorithms are recursive in nature. When we
analyze them, we get a recurrence relation for time complexity. We get running time on an input of size n as
a function of n and the running time on inputs of smaller sizes. For example in Merge Sort, to sort a given
array, we divide it in two halves and recursively repeat the process for the two halves. Finally we merge the
results. Time complexity of Merge Sort can be written as T(n) = 2T(n/2) + cn. There are many other
algorithms like Binary Search, Tower of Hanoi, etc.
There are mainly three ways for solving recurrences.
1) Substitution Method: We make a guess for the solution and then we use mathematical induction to
prove the the guess is correct or incorrect.

For example consider the recurrence T(n) = 2T(n/2) + n
We guess the solution as T(n) = O(nLogn). Now we use induction

to prove our guess.
We need to prove that T(n) <= cnLogn. We can assume that it is true
for values smaller than n.
T(n) = 2T(n/2) + n
<= cn/2Log(n/2) + n
= cnLogn - cnLog2 + n
= cnLogn - cn + n
<= cnLogn

2) Recurrence Tree Method: In this method, we draw a recurrence tree and calculate the time taken by
every level of tree. Finally, we sum the work done at all levels. To draw the recurrence tree, we start from the
given recurrence and keep drawing till we find a pattern among levels. The pattern is typically a arithmetic
or geometric series.

For example consider the recurrence relation
T(n) = T(n/4) + T(n/2) + cn2
cn2
/ \
T(n/4) T(n/2)
If we further break down the expression T(n/4) and T(n/2),

we get following recursion tree.
cn2
/ \
c(n2)/16 c(n2)/4
/ \ / \
T(n/16) T(n/8) T(n/8) T(n/4)
Breaking down further gives us following
cn2
/ \
c(n2)/16 c(n2)/4
/ \ / \
c(n2)/256 c(n2)/64 c(n2)/64 c(n2)/16
/ \ / \ / \ / \
To know the value of T(n), we need to calculate sum of tree

nodes level by level. If we sum the above tree level by level,
we get the following series
T(n) = c(n^2 + 5(n^2)/16 + 25(n^2)/256) + ....
The above series is geometrical progression with ratio 5/16.
To get an upper bound, we can sum the infinite series.

We get the sum as (n2)/(1 - 5/16) which is O(n2)

3) Master Method:
Master Method is a direct way to get the solution. The master method works only for following type of
recurrences or for recurrences that can be transformed to following type.

T(n) = aT(n/b) + f(n) where a >= 1 and b > 1

There are following three cases:

1. If f(n) = Θ(nc) where c < Logba then T(n) = Θ(nLogba )
2. If f(n) = Θ(nc) where c = Logba then T(n) = Θ(ncLog n)
3.If f(n) = Θ(nc) where c > Logba then T(n) = Θ(f(n))
How does this work?

Master method is mainly derived from recurrence tree method. If we draw recurrence tree of T(n) = aT(n/b)
+ f(n), we can see that the work done at root is f(n) and work done at all leaves is Θ(nc) where c is Logba. And
the height of recurrence tree is Logbn
In recurrence tree method, we calculate total work done. If the work done at leaves is polynomially more,
then leaves are the dominant part, and our result becomes the work done at leaves (Case 1). If work done at
leaves and root is asymptotically same, then our result becomes height multiplied by work done at any level
(Case 2). If work done at root is asymptotically more, then our result becomes work done at root (Case 3).
Examples of some standard algorithms whose time complexity can be evaluated using Master
Method
Merge Sort: T(n) = 2T(n/2) + Θ(n). It falls in case 2 as c is 1 and Loga] is also 1. So the solution is Θ(n Logn)
b
Binary Search: T(n) = T(n/2) + Θ(1). It also falls in case 2 as c is 0 and Loga is also 0. So the solution is
b
Θ(Logn)
Notes:
1) It is not necessary that a recurrence of the form T(n) = aT(n/b) + f(n) can be solved using Master
Theorem. The given three cases have some gaps between them. For example, the recurrence T(n) = 2T(n/2)
+ n/Logn cannot be solved using master method.
2) Case 2 can be extended for f(n) = Θ(ncLogkn)

If f(n) = Θ(ncLogkn) for some constant k >= 0 and c = Logba, then T(n) = Θ(ncLogk+1n)
Practice Problems and Solutions on Master Theorem.
References:
http://en.wikipedia.org/wiki/Master_theorem
MIT Video Lecture on Asymptotic Notation | Recurrences | Substitution, Master Method
L. Rivest
discussed above
Red-Black Tree | Set 2 (Insert)
In the previous post, we discussed introduction to Red-Black Trees. In this post, insertion is discussed.
In AVL tree insertion, we used rotation as a tool to do balancing after insertion caused imbalance. In Red-
Black tree, we use two tools to do balancing.
1) Recoloring
2) Rotation
We try recoloring first, if recoloring doesn’t work, then we go for rotation. Following is detailed algorithm.
The algorithms has mainly two cases depending upon the color of uncle. If uncle is red, we do recoloring. If
uncle is black, we do rotations and/or recoloring.
Color of a NULL node is considered as BLACK.
Let x be the newly inserted node.

1) Perform standard BST insertion and make the color of newly inserted nodes as RED.
2) Do following if color of x’s parent is not BLACK or x is not root.

….a) If x’s uncle is RED (Grand parent must have been black from property 4)
……..(i) Change color of parent and uncle as BLACK.
……..(ii) color of grand parent as RED.
……..(iii) Change x = x’s grandparent, repeat steps 2 and 3 for new x.
….b) If x’s uncle is BLACK , then there can be four configurations for x, x’s parent (p) and x’s grandparent
(g) (This is similar to AVL Tree)
……..i) Left Left Case (p is left child of g and x is left child of p)
……..ii) Left Right Case (p is left child of g and x is right child of p)
……..iii) Right Right Case (Mirror of case a)
……..iv) Right Left Case (Mirror of case c)
3) If x is root, change color of x as BLACK (Black height of complete tree increases by 1).
Following are operations to be performed in four subcases when uncle is BLACK.
All four cases when Uncle is BLACK

Left Left Case (See g, p and x)
Left Right Case (See g, p and x)
Right Right Case (See g, p and x)
Right Left Case (See g, p and x)
Examples of Insertion
Please refer C Program for Red Black Tree Insertion for complete implementation of above algorithm.
discussed above.
Given a Binary Tree (BT), convert it to a Doubly Linked List(DLL) In-Place. The left and right pointers in
nodes are to be used as previous and next pointers respectively in converted DLL. The order of nodes in DLL
must be same as Inorder of the given Binary Tree. The first node of Inorder traversal (left most node in BT)
must be head node of the DLL.
TreeToList
Following two different solutions have been discussed for this problem.
In this post, a third solution is discussed which seems to be the simplest of all. The idea is to do inorder
traversal of the binary tree. While doing inorder traversal, keep track of the previously visited node in a
variable say prev. For every visited node, make it next of prev and previous of this node as prev.
Thanks to rahul, wishall and all other readers for their useful comments on the above two posts.
Following is C++ implementation of this solution.
// A C++ program for in-place conversion of Binary Tree to DLL

#include <iostream>
/* A binary tree node has data, and left and right pointers */
struct node
{
int data;
node* left;
node* right;
};
// A simple recursive function to convert a given Binary tree to Doubly

// Linked List
// root --> Root of Binary Tree
// head --> Pointer to head node of created doubly linked list
void BinaryTree2DoubleLinkedList(node *root, node **head)
{
// Base case
// Initialize previously visited node as NULL. This is

// static so that the same value is accessible in all recursive
// calls
static node* prev = NULL;
// Recursively convert left subtree

BinaryTree2DoubleLinkedList(root->left, head);
// Now convert this node

if (prev == NULL)
*head = root;
else
{
root->left = prev;
prev->right = root;
}
prev = root;
// Finally convert right subtree

// Finally convert right subtree
BinaryTree2DoubleLinkedList(root->right, head);
}

{
new_node->left = new_node->right = NULL;
return (new_node);
}
/* Function to print nodes in a given doubly linked list */

void printList(node *node)
{
while (node!=NULL)
{
node = node->right;
}
}

int main()
{
// Convert to DLL
node *head = NULL;
BinaryTree2DoubleLinkedList(root, &head);
// Print the converted list

printList(head);
return 0;
}

Output:

25 12 30 10 36 15

Note that use of static variables like above is not a recommended practice (we have used static for
simplicity). Imagine a situation where same function is called for two or more trees, the old value of prev
would be used in next call for a different tree. To avoid such problems, we can use double pointer or
reference to a pointer.
Time Complexity: The above program does a simple inorder traversal, so time complexity is O(n) where n is
the number of nodes in given binary tree.
discussed above
Given a linked list, reverse alternate nodes and append at the end
Given a linked list, reverse alternate nodes and append them to end of list. Extra allowed space is O(1)
Examples
Input List: 1->2->3->4->5->6

Output List: 1->3->5->6->4->2
Input List: 12->14->16->18->20

Output List: 12->16->20->18->14

We strongly recommend to minimize the browser and try this yourself first.
The idea is to maintain two linked lists, one list of all odd positioned nodes (1, 3, 5 in above example) and
other list of all even positioned nodes (6, 4 and 2 in above example). Following are detailed steps.
1) Traverse the given linked list which is considered as odd list. Do following for every visited node.
……a) If the node is even node, remove it from odd list and add it to the front of even node list. Nodes are
added at front to keep the reverse order.
2) Append the even node list at the end of odd node list.
#include<stdio.h>
#include<stdlib.h>

struct node
{
int data;
struct node *next;
};
/* Function to reverse all even positioned node and append at the end
odd is the head node of given linked list */
void rearrange(struct node *odd)
{
// If linked list has less than 3 nodes, no change is required
if (odd == NULL || odd->next == NULL || odd->next->next == NULL)
return;
// even points to the beginning of even list

struct node *even = odd->next;
// Remove the first even node

odd->next = odd->next->next;
// odd points to next node in odd list

odd = odd->next;
// Set terminator for even list

even->next = NULL;
// Traverse the list

while (odd && odd->next)
{
// Store the next node in odd list
struct node *temp = odd->next->next;
// Link the next even node at the beginning of even list
odd->next->next = even;
even = odd->next;
// Remove the even node from middle

odd->next = temp;
// Move odd to the next odd node

if (temp != NULL)
odd = temp;
}
// Append the even list at the end of odd list

odd->next = even;
}
/* Function to add a node at the beginning of Linked List */

{
}

{
{
node = node->next;
}
}

int main()
{

1->2->3->4->5->6->7 */
push(&start, 7);
push(&start, 6);
push(&start, 5);
push(&start, 4);
push(&start, 3);
push(&start, 2);
push(&start, 1);
printf("\n Linked list before calling rearrange() ");

printList(start);
rearrange(start);
printf("\n Linked list after calling rearrange() ");

printList(start);
return 0;
}

Output:
Linked list before calling rearrange() 1 2 3 4 5 6 7

Linked list after calling rearrange() 1 3 5 7 6 4 2

Time Complexity: The above code simply traverses the given linked list. So time complexity is O(n)
This article is contributed by Aman Gupta. Please write comments if you find anything incorrect, or you
Find if two rectangles overlap
Given two rectangles, find if the given two rectangles overlap or not.
Note that a rectangle can be represented by two coordinates, top left and bottom right. So mainly we are
given following four coordinates.
l1: Top Left coordinate of first rectangle.
r1: Bottom Right coordinate of first rectangle.
l2: Top Left coordinate of second rectangle.
r2: Bottom Right coordinate of second rectangle.
We need to write a function bool doOverlap(l1, r1, l2, r2) that returns true if the two given rectangles
overlap.
One solution is to one by one pick all points of one rectangle and see if the point lies inside the other
rectangle or not. This can be done using the algorithm discussed here.
Following is a simpler approach. Two rectangles do not overlap if one of the following conditions is true.
1) One rectangle is above top edge of other rectangle.
2) One rectangle is on left side of left edge of other rectangle.
We need to check above cases to find out if given rectangles overlap or not. Following is C++
implementation of the above approach.

#include<stdio.h>
struct Point
{
int x, y;
};
// Returns true if two rectangles (l1, r1) and (l2, r2) overlap
bool doOverlap(Point l1, Point r1, Point l2, Point r2)
{
// If one rectangle is on left side of other
if (l1.x > r2.x || l2.x > r1.x)
return false;
// If one rectangle is above other

if (l1.y < r2.y || l2.y < r1.y)
return false;
return true;
}

int main()
{
Point l1 = {0, 10}, r1 = {10, 0};
Point l2 = {5, 5}, r2 = {15, 0};
if (doOverlap(l1, r1, l2, r2))
printf("Rectangles Overlap");
else
printf("Rectangles Don't Overlap");
return 0;
}

Output:

Rectangles Overlap

Time Complexity of above code is O(1) as the code doesn’t have any loop or recursion.
This article is compiled by Aman Gupta. Please write comments if you find anything incorrect, or you want
Print all nodes that don’t have sibling
Given a Binary Tree, print all nodes that don’t have a sibling (a sibling is a node that has same parent. In a
Binary Tree, there can be at most one sibling). Root should not be printed as root cannot have a sibling.
For example, the output should be “4 5 6″ for the following tree.
This is a typical tree traversal question. We start from root and check if the node has one child, if yes then
print the only child of that node. If node has both children, then recur for both the children.
/* Program to find singles in a given binary tree */

#include <iostream>

struct node
{
int key;
};

node* newNode(int key)
{
temp->key = key;
return temp;
}
// Function to print all non-root nodes that don't have a sibling

void printSingles(struct node *root)
{
// Base case
if (root == NULL)
return;
// If this is an internal node, recur for left

// and right subtrees
if (root->left != NULL && root->right != NULL)
{
printSingles(root->left);
printSingles(root->right);
}
// If left child is NULL and right is not, print right child

// and recur for right child
else if (root->right != NULL)
{
cout << root->right->key << " ";
printSingles(root->right);
}
// If right child is NULL and left is not, print left child

// and recur for left child
else if (root->left != NULL)
{
cout << root->left->key << " ";
}
}

int main()
{
printSingles(root);
return 0;
}

Output:

4 5 6

Time Complexity of above code is O(n) as the code does a simple tree traversal.
This article is compiled by Aman Gupta. Please write comments if you find anything incorrect, or you want
Lowest Common Ancestor in a Binary Tree | Set 1
Given a binary tree (not a binary search tree) and two values say n1 and n2, write a program to find the least
common ancestor.
Following is definition of LCA from Wikipedia:

Let T be a rooted tree. The lowest common ancestor between two nodes n1 and n2 is defined as the lowest
node in T that has both n1 and n2 as descendants (where we allow a node to be a descendant of itself).
The LCA of n1 and n2 in T is the shared ancestor of n1 and n2 that is located farthest from the root.
Computation of lowest common ancestors may be useful, for instance, as part of a procedure for determining
the distance between pairs of nodes in a tree: the distance from n1 to n2 can be computed as the distance
from the root to n1, plus the distance from the root to n2, minus twice the distance from the root to their
lowest common ancestor. (Source Wiki)
We have discussed an efficient solution to find LCA in Binary Search Tree. In Binary Search Tree, using BST
properties, we can find LCA in O(h) time where h is height of tree. Such an implementation is not possible in
Binary Tree as keys Binary Tree nodes don’t follow any order. Following are different approaches to find
LCA in Binary Tree.
Method 1 (By Storing root to n1 and root to n2 paths):

Following is simple O(n) algorithm to find LCA of n1 and n2.
1) Find path from root to n1 and store it in a vector or array.
2) Find path from root to n2 and store it in another vector or array.
3) Traverse both paths till the values in arrays are same. Return the common element just before the
mismatch.
// A O(n) solution to find LCA of two given values n1 and n2

#include <iostream>
#include <vector>
// A Bianry Tree node

struct Node
{
int key;
};
// Utility function creates a new binary tree node with given key
Node * newNode(int k)
{
temp->key = k;
return temp;
}
// Finds the path from root node to given root of the tree, Stores the
// path in a vector path[], returns true if path exists otherwise false
bool findPath(Node *root, vector<int> &path, int k)
{
// base case
if (root == NULL) return false;
// Store this node in path vector. The node will be removed if

// not in path from root to k
path.push_back(root->key);
// See if the k is same as root's key

if (root->key == k)
return true;
// Check if k is found in left or right sub-tree

if ( (root->left && findPath(root->left, path, k)) ||
(root->right && findPath(root->right, path, k)) )
return true;
// If not present in subtree rooted with root, remove root from

// path[] and return false
path.pop_back();
return false;
}
// Returns LCA if node n1, n2 are present in the given binary tree,
// otherwise return -1
int findLCA(Node *root, int n1, int n2)
{
// to store paths to n1 and n2 from the root
vector<int> path1, path2;
// Find paths from root to n1 and root to n1. If either n1 or n2

// is not present, return -1
if ( !findPath(root, path1, n1) || !findPath(root, path2, n2))
return -1;
/* Compare the paths to get the first different value */

int i;
for (i = 0; i < path1.size() && i < path2.size() ; i++)
if (path1[i] != path2[i])
break;
return path1[i-1];
}

int main()
{
// Let us create the Binary Tree shown in above diagram.
Node * root = newNode(1);
cout << "LCA(4, 5) = " << findLCA(root, 4, 5);
cout << "\nLCA(4, 6) = " << findLCA(root, 4, 6);
return 0;
}

Output:

LCA(4, 5) = 2
LCA(4, 6) = 1
LCA(3, 4) = 1
LCA(2, 4) = 2

Time Complexity: Time complexity of the above solution is O(n). The tree is traversed twice, and then
path arrays are compared.
Thanks to Ravi Chandra Enaganti for suggesting the initial solution based on this method.
Method 2 (Using Single Traversal)

The method 1 finds LCA in O(n) time, but requires three tree traversals plus extra spaces for path arrays. If
we assume that the keys n1 and n2 are present in Binary Tree, we can find LCA using single traversal of
Binary Tree and without extra storage for path arrays.
The idea is to traverse the tree starting from root. If any of the given keys (n1 and n2) matches with root,
then root is LCA (assuming that both keys are present). If root doesn’t match with any of the keys, we recur
for left and right subtree. The node which has one key present in its left subtree and the other key present in
right subtree is the LCA. If both keys lie in left subtree, then left subtree has LCA also, otherwise LCA lies in
right subtree.
/* Program to find LCA of n1 and n2 using one traversal of Binary Tree */

#include <iostream>

struct Node
{
int key;
};
// Utility function to create a new tree Node

Node* newNode(int key)
{
temp->key = key;
return temp;
}
// This function returns pointer to LCA of two given values n1 and n2.
// This function assumes that n1 and n2 are present in Binary Tree
struct Node *findLCA(struct Node* root, int n1, int n2)
{
// Base case
// If either n1 or n2 matches with root's key, report

// the presence by returning root (Note that if a key is
// ancestor of other, then the ancestor key becomes LCA
if (root->key == n1 || root->key == n2)
return root;
// Look for keys in left and right subtrees

Node *left_lca = findLCA(root->left, n1, n2);
Node *right_lca = findLCA(root->right, n1, n2);
// If both of the above calls return Non-NULL, then one key

// is present in once subtree and other is present in other,
// So this node is the LCA
if (left_lca && right_lca) return root;
// Otherwise check if left subtree or right subtree is LCA

return (left_lca != NULL)? left_lca: right_lca;
}

int main()
{
cout << "LCA(4, 5) = " << findLCA(root, 4, 5)->key;
cout << "\nLCA(4, 6) = " << findLCA(root, 4, 6)->key;
return 0;
}

Output:

LCA(4, 5) = 2
LCA(4, 6) = 1
LCA(3, 4) = 1
LCA(2, 4) = 2

Thanks to Atul Singh for suggesting this solution.
Time Complexity: Time complexity of the above solution is O(n) as the method does a simple tree
traversal in bottom up fashion.
Note that the above method assumes that keys are present in Binary Tree. If one key is present and other is
absent, then it returns the present key as LCA (Ideally should have returned NULL).
We can extend this method to handle all cases by passing two boolean variables v1 and v2. v1 is set as true
when n1 is present in tree and v2 is set as true if n2 is present in tree.
/* Program to find LCA of n1 and n2 using one traversal of Binary Tree.

It handles all cases even when n1 or n2 is not there in Binary Tree */
#include <iostream>
#include <iostream>

struct Node
{
int key;
};

{
temp->key = key;
return temp;
}
// v1 is set as true by this function if n1 is found
// v2 is set as true by this function if n2 is found
struct Node *findLCAUtil(struct Node* root, int n1, int n2, bool &v1, bool &v2)
{
// Base case
// If either n1 or n2 matches with root's key, report the presence

// by setting v1 or v2 as true and return root (Note that if a key
// is ancestor of other, then the ancestor key becomes LCA)
if (root->key == n1)
{
v1 = true;
return root;
}
{
v2 = true;
return root;
}
// Look for keys in left and right subtrees

Node *left_lca = findLCAUtil(root->left, n1, n2, v1, v2);
Node *right_lca = findLCAUtil(root->right, n1, n2, v1, v2);

if (left_lca && right_lca) return root;

}
// Returns true if key k is present in tree rooted with root

bool find(Node *root, int k)
{
// Base Case
if (root == NULL)
return false;
// If key is present at root, or in left subtree or right subtree,

// return true;
if (root->key == k || find(root->left, k) || find(root->right, k))
return true;
return true;
// Else return false

return false;
}
// This function returns LCA of n1 and n2 only if both n1 and n2 are present
// in tree, otherwise returns NULL;
Node *findLCA(Node *root, int n1, int n2)
{
// Initialize n1 and n2 as not visited
bool v1 = false, v2 = false;
// Find lca of n1 and n2 using the technique discussed above

Node *lca = findLCAUtil(root, n1, n2, v1, v2);
// Return LCA only if both n1 and n2 are present in tree

if (v1 && v2 || v1 && find(lca, n2) || v2 && find(lca, n1))
return lca;
// Else return NULL

return NULL;
}

int main()
{
Node *lca = findLCA(root, 4, 5);
if (lca != NULL)
cout << "LCA(4, 5) = " << lca->key;
else
cout << "Keys are not present ";
lca = findLCA(root, 4, 10);

if (lca != NULL)
cout << "\nLCA(4, 10) = " << lca->key;
else
cout << "\nKeys are not present ";
return 0;
}

Output:

LCA(4, 5) = 2
Keys are not present

Thanks to Dhruv for suggesting this extended solution.
We will soon be discussing more solutions to this problem. Solutions considering the following.
1) If there are many LCA queries and we can take some extra preprocessing time to reduce the time taken to
find LCA.
2) If parent pointer is given with every node.
discussed above
Find distance between two given keys of a Binary Tree
Find the distance between two keys in a binary tree, no parent pointers are given. Distance between two
nodes is the minimum number of edges to be traversed to reach one node from other.
The distance between two nodes can be obtained in terms of lowest common ancestor. Following is the
formula.
Dist(n1, n2) = Dist(root, n1) + Dist(root, n2) - 2*Dist(root, lca)

'n1' and 'n2' are the two given keys
'root' is root of given Binary Tree.
'lca' is lowest common ancestor of n1 and n2
Dist(n1, n2) is the distance between n1 and n2.

Following is C++ implementation of above approach. The implementation is adopted from last code
provided in Lowest Common Ancestor Post.
/* Program to find distance between n1 and n2 using one traversal */

#include <iostream>

struct Node
{
int key;
};

{
temp->key = key;
return temp;
}
// Returns level of key k if it is present in tree, otherwise returns -1

int findLevel(Node *root, int k, int level)
{
{
// Base Case
if (root == NULL)
return -1;
// If key is present at root, or in left subtree or right subtree,

// return true;
if (root->key == k)
return level;
int l = findLevel(root->left, k, level+1);

return (l != -1)? l : findLevel(root->right, k, level+1);
}
// It also sets d1, d2 and dist if one key is not ancestor of other
// d1 --> To store distance of n1 from root
// d2 --> To store distance of n2 from root
// lvl --> Level (or distance from root) of current node
// dist --> To store distance between n1 and n2
Node *findDistUtil(Node* root, int n1, int n2, int &d1, int &d2,
int &dist, int lvl)
{
// Base case

// the presence by returning root (Note that if a key is
// ancestor of other, then the ancestor key becomes LCA
{
d1 = lvl;
return root;
}
{
d2 = lvl;
return root;
}
// Look for n1 and n2 in left and right subtrees

Node *left_lca = findDistUtil(root->left, n1, n2, d1, d2, dist, lvl+1);
Node *right_lca = findDistUtil(root->right, n1, n2, d1, d2, dist, lvl+1);

if (left_lca && right_lca)
{
dist = d1 + d2 - 2*lvl;
return root;
}

}
// The main function that returns distance between n1 and n2

// This function returns -1 if either n1 or n2 is not present in
// Binary Tree.
int findDistance(Node *root, int n1, int n2)
{
// Initialize d1 (distance of n1 from root), d2 (distance of n2
// from root) and dist(distance between n1 and n2)
int d1 = -1, d2 = -1, dist;
int d1 = -1, d2 = -1, dist;
Node *lca = findDistUtil(root, n1, n2, d1, d2, dist, 1);
// If both n1 and n2 were present in Binary Tree, return dist

if (d1 != -1 && d2 != -1)
return dist;
// If n1 is ancestor of n2, consider n1 as root and find level

// of n2 in subtree rooted with n1
if (d1 != -1)
{
dist = findLevel(lca, n2, 0);
return dist;
}
// If n2 is ancestor of n1, consider n2 as root and find level

// of n1 in subtree rooted with n2
if (d2 != -1)
{
dist = findLevel(lca, n1, 0);
return dist;
}
return -1;
}

int main()
{
cout << "Dist(4, 5) = " << findDistance(root, 4, 5);
cout << "\nDist(4, 6) = " << findDistance(root, 4, 6);
return 0;
}

Output:

Dist(4, 5) = 2
Dist(4, 6) = 4
Dist(3, 4) = 3
Dist(2, 4) = 1
Dist(8, 5) = 5

Time Complexity: Time complexity of the above solution is O(n) as the method does a single tree
traversal.
Thanks to Atul Singh for providing the initial solution for this post.
discussed above
Print all nodes that are at distance k from a leaf node
Given a Binary Tree and a positive integer k, print all nodes that are distance k from a leaf node.
Here the meaning of distance is different from previous post. Here k distance from a leaf means k levels
higher than a leaf node. For example if k is more than height of Binary Tree, then nothing should be printed.
Expected time complexity is O(n) where n is the number nodes in the given Binary Tree.
The idea is to traverse the tree. Keep storing all ancestors till we hit a leaf node. When we reach a leaf node,
we print the ancestor at distance k. We also need to keep track of nodes that are already printed as output.
For that we use a boolean array visited[].
/* Program to print all nodes which are at distance k from a leaf */

#include <iostream>
#define MAX_HEIGHT 10000
struct Node
{
int key;
Node *left, *right;
};
/* utility that allocates a new Node with the given key */

{
Node* node = new Node;
node->key = key;
return (node);
}
/* This function prints all nodes that are distance k from a leaf node
path[] --> Store ancestors of a node
visited[] --> Stores true if a node is printed as output. A node may be k
distance away from many leaves, we want to print it once */
void kDistantFromLeafUtil(Node* node, int path[], bool visited[],
int pathLen, int k)
{
// Base case
/* append this Node to the path array */

path[pathLen] = node->key;
path[pathLen] = node->key;
visited[pathLen] = false;
pathLen++;
/* it's a leaf, so print the ancestor at distance k only

if the ancestor is not already printed */
if (node->left == NULL && node->right == NULL &&
pathLen-k-1 >= 0 && visited[pathLen-k-1] == false)
{
cout << path[pathLen-k-1] << " ";
visited[pathLen-k-1] = true;
return;
}
/* If not leaf node, recur for left and right subtrees */

kDistantFromLeafUtil(node->left, path, visited, pathLen, k);
kDistantFromLeafUtil(node->right, path, visited, pathLen, k);
}
/* Given a binary tree and a nuber k, print all nodes that are k
distant from a leaf*/
void printKDistantfromLeaf(Node* node, int k)
{
int path[MAX_HEIGHT];
bool visited[MAX_HEIGHT] = {false};
kDistantFromLeafUtil(node, path, visited, 0, k);
}

int main()
{
cout << "Nodes at distance 2 are: ";

printKDistantfromLeaf(root, 2);
return 0;
}

Output:

Nodes at distance 2 are: 3 1

Time Complexity: Time Complexity of above code is O(n) as the code does a simple tree traversal.
discussed above
Check if a given Binary Tree is height balanced like a Red-Black Tree
In a Red-Black Tree, the maximum height of a node is at most twice the minimum height (The four Red-
Black tree properties make sure this is always followed). Given a Binary Search Tree, we need to check for
following property.
For every node, length of the longest leaf to node path has not more than twice the nodes on shortest path
from node to leaf.
12 40
\ / \
14 10 100
\ / \
16 60 150
Cannot be a Red-Black Tree It can be Red-Black Tree
with any color assignment
Max height of 12 is 1
Min height of 12 is 3
10
/ \
5 100
/ \
50 150
/
40
It can also be Red-Black Tree

Expected time complexity is O(n). The tree should be traversed at-most once in the solution.
For every node, we need to get the maximum and minimum heights and compare them. The idea is to
traverse the tree and for every node check if it’s balanced. We need to write a recursive function that returns
three things, a boolean value to indicate the tree is balanced or not, minimum height and maximum height.
To return multiple values, we can either use a structure or pass variables by reference. We have passed maxh
and minh by reference so that the values can be used in parent calls.
/* Program to check if a given Binary Tree is balanced like a Red-Black Tree */

#include <iostream>
struct Node
{
int key;
Node *left, *right;
};
/* utility that allocates a new Node with the given key */

{
Node* node = new Node;
node->key = key;
return (node);
}
}
// Returns returns tree if the Binary tree is balanced like a Red-Black

// tree. This function also sets value in maxh and minh (passed by
// reference). maxh and minh are set as maximum and minimum heights of root.
bool isBalancedUtil(Node *root, int &maxh, int &minh)
{
// Base case
if (root == NULL)
{
maxh = minh = 0;
return true;
}
int lmxh, lmnh; // To store max and min heights of left subtree
int rmxh, rmnh; // To store max and min heights of right subtree
// Check if left subtree is balanced, also set lmxh and lmnh

if (isBalancedUtil(root->left, lmxh, lmnh) == false)
return false;
// Check if right subtree is balanced, also set rmxh and rmnh

if (isBalancedUtil(root->right, rmxh, rmnh) == false)
return false;
// Set the max and min heights of this node for the parent call
maxh = max(lmxh, rmxh) + 1;
minh = min(lmnh, rmnh) + 1;
// See if this node is balanced

if (maxh <= 2*minh)
return true;
return false;
}
// A wrapper over isBalancedUtil()

bool isBalanced(Node *root)
{
int maxh, minh;
return isBalancedUtil(root, maxh, minh);
}

int main()
{
isBalanced(root)? cout << "Balanced" : cout << "Not Balanced";
return 0;
}

Output:

Balanced

Time Complexity: Time Complexity of above code is O(n) as the code does a simple tree traversal.
discussed above
Rearrange an array so that arr[i] becomes arr[arr[i]] with O(1) extra space
Given an array arr[] of size n where every element is in range from 0 to n-1. Rearrange the given array so
that arr[i] becomes arr[arr[i]]. This should be done with O(1) extra space.
Examples:
Input: arr[] = {3, 2, 0, 1}

Output: arr[] = {1, 0, 3, 2}
Input: arr[] = {4, 0, 2, 1, 3}

Output: arr[] = {3, 4, 2, 0, 1}
Input: arr[] = {0, 1, 2, 3}

Output: arr[] = {0, 1, 2, 3}

If the extra space condition is removed, the question becomes very easy. The main part of the question is to
do it without extra space.
The credit for following solution goes to Ganesh Ram Sundaram . Following are the steps.
1) Increase every array element arr[i] by (arr[arr[i]] % n)*n.

2) Divide every element by n.
Let us understand the above steps by an example array {3, 2, 0, 1}

In first step, every value is incremented by (arr[arr[i]] % n)*n
After first step array becomes {7, 2, 12, 9}.
The important thing is, after the increment operation
of first step, every element holds both old values and new values.
Old value can be obtained by arr[i]%n and new value can be obtained
by arr[i]/n.
In second step, all elements are updated to new or output values

by doing arr[i] = arr[i]/n.
After second step, array becomes {1, 0, 3, 2}


#include <iostream>
// The function to rearrange an array in-place so that arr[i]

// becomes arr[arr[i]].
{
// First step: Increase all values by (arr[arr[i]]%n)*n
for (int i=0; i < n; i++)
arr[i] += (arr[arr[i]]%n)*n;
// Second Step: Divide all values by n

arr[i] /= n;
}

{
for (int i = 0; i < n; i++)
cout << arr[i] << " ";
cout << endl;
}

int main()
{
int arr[] = {3, 2, 0, 1};
cout << "Given array is \n";

printArr(arr, n);
rearrange(arr, n);
cout << "Modified array is \n";

printArr(arr, n);
return 0;
}

Output:

Given array is
3 2 0 1
Modified array is
1 0 3 2


The only problem with above solution is, it may cause overflow.
This article is contributed by Himanshu Gupta. Please write comments if you find anything incorrect, or
Sort n numbers in range from 0 to n^2 – 1 in linear time
2 – 1. Sort
Given an array of numbers of size n. It is also given that the array elements are in range from 0 to n
the given array in linear time.
Examples:
Since there are 5 elements, the elements can be from 0 to 24.
Input: arr[] = {0, 23, 14, 12, 9}
Output: arr[] = {0, 9, 12, 14, 23}
Since there are 3 elements, the elements can be from 0 to 8.

Input: arr[] = {7, 0, 2}
Output: arr[] = {0, 2, 7}

Solution: If we use Counting Sort, it would take O(n^2) time as the given range is of size n^2. Using any
comparison based sorting like Merge Sort, Heap Sort, .. etc would take O(nLogn) time.
Now question arises how to do this in 0(n)? Firstly, is it possible? Can we use data given in question? n
numbers in range from 0 to n2 – 1?
The idea is to use Radix Sort. Following is standard Radix Sort algorithm.
1) Do following for each digit i where i varies from least

significant digit to the most significant digit.
…………..a) Sort input array using counting sort (or any stable
sort) according to the i’th digit

Let there be d digits in input integers. Radix Sort takes O(d*(n+b)) time where b is the base for representing
numbers, for example, for decimal system, b is 10. Since n2-1 is the maximum possible value, the value of d
would be O(log b(n)). So overall time complexity is O((n+b)*O(logb(n)). Which looks more than the time
complexity of comparison based sorting algorithms for a large k. The idea is to change base b. If we set b as n,
the value of O(logb(n)) becomes O(1) and overall time complexity becomes O(n).
arr[] = {0, 10, 13, 12, 7}
Let us consider the elements in base 5. For example 13 in

base 5 is 23, and 7 in base 5 is 12.
arr[] = {00(0), 20(10), 23(13), 22(12), 12(7)}
After first iteration (Sorting according to the last digit in

base 5), we get.
arr[] = {00(0), 20(10), 12(7), 22(12), 23(13)}
After second iteration, we get

arr[] = {00(0), 12(7), 20(10), 22(12), 23(13)}

2 – 1.
Following is C++ implementation to sort an array of size n where elements are in range from 0 to n
#include<iostream>

// the digit represented by exp.
int countSort(int arr[], int n, int exp)
{
int output[n]; // output array

int i, count[n] ;
for (int i=0; i < n; i++)
count[i] = 0;

for (i = 0; i < n; i++)
count[ (arr[i]/exp)%n ]++;
// Change count[i] so that count[i] now contains actual

// position of this digit in output[]
for (i = 1; i < n; i++)

for (i = n - 1; i >= 0; i--)
{
output[count[ (arr[i]/exp)%n] - 1] = arr[i];
count[(arr[i]/exp)%n]--;
}

for (i = 0; i < n; i++)
arr[i] = output[i];
}
// The main function to that sorts arr[] of size n using Radix Sort
void sort(int arr[], int n)
{
// Do counting sort for first digit in base n. Note that
// instead of passing digit number, exp (n^0 = 0) is passed.
countSort(arr, n, 1);
// Do counting sort for second digit in base n. Note that

// instead of passing digit number, exp (n^1 = n) is passed.
countSort(arr, n, n);
}

{
for (int i = 0; i < n; i++)
cout << arr[i] << " ";
}

int main()
{
// Since array size is 7, elements should be from 0 to 48
int arr[] = {40, 12, 45, 32, 33, 1, 22};
printArr(arr, n);
sort(arr, n);
cout << "\nSorted array is \n";

printArr(arr, n);
return 0;
}

Output:

Given array is
40 12 45 32 33 1 22
Sorted array is
1 12 22 32 33 40 45

How to sort if range is from 1 to n 2?

If range is from 1 to n n2, the above process can not be directly applied, it must be changed. Consider n =
100 and range from 1 to 10000. Since the base is 100, a digit must be from 0 to 99 and there should be 2
digits in the numbers. But the number 10000 has more than 2 digits. So to sort numbers in a range from 1 to
n2, we can use following process.
1) Subtract all numbers by 1.
2) Since the range is now 0 to n 2, do counting sort twice as done in the above implementation.
3) After the elements are sorted, add 1 to all numbers to obtain the original numbers.
How to sort if range is from 0 to n^3 -1?

Since there can be 3 digits in base n, we need to call counting sort 3 times.
This article is contributed by Bateesh. Please write comments if you find anything incorrect, or you want to
Rearrange a string so that all same characters become d distance away
Given a string and a positive integer d. Some characters may be repeated in the given string. Rearrange
characters of the given string such that the same characters become d distance away from each other. Note
that there can be many possible rearrangements, the output should be one of the possible rearrangements. If
no such arrangement is possible, that should also be reported.
Expected time complexity is O(n) where n is length of input string.

Examples:
Input: "abb", d = 2
Output: "bab"
Input: "aacbbc", d = 3
Output: "abcabc"
Input: "geeksforgeeks", d = 3
Output: egkegkesfesor
Input: "aaa", d = 2
Output: Cannot be rearranged

Hint: Alphabet size may be assumed as constant (256) and extra space may be used.
Solution: The idea is to count frequencies of all characters and consider the most frequent character first
and place all occurrences of it as close as possible. After the most frequent character is placed, repeat the
same process for remaining characters.
1) Let the given string be str and size of string be n
2) Traverse str, store all characters and their frequencies in a Max Heap MH. The value of frequency decides
the order in MH, i.e., the most frequent character is at the root of MH.
3) Make all characters of str as ‘\0′.
4) Do following while MH is not empty.

…a) Extract the Most frequent character. Let the extracted character be x and its frequency be f.
…b) Find the first available position in str, i.e., find the first ‘\0′ in str.
…c) Let the first position be p. Fill x at p, p+d,.. p+(f-1)d
// Rearrange a string so that all same characters become at least d

// distance away
#include <iostream>
#include <cstring>
#include <cstdlib>
#define MAX 256
// A structure to store a character 'c' and its frequency 'f'

// in input string
struct charFreq {
char c;
int f;
};
};
// A utility function to swap two charFreq items.

void swap(charFreq *x, charFreq *y) {
charFreq z = *x;
*x = *y;
*y = z;
}
// A utility function to maxheapify the node freq[i] of a heap

// stored in freq[]
void maxHeapify(charFreq freq[], int i, int heap_size)
{
int l = i*2 + 1;
int r = i*2 + 2;
int largest = i;
if (l < heap_size && freq[l].f > freq[i].f)
largest = l;
if (r < heap_size && freq[r].f > freq[largest].f)
largest = r;
if (largest != i)
{
swap(&freq[i], &freq[largest]);
maxHeapify(freq, largest, heap_size);
}
}
// A utility function to convert the array freq[] to a max heap

void buildHeap(charFreq freq[], int n)
{
int i = (n - 1)/2;
while (i >= 0)
{
maxHeapify(freq, i, n);
i--;
}
}
// A utility function to remove the max item or root from max heap
charFreq extractMax(charFreq freq[], int heap_size)
{
charFreq root = freq[0];
if (heap_size > 1)
{
freq[0] = freq[heap_size-1];
maxHeapify(freq, 0, heap_size-1);
}
return root;
}
// The main function that rearranges input string 'str' such that
// two same characters become d distance away
void rearrange(char str[], int d)
{
// Find length of input string
// Create an array to store all characters and their

// frequencies in str[]
charFreq freq[MAX] = {{0, 0}};
int m = 0; // To store count of distinct characters in str[]
// Traverse the input string and store frequencies of all

// characters in freq[] array.
// characters in freq[] array.
for (int i = 0; i < n; i++)
{
char x = str[i];
// If this character has occurred first time, increment m

if (freq[x].c == 0)
freq[x].c = x, m++;
(freq[x].f)++;
str[i] = '\0'; // This change is used later
}
// Build a max heap of all characters

buildHeap(freq, MAX);
// Now one by one extract all distinct characters from max heap
// and put them back in str[] with the d distance constraint
for (int i = 0; i < m; i++)
{
charFreq x = extractMax(freq, MAX-i);
// Find the first available position in str[]

int p = i;
while (str[p] != '\0')
p++;
// Fill x.c at p, p+d, p+2d, .. p+(f-1)d

for (int k = 0; k < x.f; k++)
{
// If the index goes beyond size, then string cannot
// be rearranged.
if (p + d*k >= n)
{
cout << "Cannot be rearranged";
exit(0);
}
str[p + d*k] = x.c;
}
}
}

int main()
{
char str[] = "aabbcc";
rearrange(str, 3);
cout << str;
}

Output:

abcabc

Algorithmic Paradigm: Greedy Algorithm
Time Complexity: Time complexity of above implementation is O(n + mLog(MAX)). Here n is the length
of str, m is count of distinct characters in str[] and MAX is maximum possible different characters. MAX is
typically 256 (a constant) and m is smaller than MAX. So the time complexity can be considered as O(n).
More Analysis:
The above code can be optimized to store only m characters in heap, we have kept it this way to keep the
code simple. So the time complexity can be improved to O(n + mLogm). It doesn’t much matter through as
MAX is a constant.
Also, the above algorithm can be implemented using a O(mLogm) sorting algorithm. The first steps of above
algorithm remain same. Instead of building a heap, we can sort the freq[] array in non-increasing order of
frequencies and then consider all characters one by one from sorted array.
We will soon be covering an extended version where same characters should be moved at least d distance
away.
Check if a number is multiple of 9 using bitwise operators
Given a number n, write a function that returns true if n is divisible by 9, else false. The most simple way to
check for n’s divisibility by 9 is to do n%9.
Another method is to sum the digits of n. If sum of digits is multiple of 9, then n is multiple of 9.
The above methods are not bitwise operators based methods and require use of % and /.
The bitwise operators are generally faster than modulo and division operators. Following is a bitwise
operator based method to check divisibility by 9.
#include<iostream>
// Bitwise operator based function to check divisibility by 9

bool isDivBy9(int n)
{
// Base cases
if (n == 0 || n == 9)
return true;
if (n < 9)
return false;
// If n is greater than 9, then recur for [floor(n/9) - n%8]

return isDivBy9((int)(n>>3) - (int)(n&7));
}

int main()
{
// Let us print all multiples of 9 from 0 to 100
// using above method
for (int i = 0; i < 100; i++)
if (isDivBy9(i))
cout << i << " ";
return 0;
}

Output:

0 9 18 27 36 45 54 63 72 81 90 99

How does this work?

n/9 can be written in terms of n/8 using the following simple formula.
n/9 = n/8 - n/72

Since we need to use bitwise operators, we get the value of floor(n/8) using n>>3 and get value of n%8 using
n&7. We need to write above expression in terms of floor(n/8) and n%8.
n/8 is equal to “floor(n/8) + (n%8)/8″. Let us write the above expression in terms of floor(n/8) and n%8

n/9 = floor(n/8) + (n%8)/8 - [floor(n/8) + (n%8)/8]/9

n/9 = floor(n/8) - [floor(n/8) - 9(n%8)/8 + (n%8)/8]/9
n/9 = floor(n/8) - [floor(n/8) - n%8]/9

From above equation, n is a multiple of 9 only if the expression floor(n/8) – [floor(n/8) – n%8]/9 is an
integer. This expression can only be an integer if the sub-expression [floor(n/8) – n%8]/9 is an integer. The
subexpression can only be an integer if [floor(n/8) – n%8] is a multiple of 9. So the problem reduces to a
smaller value which can be written in terms of bitwise operators.
discussed above
Tail Recursion
What is tail recursion?
A recursive function is tail recursive when recursive call is the last thing executed by the function. For
example the following C++ function print() is tail recursive.
// An example of tail recursive function

void print(int n)
{
if (n < 0) return;
cout << " " << n;
// The last executed statement is recursive call

print(n-1);
}

Why do we care?
The tail recursive functions considered better than non tail recursive functions as tail-recursion can be
optimized by compiler. The idea used by compilers to optimize tail-recursive functions is simple, since the
recursive call is the last statement, there is nothing left to do in the current function, so saving the current
function’s stack frame is of no use.
Can a non-tail recursive function be written as tail-recursive to optimize it?

Consider the following function to calculate factorial of n. It is a non-tail-recursive function. Although it
looks like a tail recursive at first look. If we take a closer look, we can see that the value returned by fact(n-1)
is used in fact(n), so the call to fact(n-1) is not the last thing done by fact(n)
#include<iostream>
// A NON-tail-recursive function. The function is not tail

// recursive because the value returned by fact(n-1) is used in
// fact(n) and call to fact(n-1) is not the last thing done by fact(n)
unsigned int fact(unsigned int n)
{
return n*fact(n-1);
}

int main()
{
cout << fact(5);
return 0;
}

The above function can be written as a tail recursive function. The idea is to use one more argument and
accumulate the factorial value in second argument. When n reaches 0, return the accumulated value.

#include<iostream>
// A tail recursive function to calculate factorial

unsigned factTR(unsigned int n, unsigned int a)
{
if (n == 0) return a;
return factTR(n-1, n*a);

}
// A wrapper over factTR

unsigned int fact(unsigned int n)
{
return factTR(n, 1);
}

int main()
{
cout << fact(5);
return 0;
}

We will soon be discussing more on tail recursion.
References:
http://en.wikipedia.org/wiki/Tail_call
http://c2.com/cgi/wiki?TailRecursion
discussed above
Interval Tree
Consider a situation where we have a set of intervals and we need following operations to be implemented
efficiently.
1) Add an interval
2) Remove an interval
3) Given an interval x, find if x overlaps with any of the existing intervals.
Interval Tree: The idea is to augment a self-balancing Binary Search Tree (BST) like Red Black Tree, AVL
Tree, etc to maintain set of intervals so that all operations can be done in O(Logn) time.
Every node of Interval Tree stores following information.

a) i: An interval which is represented as a pair [low, high]
b) max: Maximum high value in subtree rooted with this node.
The low value of an interval is used as key to maintain order in BST. The insert and delete operations are
same as insert and delete in self-balancing BST used.
The main operation is to search for an overlapping interval. Following is algorithm for searching an
overlapping interval x in an Interval tree rooted with root.
Interval overlappingIntervalSearch(root, x)
1) If x overlaps with root's interval, return the root's interval.
2) If left child of root is not empty and the max in left child
is greater than x's low value, recur for left child
3) Else recur for right child.

How does the above algorithm work?

Let the interval to be searched be x. We need to prove this in for following two cases.
Case 1: When we go to right subtree, one of the following must be true.

a) There is an overlap in right subtree: This is fine as we need to return one overlapping interval.
b) There is no overlap in either subtree: We go to right subtree only when either left is NULL or maximum
value in left is smaller than x.low. So the interval cannot be present in left subtree.
Case 2: When we go to left subtree, one of the following must be true.

a) There is an overlap in left subtree: This is fine as we need to return one overlapping interval.
b) There is no overlap in either subtree: This is the most important part. We need to consider following facts.
… We went to left subtree because x.low in left subtree
…. max in left subtree is a high of one of the intervals let us say [a, max] in left subtree.
…. Since x doesn’t overlap with any node in left subtree x.low must be smaller than ‘a‘.
…. All nodes in BST are ordered by low value, so all nodes in right subtree must have low value greater
than ‘a‘.
…. From above two facts, we can say all intervals in right subtree have low value greater than x.low. So x
cannot overlap with any interval in right subtree.
Implementation of Interval Tree:

Following is C++ implementation of Interval Tree. The implementation uses basic insert operation of BST to
keep things simple. Ideally it should be insertion of AVL Tree or insertion of Red-Black Tree. Deletion from
BST is left as an exercise.
#include <iostream>
// Structure to represent an interval

struct Interval
{
int low, high;
};
// Structure to represent a node in Interval Search Tree

struct ITNode
{
Interval *i; // 'i' could also be a normal variable
int max;
ITNode *left, *right;
};
// A utility function to create a new Interval Search Tree Node

ITNode * newNode(Interval i)
{
ITNode *temp = new ITNode;
temp->i = new Interval(i);
temp->max = i.high;
};
// A utility function to insert a new Interval Search Tree Node

// This is similar to BST Insert. Here the low value of interval
// is used tomaintain BST property
ITNode *insert(ITNode *root, Interval i)
{
// Base case: Tree is empty, new node becomes root
if (root == NULL)
return newNode(i);
// Get low value of interval at root

int l = root->i->low;
// If root's low value is smaller, then new interval goes to

// left subtree
if (i.low < l)
root->left = insert(root->left, i);
// Else, new node goes to right subtree.

else
else
root->right = insert(root->right, i);
// Update the max value of this ancestor if needed

if (root->max < i.high)
root->max = i.high;
return root;
}
// A utility function to check if given two intervals overlap

bool doOVerlap(Interval i1, Interval i2)
{
if (i1.low <= i2.high && i2.low <= i1.high)
return true;
return false;
}
// The main function that searches a given interval i in a given

// Interval Tree.
Interval *overlapSearch(ITNode *root, Interval i)
{
// Base Case, tree is empty
// If given interval overlaps with root

if (doOVerlap(*(root->i), i))
return root->i;
// If left child of root is present and max of left child is

// greater than or equal to given interval, then i may
// overlap with an interval is left subtree
if (root->left != NULL && root->left->max >= i.low)
return overlapSearch(root->left, i);
// Else interval can only overlap with right subtree

return overlapSearch(root->right, i);
}
void inorder(ITNode *root)

{
cout << "[" << root->i->low << ", " << root->i->high << "]"
<< " max = " << root->max << endl;
}

int main()
{
// Let us create interval tree shown in above figure
Interval ints[] = {{15, 20}, {10, 30}, {17, 19},
{5, 20}, {12, 15}, {30, 40}
};
int n = sizeof(ints)/sizeof(ints[0]);
ITNode *root = NULL;
for (int i = 0; i < n; i++)
root = insert(root, ints[i]);
cout << "Inorder traversal of constructed Interval Tree is\n";

inorder(root);
inorder(root);
Interval x = {6, 7};
cout << "\nSearching for interval [" << x.low << "," << x.high << "]";
Interval *res = overlapSearch(root, x);
if (res == NULL)
cout << "\nNo Overlapping Interval";
else
cout << "\nOverlaps with [" << res->low << ", " << res->high << "]";
return 0;
}

Output:

Inorder traversal of constructed Interval Tree is
[5, 20] max = 20
[10, 30] max = 30
[12, 15] max = 15
[15, 20] max = 40
[17, 19] max = 40
[30, 40] max = 40
Searching for interval [6,7]

Overlaps with [5, 20]

Applications of Interval Tree:

Interval tree is mainly a geometric data structure and often used for windowing queries, for instance, to find
all roads on a computerized map inside a rectangular viewport, or to find all visible elements inside a three-
dimensional scene (Source Wiki).
Interval Tree vs Segment Tree

Both segment and interval trees store intervals. Segment tree is mainly optimized for queries for a given
point, and interval trees are mainly optimized for overlapping queries for a given interval.
Exercise:
1) Implement delete operation for interval tree.
2) Extend the intervalSearch() to print all overlapping intervals instead of just one.
http://en.wikipedia.org/wiki/Interval_tree
http://www.cse.unr.edu/~mgunes/cs302/IntervalTrees.pptx
L. Rivest
https://www.youtube.com/watch?v=dQF0zyaym8A
discussed above
Print a Binary Tree in Vertical Order | Set 1
Given a binary tree, print it vertically. The following example illustrates vertical order traversal.
1
/ \
2 3
/ \ / \
4 5 6 7
\ \
8 9

The output of print this tree vertically will be:
4
2
1 5 6
3 8
7
9

The idea is to traverse the tree once and get the minimum and maximum horizontal distance with respect to
root. For the tree shown above, minimum distance is -2 (for node with value 4) and maximum distance is 3
(For node with value 9).
Once we have maximum and minimum distances from root, we iterate for each vertical line at distance
minimum to maximum from root, and for each vertical line traverse the tree and print the nodes which lie
on that vertical line.
Algorithm:

// min --> Minimum horizontal distance from root

// max --> Maximum horizontal distance from root
// hd --> Horizontal distance of current node from root
findMinMax(tree, min, max, hd)

if hd is less than min then
min = hd;
else if hd is greater than max then
*max = hd;

findMinMax(tree->left, min, max, hd-1);
findMinMax(tree->right, min, max, hd+1);

printVerticalLine(tree, line_no, hd)

if hd is equal to line_no, then
print(tree->data);
printVerticalLine(tree->left, line_no, hd-1);
printVerticalLine(tree->right, line_no, hd+1);

Implementation:
#include <iostream>
// A node of binary tree

struct Node
{
int data;
};
// A utility function to create a new Binary Tree node

Node* newNode(int data)
{
temp->data = data;
return temp;
}
// A utility function to find min and max distances with respect

// to root.
void findMinMax(Node *node, int *min, int *max, int hd)
{
// Base case
// Update min and max

if (hd < *min) *min = hd;
else if (hd > *max) *max = hd;

findMinMax(node->left, min, max, hd-1);
findMinMax(node->right, min, max, hd+1);
}
// A utility function to print all nodes on a given line_no.

// hd is horizontal distance of current node with respect to root.
void printVerticalLine(Node *node, int line_no, int hd)
{
// Base case
// If this node is on the given line number

if (hd == line_no)

printVerticalLine(node->left, line_no, hd-1);
printVerticalLine(node->right, line_no, hd+1);
}
// The main function that prints a given binary tree in

// vertical order
void verticalOrder(Node *root)
{
// Find min and max distances with resepect to root
int min = 0, max = 0;
findMinMax(root, &min, &max, 0);
// Iterate through all possible vertical lines starting

// from the leftmost line and print nodes line by line
for (int line_no = min; line_no <= max; line_no++)
{
printVerticalLine(root, line_no, 0);
cout << endl;
}
}

int main()
{
// Create binary tree shown in above figure
Node *root = newNode(1);
cout << "Vertical order traversal is \n";

verticalOrder(root);
return 0;
}

Output:

Vertical order traversal is
4
2
1 5 6
3 8
7
9

Time Complexity: Time complexity of above algorithm is O(w*n) where w is width of Binary Tree and n is
number of nodes in Binary Tree. In worst case, the value of w can be O(n) (consider a complete tree for
example) and time complexity can become O(n2).
This problem can be solved more efficiently using the technique discussed in this post. We will soon be
discussing complete algorithm and implementation of more efficient method.
This article is contributed by Shalki Agarwal. Please write comments if you find anything incorrect, or you
Count all possible groups of size 2 or 3 that have sum as multiple of 3
Given an unsorted integer (positive values only) array of size ‘n’, we can form a group of two or three,
the
group should be such that the sum of all elements in that group is a multiple of 3. Count all possible number
of groups that can be generated in this way.
Input: arr[] = {3, 6, 7, 2, 9}

Output: 8
// Groups are {3,6}, {3,9}, {9,6}, {7,2}, {3,6,9},
// {3,7,2}, {7,2,6}, {7,2,9}
Input: arr[] = {2, 1, 3, 4}

Output: 4
// Groups are {2,1}, {2,4}, {2,1,3}, {2,4,3}

The idea is to see remainder of every element when divided by 3. A set of elements can form a group only if
sun of their remainders is multiple of 3. Since the task is to enumerate groups, we count all elements with
different remainders.
1. Hash all elements in a count array based on remainder, i.e,

for all elements a[i], do c[a[i]%3]++;
2. Now c[0] contains the number of elements which when divided
by 3 leave remainder 0 and similarly c[1] for remainder 1
and c[2] for 2.
3. Now for group of 2, we have 2 possibilities
a. 2 elements of remainder 0 group. Such possibilities are
c[0]*(c[0]-1)/2
b. 1 element of remainder 1 and 1 from remainder 2 group
Such groups are c[1]*c[2].
4. Now for group of 3,we have 4 possibilities
a. 3 elements from remainder group 0.
No. of such groups are c[0]C3
b. 3 elements from remainder group 1.
c. 3 elements from remainder group 2.
d. 1 element from each of 3 groups.
No. of such groups are c[0]*c[1]*c[2].
5. Add all the groups in steps 3 and 4 to obtain the result.

#include<stdio.h>
// Returns count of all possible groups that can be formed from elements
// of a[].
int findgroups(int arr[], int n)
{
// Create an array C[3] to store counts of elements with remainder
// 0, 1 and 2. c[i] would store count of elements with remainder i
int c[3] = {0}, i;
int res = 0; // To store the result
// Count elements with remainder 0, 1 and 2

for (i=0; i<n; i++)
c[arr[i]%3]++;
// Case 3.a: Count groups of size 2 from 0 remainder elements

res += ((c[0]*(c[0]-1))>>1);
// Case 3.b: Count groups of size 2 with one element with 1

// remainder and other with 2 remainder
res += c[1] * c[2];
// Case 4.a: Count groups of size 3 with all 0 remainder elements

res += (c[0] * (c[0]-1) * (c[0]-2))/6;
// Case 4.b: Count groups of size 3 with all 1 remainder elements

res += (c[1] * (c[1]-1) * (c[1]-2))/6;
// Case 4.c: Count groups of size 3 with all 2 remainder elements

res += ((c[2]*(c[2]-1)*(c[2]-2))/6);
// Case 4.c: Count groups of size 3 with different remainders

res += c[0]*c[1]*c[2];
// Return total count stored in res

return res;
}

int main()
{
int arr[] = {3, 6, 7, 2, 9};
printf("Required number of groups are %d\n", findgroups(arr,n));
return 0;
}

Output:

Required number of groups are 8


Print all nodes at distance k from a given node
Given a binary tree, a target node in the binary tree, and an integer value k, print all the nodes that are at
distance k from the given target node. No parent pointers are available.
Consider the tree shown in diagram
Input: target = pointer to node with data 8.

root = pointer to node with data 20.
k = 2.
Output : 10 14 22
If target is 14 and k is 3, then output

should be "4 20"
There are two types of nodes to be considered.

1) Nodes in the subtree rooted with target node. For example if the target node is 8 and k is 2, then such
nodes are 10 and 14.
2) Other nodes, may be an ancestor of target, or a node in some other subtree. For target node 8 and k is 2,
the node 22 comes in this category.
Finding the first type of nodes is easy to implement. Just traverse subtrees rooted with the target node and
decrement k in recursive call. When the k becomes 0, print the node currently being traversed (See this for
more details). Here we call the function as printkdistanceNodeDown().
How to find nodes of second type? For the output nodes not lying in the subtree with the target node as the
root, we must go through all ancestors. For every ancestor, we find its distance from target node, let the
distance be d, now we go to other subtree (if target was found in left subtree, then we go to right subtree and
vice versa) of the ancestor and find all nodes at k-d distance from the ancestor.
#include <iostream>
// A binary Tree node

struct node
{
{
int data;
};
/* Recursive function to print all the nodes at distance k in the

tree (or subtree) rooted with given root. See */
void printkdistanceNodeDown(node *root, int k)
{
// Base Case
if (root == NULL || k < 0) return;
// If we reach a k distant node, print it

if (k==0)
{
cout << root->data << endl;
return;
}

printkdistanceNodeDown(root->left, k-1);
printkdistanceNodeDown(root->right, k-1);
}
// Prints all nodes at distance k from a given target node.

// The k distant nodes may be upward or downward. This function
// Returns distance of root from target node, it returns -1 if target
// node is not present in tree rooted with root.
int printkdistanceNode(node* root, node* target , int k)
{
// Base Case 1: If tree is empty, return -1
if (root == NULL) return -1;
// If target is same as root. Use the downward function

// to print all nodes at distance k in subtree rooted with
// target or root
if (root == target)
{
printkdistanceNodeDown(root, k);
return 0;
}

int dl = printkdistanceNode(root->left, target, k);
// Check if target node was found in left subtree

if (dl != -1)
{
// If root is at distance k from target, print root
// Note that dl is Distance of root's left child from target
if (dl + 1 == k)
// Else go to right subtree and print all k-dl-2 distant nodes

// Note that the right child is 2 edges away from left child
else
printkdistanceNodeDown(root->right, k-dl-2);
// Add 1 to the distance and return value for parent calls

return 1 + dl;
}
// MIRROR OF ABOVE CODE FOR RIGHT SUBTREE

// Note that we reach here only when node was not found in left subtree
int dr = printkdistanceNode(root->right, target, k);
int dr = printkdistanceNode(root->right, target, k);
if (dr != -1)
{
if (dr + 1 == k)
else
printkdistanceNodeDown(root->left, k-dr-2);
return 1 + dr;
}
// If target was neither present in left nor in right subtree

return -1;
}
// A utility function to create a new binary tree node

node *newnode(int data)
{
temp->data = data;
return temp;
}

int main()
{
/* Let us construct the tree shown in above diagram */
node * root = newnode(20);
root->left->right->left = newnode(10);
root->left->right->right = newnode(14);
node * target = root->left->right;
printkdistanceNode(root, target, 2);
return 0;
}

Output:
4
20

Time Complexity: At first look the time complexity looks more than O(n), but if we take a closer look, we can
observe that no node is traversed more than twice. Therefore the time complexity is O(n).
This article is contributed by Prasant Kumar. Please write comments if you find anything incorrect, or you
Backtracking | Set 8 (Solving Cryptarithmetic Puzzles)
Newspapers and magazines often have crypt-arithmetic puzzles of the form:
SEND
+ MORE
--------
MONEY
--------

The goal here is to assign each letter a digit from 0 to 9 so that the arithmetic works out correctly. The rules
are that all occurrences of a letter must be assigned the same digit, and no digit can be assigned to more than
one letter.
First, create a list of all the characters that need assigning to pass to Solve
If all characters are assigned, return true if puzzle is solved, false otherwise
Otherwise, consider the first unassigned character
for (every possible choice among the digits not in use)
make that choice and then recursively try to assign the rest of the characters
if recursion sucessful, return true
if !successful, unmake assignment and try another digit
If all digits have been tried and nothing worked, return false to trigger backtracking

/* ExhaustiveSolve
* ---------------
* This is the "not-very-smart" version of cryptarithmetic solver. It takes
* the puzzle itself (with the 3 strings for the two addends and sum) and a
* string of letters as yet unassigned. If no more letters to assign
* then we've hit a base-case, if the current letter-to-digit mapping solves
* the puzzle, we're done, otherwise we return false to trigger backtracking
* If we have letters to assign, we take the first letter from that list, and
* try assigning it the digits from 0 to 9 and then recursively working
* through solving puzzle from here. If we manage to make a good assignment
* that works, we've succeeded, else we need to unassign that choice and try
* another digit. This version is easy to write, since it uses a simple
* approach (quite similar to permutations if you think about it) but it is
* not so smart because it doesn't take into account the structure of the
* puzzle constraints (for example, once the two digits for the addends have
* been assigned, there is no reason to try anything other than the correct
* digit for the sum) yet it tries a lot of useless combos regardless
*/
bool ExhaustiveSolve(puzzleT puzzle, string lettersToAssign)
{
if (lettersToAssign.empty()) // no more choices to make
return PuzzleSolved(puzzle); // checks arithmetic to see if works
for (int digit = 0; digit <= 9; digit++) // try all digits
{
if (AssignLetterToDigit(lettersToAssign[0], digit))
{
if (ExhaustiveSolve(puzzle, lettersToAssign.substr(1)))
return true;
UnassignLetterFromDigit(lettersToAssign[0], digit);
}
}
return false; // nothing worked, need to backtrack
}

The algorithm above actually has a lot in common with the permutations algorithm, it pretty much just
creates all arrangements of the mapping from characters to digits and tries each until one works or all have
been successfully tried. For a large puzzle, this could take a while.
A smarter algorithm could take into account the structure of the puzzle and avoid going down dead-end
paths. For example, if we assign the characters starting from the ones place and moving to the left, at each
stage, we can verify the correctness of what we have so far before we continue onwards. This definitely
complicates the code but leads to a tremendous improvement in efficiency, making it much more feasible to
solve large puzzles.
Below pseudocode in this case has more special cases, but the same general design
Start by examining the rightmost digit of the topmost row, with a carry of 0
If we are beyond the leftmost digit of the puzzle, return true if no carry, false otherwise
If we are currently trying to assign a char in one of the addends
If char already assigned, just recur on row beneath this one, adding value into sum
If not assigned, then
for (every possible choice among the digits not in use)
make that choice and then on row beneath this one, if successful, return true
if !successful, unmake assignment and try another digit
return false if no assignment worked to trigger backtracking
Else if trying to assign a char in the sum
If char assigned & matches correct,
recur on next column to the left with carry, if success return true,
If char assigned & doesn’t match, return false
If char unassigned & correct digit already used, return false
If char unassigned & correct digit unused,
assign it and recur on next column to left with carry, if success return true
return false to trigger backtracking
Source:
Divide and Conquer | Set 5 (Strassen’s Matrix Multiplication)
Given two square matrices A and B of size n x n each, find their multiplication matrix.
Naive Method
Following is a simple way to multiply two matrices.
void multiply(int A[][N], int B[][N], int C[][N])

{
for (int i = 0; i < N; i++)
{
for (int j = 0; j < N; j++)
{
C[i][j] = 0;
for (int k = 0; k < N; k++)
{
C[i][j] += A[i][k]*B[k][j];
}
}
}
}

Time Complexity of above method is O(N3).
Divide and Conquer

Following is simple Divide and Conquer method to multiply two square matrices.
1) Divide matrices A and B in 4 sub-matrices of size N/2 x N/2 as shown in the below diagram.
2) Calculate following values recursively. ae + bg, af + bh, ce + dg and cf + dh.
In the above method, we do 8 multiplications for matrices of size N/2 x N/2 and 4 additions. Addition of two
matrices takes O(N 2) time. So the time complexity can be written as
T(N) = 8T(N/2) + O(N2)
From Master's Theorem, time complexity of above method is O(N3)

which is unfortunately same as the above naive method.

Simple Divide and Conquer also leads to O(N 3), can there be a better way?
In the above divide and conquer method, the main component for high time complexity is 8 recursive calls.
The idea of Strassen’s method is to reduce the number of recursive calls to 7. Strassen’s method is similar
to above simple divide and conquer method in the sense that this method also divide matrices to sub-
matrices of size N/2 x N/2 as shown in the above diagram, but in Strassen’s method, the four sub-matrices of
result are calculated using following formulae.
Time Complexity of Strassen’s Method

Addition and Subtraction of two matrices takes O(N2) time. So time complexity can be written as
T(N) = 7T(N/2) + O(N 2)
From Master's Theorem, time complexity of above method is

O(N Log7 ) which is approximately O(N2.8074)

Generally Strassen’s Method is not preferred for practical applications for following reasons.
1) The constants used in Strassen’s method are high and for a typical application Naive method works better.
2) For Sparse matrices, there are better methods especially designed for them.
3) The submatrices in recursion take extra space.
4) Because of the limited precision of computer arithmetic on noninteger values, larger errors accumulate in
Strassen’s algorithm than in Naive Method (Source: CLRS Book)
References:
L. Rivest
https://www.youtube.com/watch?v=LOLebQ8nKHA
https://www.youtube.com/watch?v=QXY4RskLQcI
discussed above
Construct a tree from Inorder and Level order traversals
Given inorder and level-order traversals of a Binary Tree, construct the Binary Tree. Following is an example
to illustrate the problem.
Input: Two arrays that represent Inorder

and level order traversals of a
Binary Tree
in[] = {4, 8, 10, 12, 14, 20, 22};
level[] = {20, 8, 22, 4, 12, 10, 14};
Output: Construct the tree represented

by the two arrays.
For the above two arrays, the
constructed tree is shown in
the diagram on right side

The following post can be considered as a prerequisite for this.
Construct Tree from given Inorder and Preorder traversals
Let us consider the above example.
in[] = {4, 8, 10, 12, 14, 20, 22};

level[] = {20, 8, 22, 4, 12, 10, 14};
In a Levelorder sequence, the first element is the root of the tree. So we know ’20’ is root for given
sequences. By searching ’20’ in Inorder sequence, we can find out all elements on left side of ‘20’ are in left
subtree and elements on right are in right subtree. So we know below structure now.
20
/ \
/ \
{4,8,10,12,14} {22}

Let us call {4,8,10,12,14} as left subarray in Inorder traversal and {22} as right subarray in Inorder traversal.
In level order traversal, keys of left and right subtrees are not consecutive. So we extract all nodes from level
order traversal which are in left subarray of Inorder traversal. To construct the left subtree of root, we recur
for the extracted elements from level order traversal and left subarray of inorder traversal. In the above
example, we recur for following two arrays.
// Recur for following arrays to construct the left subtree

In[] = {4, 8, 10, 12, 14}
level[] = {8, 4, 12, 10, 14}

Similarly, we recur for following two arrays and construct the right subtree.
// Recur for following arrays to construct the right subtree

In[] = {22}
level[] = {22}

/* program to construct tree using inorder and levelorder traversals */

#include <iostream>
/* A binary tree node */

struct Node
{
int key;
struct Node* left, *right;
};
/* Function to find index of value in arr[start...end] */

int search(int arr[], int strt, int end, int value)
{
for (int i = strt; i <= end; i++)
if (arr[i] == value)
return i;
return -1;
}
// n is size of level[], m is size of in[] and m < n. This

// function extracts keys from level[] which are present in
// in[]. The order of extracted keys must be maintained
int *extrackKeys(int in[], int level[], int m, int n)
{
int *newlevel = new int[m], j = 0;
for (int i = 0; i < n; i++)
if (search(in, 0, m-1, level[i]) != -1)
newlevel[j] = level[i], j++;
return newlevel;
}
/* function that allocates a new node with the given key */

{
Node *node = new Node;
node->key = key;
return (node);
return (node);
}
/* Recursive function to construct binary tree of size n from

Inorder traversal in[] and Level Order traversal level[].
inSrt and inEnd are start and end indexes of array in[]
Initial values of inStrt and inEnd should be 0 and n -1.
The function doesn't do any error checking for cases
where inorder and levelorder do not form a tree */
Node* buildTree(int in[], int level[], int inStrt, int inEnd, int n)
{
// If start index is more than the end index

if (inStrt > inEnd)
return NULL;
/* The first node in level order traversal is root */

Node *root = newNode(level[0]);
/* If this node has no children then return */

if (inStrt == inEnd)
return root;
/* Else find the index of this node in Inorder traversal */

int inIndex = search(in, inStrt, inEnd, root->key);
// Extract left subtree keys from level order traversal

int *llevel = extrackKeys(in, level, inIndex, n);
// Extract right subtree keys from level order traversal

int *rlevel = extrackKeys(in + inIndex + 1, level, n-inIndex-1, n);
/* construct left and right subtress */

root->left = buildTree(in, llevel, inStrt, inIndex-1, n);
root->right = buildTree(in, rlevel, inIndex+1, inEnd, n);
// Free memory to avoid memory leak

delete [] llevel;
delete [] rlevel;
return root;
}
/* Uti;ity function to print inorder traversal of binary tree */

void printInorder(Node* node)
{
if (node == NULL)
return;
cout << node->key << " ";
}

int main()
{
int in[] = {4, 8, 10, 12, 14, 20, 22};
int level[] = {20, 8, 22, 4, 12, 10, 14};
int n = sizeof(in)/sizeof(in[0]);
Node *root = buildTree(in, level, 0, n - 1, n);

cout << "Inorder traversal of the constructed tree is \n";
printInorder(root);
return 0;
}

Output:

Inorder traversal of the constructed tree is
4 8 10 12 14 20 22

An upper bound on time complexity of above method is O(n3). In the main recursive function,
extractNodes() is called which takes O(n 2) time.
The code can be optimized in many ways and there may be better solutions. Looking for improvements and
other optimized approaches to solve this problem.
Red-Black Tree | Set 3 (Delete)
We have discussed following topics on Red-Black tree in previous posts. We strongly recommend to refer
following post as prerequisite of this post.
Red-Black Tree Introduction

Red Black Tree Insert
Insertion Vs Deletion:
Like Insertion, recoloring and rotations are used to maintain the Red-Black properties.
In insert operation, we check color of uncle to decide the appropriate case. In delete operation, we check
color of sibling to decide the appropriate case.
The main property that violates after insertion is two consecutive reds. In delete, the main violated property
is, change of black height in subtrees as deletion of a black node may cause reduced black height in one root
to leaf path.
Deletion is fairly complex process. To understand deletion, notion of double black is used. When a black
node is deleted and replaced by a black child, the child is marked as double black. The main task now
becomes to convert this double black to single black.
Deletion Steps
Following are detailed steps for deletion.
1) Perform standard BST delete. When we perform standard delete operation in BST, we always end up
deleting a node which is either leaf or has only one child (For an internal node, we copy the successor and
then recursively call delete for successor, successor is always a leaf node or a node with one child). So we
only need to handle cases where a node is leaf or has one child. Let v be the node deleted and u be the child
that replaces v.
2) Simple Case: If either u or v is red, we mark the replaced child as black (No change in black height).
Note that both u and v cannot be red as v is parent of u and two consecutive reds are not allowed in red-black
tree.
3) If Both u and v are Black .
3.1) Color u as double black. Now our task reduces to convert this double black to single black. Note that If v
is leaf, then u is NULL and color of NULL is considered as black. So the deletion of a black leaf also causes a
double black.
3.2) Do following while the current node u is double black or it is not root. Let sibling of node be
s.
….(a): If sibling s is black and at least one of sibling’s children is red, perform rotation(s). Let the
red child of s be r. This case can be divided in four subcases depending upon positions of s and r.
…………..(i) Left Left Case (s is left child of its parent and r is left child of s or both children of s are red). This
is mirror of right right case shown in below diagram.
…………..(ii) Left Right Case (s is left child of its parent and r is right child). This is mirror of right left case
shown in below diagram.
…………..(iii) Right Right Case (s is right child of its parent and r is right child of s or both children of s are
red)
…………..(iv) Right Left Case (s is right child of its parent and r is left child of s)
…..(b): If sibling is black and its both children are black , perform recoloring, and recur for the
parent if parent is black.
In this case, if parent was red, then we didn’t need to recur for prent, we can simply make it black (red +
double black = single black)
…..(c): If sibling is red, perform a rotation to move old sibling up, recolor the old sibling and parent. The
new sibling is always black (See the below diagram). This mainly converts the tree to black sibling case (by
rotation) and leads to case (a) or (b). This case can be divided in two subcases.
…………..(i) Left Case (s is left child of its parent). This is mirror of right right case shown in below diagram.
We right rotate the parent p.
…………..(iii) Right Case (s is right child of its parent). We left rotate the parent p.
3.3) If u is root, make it single black and return (Black height of complete tree reduces by 1).
References:
https://www.cs.purdue.edu/homes/ayg/CS251/slides/chap13c.pdf
L. Rivest
discussed above
Find if there is a subarray with 0 sum
Given an array of positive and negative numbers, find if there is a subarray with 0 sum.
Examples:
Input: {4, 2, -3, 1, 6}

Output: true
There is a subarray with zero sum from index 1 to 3.
Input: {4, 2, 0, 1, 6}
Output: true
There is a subarray with zero sum from index 2 to 2.
Input: {-3, 2, 3, 1, 6}
Output: false
There is no subarray with zero sum.

A simple solution is to consider all subarrays one by one and check the sum of every subarray. We can run
two loops: the outer loop picks a starting point i and the inner loop tries all subarrays starting from i (See this
for implementation). Time complexity of this method is O(n2).
We can also use hashing. The idea is to iterate through the array and for every element arr[i], calculate
sum of elements form 0 to i (this can simply be done as sum += arr[i]). If the current sum has been seen
before, then there is a zero sum array. Hashing is used to store the sum values, so that we can quickly store
sum and find out whether the current sum is seen before or not.
Following is Java implementation of the above approach.

// A Java program to find if there is a zero sum subarray


class ZeroSumSubarray {

// Returns true if arr[] has a subarray with sero sum
static Boolean printZeroSumSubarray(int arr[])
{

// Initialize sum of elements
int sum = 0;

// Traverse through the given array
for (int i = 0; i < arr.length; i++)
{
// Add current element to sum
sum += arr[i];

// Return true in following cases
// a) Current element is 0
// b) sum of elements from 0 to i is 0
// c) sum is already present in hash map
if (arr[i] == 0 || sum == 0 || hM.get(sum) != null)
return true;

// Add sum to hash map
hM.put(sum, i);
}

// We reach here only when there is no subarray with 0 sum
return false;
}

public static void main(String arg[])
{
int arr[] = {4, 2, -3, 1, 6};
if (printZeroSumSubarray(arr))
System.out.println("Found a subarray with 0 sum");
else
System.out.println("No Subarray with 0 sum");
}
}

Output:

Found a subarray with 0 sum

Time Complexity of this solution can be considered as O(n) under the assumption that we have good hashing
function that allows insertion and retrieval operations in O(1) time.
Exercise:
Extend the above program to print starting and ending indexes of all subarrays with 0 sum.
This article is contributed by Chirag Gupta. Please write comments if you find anything incorrect, or you
Print Right View of a Binary Tree
Given a Binary Tree, print Right view of it. Right view of a Binary Tree is set of nodes visible when tree is
visited from Right side.
Right view of following tree is 1 3 7 8
1
/ \
2 3
/ \ / \
4 5 6 7
\
8

The Right view contains all nodes that are last nodes in their levels. A simple solution is to do
level order
traversal and print the last node in every level.
The problem can also be solved using simple recursive traversal. We can keep track of level of a node by
passing a parameter to all recursive calls. The idea is to keep track of maximum level also. And traverse the
tree in a manner that right subtree is visited before left subtree. Whenever we see a node whose level is more
than maximum level so far, we print the node because this is the last node in its level (Note that we traverse
the right subtree before left subtree). Following is C implementation of this approach.
// C program to print right view of Binary Tree

#include<stdio.h>
#include<stdlib.h>
struct Node
{
int data;
};
// A utility function to create a new Binary Tree Node

struct Node *newNode(int item)
{
struct Node *temp = (struct Node *)malloc(sizeof(struct Node));
temp->data = item;
return temp;
}
// Recursive function to print right view of a binary tree.

void rightViewUtil(struct Node *root, int level, int *max_level)
{
// Base Case
if (root==NULL) return;
// If this is the last Node of its level

if (*max_level < level)
{
printf("%d\t", root->data);
*max_level = level;
*max_level = level;
}
// Recur for right subtree first, then left subtree

rightViewUtil(root->right, level+1, max_level);
rightViewUtil(root->left, level+1, max_level);
}
// A wrapper over rightViewUtil()

void rightView(struct Node *root)
{
int max_level = 0;
rightViewUtil(root, 1, &max_level);
}

int main()
{
rightView(root);
return 0;
}

Output:

1 3 7 8

This article is contributed by Shalki Agarwal. Please write comments if you find anything incorrect, or you
Find the number of zeroes
Given an array of 1s and 0s which has all 1s first followed by all 0s. Find the number of 0s. Count the number
of zeroes in the given array.
Examples:
Input: arr[] = {1, 1, 1, 1, 0, 0}

Output: 2
Input: arr[] = {1, 0, 0, 0, 0}

Output: 4
Input: arr[] = {0, 0, 0}

Output: 3
Input: arr[] = {1, 1, 1, 1}

Output: 0

We strongly recommend to minimize the browser and try this yourself in time complexity
better than O(n).
A simple solution is to traverse the input array. As soon as we find a 0, we return n – index of first 0. Here
n is number of elements in input array. Time complexity of this solution would be O(n).
Since the input array is sorted, we can use Binary Search to find the first occurrence of 0. Once we have
index of first element, we can return count as n – index of first zero.

// A divide and conquer solution to find count of zeroes in an array

// where all 1s are present before all 0s
#include <stdio.h>
/* if 0 is present in arr[] then returns the index of FIRST occurrence

of 0 in arr[low..high], otherwise returns -1 */
int firstZero(int arr[], int low, int high)
{
if (high >= low)
{
// Check if mid element is first 0
if (( mid == 0 || arr[mid-1] == 1) && arr[mid] == 0)
return mid;
if (arr[mid] == 1) // If mid element is not 0

return firstZero(arr, (mid + 1), high);
else // If mid element is 0, but not first 0
return firstZero(arr, low, (mid -1));
}
return -1;
}
// A wrapper over recursive function firstZero()

int countZeroes(int arr[], int n)
{
// Find index of first zero in given array
int first = firstZero(arr, 0, n-1);
// If 0 is not present at all, return 0

if (first == -1)
return 0;
return (n - first);
}

int main()
{
int arr[] = {1, 1, 1, 0, 0, 0, 0, 0};
printf("Count of zeroes is %d", countZeroes(arr, n));
return 0;
}

Output:

Count of zeroes is 5

Time Complexity: O(Logn) where n is number of elements in arr[].
discussed above
Suffix Array | Set 2 (nLogn Algorithm)
A suffix array is a sorted array of all suffixes of a given string. The definition is similar to Suffix
Tree which is compressed trie of all suffixes of the given text.
Let the given string be "banana".
0 banana 5 a
1 anana Sort the Suffixes 3 ana
2 nana ----------------> 1 anana
3 ana alphabetically 0 banana
4 na 4 na
5 a 2 nana
The suffix array for "banana" is {5, 3, 1, 0, 4, 2}

We have discussed Naive algorithm for construction of suffix array. The Naive algorithm is to consider all
suffixes, sort them using a O(nLogn) sorting algorithm and while sorting, maintain original indexes. Time
complexity of the Naive algorithm is O(n2Logn) where n is the number of characters in the input string.
In this post, a O(nLogn) algorithm for suffix array construction is discussed. Let us first discuss a O(n *
Logn * Logn) algorithm for simplicity. The idea is to use the fact that strings that are to be sorted are suffixes
of a single string.
We first sort all suffixes according to first character, then according to first 2 characters, then first 4
characters and so on while the number of characters to be considered is smaller than 2n. The important
point is, if we have sorted suffixes according to first 2i characters, then we can sort suffixes according to first
2i+1 characters in O(nLogn) time using a nLogn sorting algorithm like Merge Sort. This is possible as two
suffixes can be compared in O(1) time (we need to compare only two values, see the below example and
code).
The sort function is called O(Logn) times (Note that we increase number of characters to be considered in
powers of 2). Therefore overall time complexity becomes O(nLognLogn). See
http://www.stanford.edu/class/cs97si/suffix-array.pdf for more details.
Let us build suffix array the example string “banana” using above algorithm.
Sort according to first two characters Assign a rank to all suffixes using ASCII value of first character.
A simple way to assign rank is to do “str[i] – ‘a'” for ith suffix of strp[]
Index Suffix Rank

0 banana 1
1 anana 0
2 nana 13
3 ana 0
4 na 13
5 a 0

For every character, we also store rank of next adjacent character, i.e., the rank of character at str[i + 1] (This
is needed to sort the suffixes according to first 2 characters). If a character is last character, we store next
rank as -1

Index Suffix Rank Next Rank

0 banana 1 0
1 anana 0 13
2 nana 13 0
3 ana 0 13
4 na 13 0
5 a 0 -1

Sort all Suffixes according to rank and adjacent rank. Rank is considered as first digit or MSD, and adjacent
rank is considered as second digit.

5 a 0 -1
1 anana 0 13
3 ana 0 13
0 banana 1 0
2 nana 13 0
4 na 13 0

Sort according to first four character

Assign new ranks to all suffixes. To assign new ranks, we consider the sorted suffixes one by one. Assign 0 as
new rank to first suffix. For assigning ranks to remaining suffixes, we consider rank pair of suffix just before
the current suffix. If previous rank pair of a suffix is same as previous rank of suffix just before it, then assign
it same rank. Otherwise assign rank of previous suffix plus one.
Index Suffix Rank

5 a 0 [Assign 0 to first]
1 anana 1 (0, 13) is different from previous
3 ana 1 (0, 13) is same as previous
0 banana 2 (1, 0) is different from previous
2 nana 3 (13, 0) is different from previous
4 na 3 (13, 0) is same as previous

For every suffix str[i], also store rank of next suffix at str[i + 2]. If there is no next suffix at i + 2, we store next
rank as -1

5 a 0 -1
1 anana 1 1
3 ana 1 0
0 banana 2 3
2 nana 3 3
4 na 3 -1

Sort all Suffixes according to rank and next rank.

5 a 0 -1
3 ana 1 0
1 anana 1 1
0 banana 2 3
4 na 3 -1
2 nana 3 3

// C++ program for building suffix array of a given text

#include <iostream>
#include <cstring>
// Structure to store information of a suffix

struct suffix
{
int index; // To store original index
int rank[2]; // To store ranks and next rank pair
};
// A comparison function used by sort() to compare two suffixes

// Compares two pairs, returns 1 if first pair is smaller
int cmp(struct suffix a, struct suffix b)
{
return (a.rank[0] == b.rank[0])? (a.rank[1] < b.rank[1] ?1: 0):
(a.rank[0] < b.rank[0] ?1: 0);
}
// This is the main function that takes a string 'txt' of size n as an

// argument, builds and return the suffix array for the given string
int *buildSuffixArray(char *txt, int n)
{
struct suffix suffixes[n];
// Store suffixes and their indexes in an array of structures.

// The structure is needed to sort the suffixes alphabatically
// and maintain their old indexes while sorting
for (int i = 0; i < n; i++)
{
suffixes[i].index = i;
suffixes[i].rank[0] = txt[i] - 'a';
suffixes[i].rank[1] = ((i+1) < n)? (txt[i + 1] - 'a'): -1;
}
// Sort the suffixes using the comparison function

// defined above.
// At his point, all suffixes are sorted according to first

// 2 characters. Let us sort suffixes according to first 4
// characters, then first 8 and so on
int ind[n]; // This array is needed to get the index in suffixes[]
// from original index. This mapping is needed to get
// from original index. This mapping is needed to get
// next suffix.
for (int k = 4; k < 2*n; k = k*2)
{
// Assigning rank and index values to first suffix
int rank = 0;
int prev_rank = suffixes[0].rank[0];
suffixes[0].rank[0] = rank;
ind[suffixes[0].index] = 0;
// Assigning rank to suffixes

for (int i = 1; i < n; i++)
{
// If first rank and next ranks are same as that of previous
// suffix in array, assign the same new rank to this suffix
if (suffixes[i].rank[0] == prev_rank &&
suffixes[i].rank[1] == suffixes[i-1].rank[1])
{
prev_rank = suffixes[i].rank[0];
suffixes[i].rank[0] = rank;
}
else // Otherwise increment rank and assign
{
prev_rank = suffixes[i].rank[0];
suffixes[i].rank[0] = ++rank;
}
ind[suffixes[i].index] = i;
}
// Assign next rank to every suffix

for (int i = 0; i < n; i++)
{
int nextindex = suffixes[i].index + k/2;
suffixes[i].rank[1] = (nextindex < n)?
suffixes[ind[nextindex]].rank[0]: -1;
}
// Sort the suffixes according to first k characters

}
// Store indexes of all sorted suffixes in the suffix array

int *suffixArr = new int[n];
for (int i = 0; i < n; i++)
suffixArr[i] = suffixes[i].index;
// Return the suffix array

return suffixArr;
}
// A utility function to print an array of given size

{
for (int i = 0; i < n; i++)
cout << arr[i] << " ";
cout << endl;
}

int main()
{
char txt[] = "banana";
int *suffixArr = buildSuffixArray(txt, n);
printArr(suffixArr, n);
return 0;
}

Output:

Following is suffix array for banana
5 3 1 0 4 2

Note that the above algorithm uses standard sort function and therefore time complexity is O(nLognLogn).
We can use Radix Sort here to reduce the time complexity to O(nLogn).
Please note that suffx arrays can be constructed in O(n) time also. We will soon be discussing O(n)
algorithms.
References:
http://www.stanford.edu/class/cs97si/suffix-array.pdf
http://www.cbcb.umd.edu/confcour/Fall2012/lec14b.pdf
discussed above.
Print a Binary Tree in Vertical Order | Set 2 (Hashmap based Method)
Given a binary tree, print it vertically. The following example illustrates vertical order traversal.
1
/ \
2 3
/ \ / \
4 5 6 7
\ \
8 9

The output of print this tree vertically will be:
4
2
1 5 6
3 8
7
9

We have discussed a O(n2) solution in the previous post. In this post, an efficient solution based on hash
map is discussed. We need to check the Horizontal Distances from root for all nodes. If two nodes have the
same Horizontal Distance (HD), then they are on same vertical line. The idea of HD is simple. HD for root is
0, a right edge (edge connecting to right subtree) is considered as +1 horizontal distance and a left edge is
considered as -1 horizontal distance. For example, in the above tree, HD for Node 4 is at -2, HD for Node 2 is
-1, HD for 5 and 6 is 0 and HD for node 7 is +2.
We can do inorder traversal of the given Binary Tree. While traversing the tree, we can recursively calculate
HDs. We initially pass the horizontal distance as 0 for root. For left subtree, we pass the Horizontal Distance
as Horizontal distance of root minus 1. For right subtree, we pass the Horizontal Distance as Horizontal
Distance of root plus 1. For every HD value, we maintain a list of nodes in a hasp map. Whenever we see a
node in traversal, we go to the hash map entry and add the node to the hash map using HD as a key in map.
Following is C++ implementation of the above method. Thanks to Chirag for providing the below C++
implementation.
// C++ program for printing vertical order of a given binary tree

#include <iostream>
#include <vector>
#include <map>
// Structure for a binary tree node

struct Node
{
int key;
Node *left, *right;
};

struct Node* newNode(int key)
{
struct Node* node = new Node;
node->key = key;
return node;
}
// Utility function to store vertical order in map 'm'

// 'hd' is horigontal distance of current node from root.
// 'hd' is initally passed as 0
void getVerticalOrder(Node* root, int hd, map<int, vector<int>> &m)
{
// Base case
if (root == NULL)
return;
// Store current node in map 'm'

m[hd].push_back(root->key);
// Store nodes in left subtree

getVerticalOrder(root->left, hd-1, m);
// Store nodes in right subtree

getVerticalOrder(root->right, hd+1, m);
}
// The main function to print vertical oder of a binary tree

// with given root
void printVerticalOrder(Node* root)
{
// Create a map and store vertical oder in map using
// function getVerticalOrder()
map < int,vector<int> > m;
int hd = 0;
getVerticalOrder(root, hd,m);
// Traverse the map and print nodes at every horigontal

// distance (hd)
map< int,vector<int> > :: iterator it;
for (it=m.begin(); it!=m.end(); it++)
{
for (int i=0; i<it->second.size(); ++i)
cout << it->second[i] << " ";
cout << endl;
}
}

int main()
{
cout << "Vertical order traversal is \n";
printVerticalOrder(root);
return 0;
}

Output:

Vertical order traversal is
4
2
1 5 6
3 8
7
9

Time Complexity of hashing based solution can be considered as O(n) under the assumption that we have
good hashing function that allows insertion and retrieval operations in O(1) time. In the above C++
implementation, map of STL is used. map in STL is typically implemented using a Self-Balancing Binary
Search Tree where all operations take O(Logn) time. Therefore time complexity of above implementation is
O(nLogn).
discussed above
Kth smallest element in a row-wise and column-wise sorted 2D array | Set 1
Given an n x n matrix, where every row and column is sorted in non-decreasing order. Find the kth smallest
element in the given 2D array.
For example, consider the following 2D array.
10, 20, 30, 40

15, 25, 35, 45
24, 29, 37, 48
32, 33, 39, 50
The 3rd smallest element is 20 and 7th smallest element is 30

The idea is to use min heap. Following are detailed step.

1) Build a min heap of elements from first row. A heap entry also stores row number and column number.
2) Do following k times.
…a) Get minimum element (or root) from min heap.
…b) Find row number and column number of the minimum element.
…c) Replace root with the next element from same column and min-heapify the root.
3) Return the last extracted root.
// kth largest element in a 2d array sorted row-wise and column-wise

#include<iostream>
#include<climits>
// A structure to store an entry of heap. The entry contains

// a value from 2D array, row and column numbers of the value
struct HeapNode {
int val; // value to be stored
int r; // Row number of value in 2D array
int c; // Column number of value in 2D array
};
// A utility function to swap two HeapNode items.

void swap(HeapNode *x, HeapNode *y) {
HeapNode z = *x;
*x = *y;
*y = z;
}
// A utility function to minheapify the node harr[i] of a heap

// stored in harr[]
void minHeapify(HeapNode harr[], int i, int heap_size)
{
int l = i*2 + 1;
int r = i*2 + 2;
int smallest = i;
if (l < heap_size && harr[l].val < harr[i].val)
smallest = l;
if (r < heap_size && harr[r].val < harr[smallest].val)
smallest = r;
smallest = r;
if (smallest != i)
{
minHeapify(harr, smallest, heap_size);
}
}
// A utility function to convert harr[] to a max heap

void buildHeap(HeapNode harr[], int n)
{
int i = (n - 1)/2;
while (i >= 0)
{
minHeapify(harr, i, n);
i--;
}
}
// This function returns kth smallest element in a 2D array mat[][]

int kthSmallest(int mat[4][4], int n, int k)
{
// k must be greater than 0 and smaller than n*n
if (k <= 0 || k > n*n)
return INT_MAX;
// Create a min heap of elements from first row of 2D array

HeapNode harr[n];
for (int i = 0; i < n; i++)
harr[i] = {mat[0][i], 0, i};
buildHeap(harr, n);
HeapNode hr;
for (int i = 0; i < k; i++)
{
// Get current heap root
hr = harr[0];
// Get next value from column of root's value. If the

// value stored at root was last value in its column,
// then assign INFINITE as next value
int nextval = (hr.r < (n-1))? mat[hr.r + 1][hr.c]: INT_MAX;
// Update heap root with next value

harr[0] = {nextval, (hr.r) + 1, hr.c};
// Heapify root
minHeapify(harr, 0, n);
}
// Return the value at last extracted root

return hr.val;
}

int main()
{
int mat[4][4] = { {10, 20, 30, 40},
{15, 25, 35, 45},
{25, 29, 37, 48},
{32, 33, 39, 50},
};
cout << "7th smallest element is " << kthSmallest(mat, 4, 7);
return 0;
}
}

Output:

7th smallest element is 30

Time Complexity: The above solution involves following steps.

1) Build a min heap which takes O(n) time
2) Heapify k times which takes O(kLogn) time.
Therefore, overall time complexity is O(n + kLogn) time.
The above code can be optimized to build a heap of size k when k is smaller than n. In that case, the kth
smallest element must be in first k rows and k columns.
We will soon be publishing more efficient algorithms for finding the kth smallest element.
This article is compiled by Ravi Gupta. Please write comments if you find anything incorrect, or you want to
G-Fact 18
Finding nth Fibonacci Number using Golden Ratio:
We have discussed different methods to find nth Fibonacci Number.
Following is another mathematically correct way to find the same.
nth Fibonacci Number Fn =
Here φ is golden ratio with value as
The above formula seems to be good for finding nth Fibonacci Number in O(Logn) time as integer power of
a number can be calculated in O(Logn) time. But this solution doesn’t work practically because φ is stored as
a floating point number and when we calculate powers of φ, important bits may be lost in the process and we
may get incorrect answer.
References:
https://www.youtube.com/watch?v=-EQTVuAhSFY
http://en.wikipedia.org/wiki/Fibonacci_number
discussed above.
Printing Longest Common Subsequence
Given two sequences, print the longest subsequence present in both of them.
Examples:
LCS for input Sequences “ABCDGH” and “AEDFHR” is “ADH” of length 3.
LCS for input Sequences “AGGTAB” and “GXTXAYB” is “GTAB” of length 4.
We have discussed Longest Common Subsequence (LCS) problem in a previous post. The function discussed
there was mainly to find the length of LCS. To find length of LCS, a 2D table L[][] was constructed. In this
post, the function to construct and print LCS is discussed.
Following is detailed algorithm to print the LCS. It uses the same 2D table L[][].
1) Construct L[m+1][n+1] using the steps discussed in previous post.
2) The value L[m][n] contains length of LCS. Create a character array lcs[] of length equal to the length of
lcs plus 1 (one extra to store \0).
2) Traverse the 2D array starting from L[m][n]. Do following for every cell L[i][j]
…..a) If characters (in X and Y) corresponding to L[i][j] are same (Or X[i-1] == Y[j-1]), then include this
character as part of LCS.
…..b) Else compare values of L[i-1][j] and L[i][j-1] and go in direction of greater value.
The following table (taken from Wiki) shows steps (highlighted) followed by the above algorithm.
01 234 5 6 7
ØMZJAWXU
0Ø 00 0 00 0 0 0
1 X 0 0 0 00 0 1 1
2M0 1 1 1 1 1 1 1
3J 0 1 1 22 2 2 2
4Y 0 1 1 22 2 2 2
5 A 0 1 1 23 3 3 3
6U 0 1 1 23 3 3 4
7 Z 0 1 2 23 3 3 4

/* Dynamic Programming implementation of LCS problem */

#include<iostream>
#include<cstring>
#include<cstdlib>

void lcs( char *X, char *Y, int m, int n )
{
int L[m+1][n+1];

for (int i=0; i<=m; i++)
{
{
if (i == 0 || j == 0)
if (i == 0 || j == 0)
L[i][j] = 0;
else if (X[i-1] == Y[j-1])
L[i][j] = L[i-1][j-1] + 1;
else
L[i][j] = max(L[i-1][j], L[i][j-1]);
}
}
// Following code is used to print LCS

int index = L[m][n];
// Create a character array to store the lcs string

char lcs[index+1];
lcs[index] = '\0'; // Set the terminating character
// Start from the right-most-bottom-most corner and

// one by one store characters in lcs[]
int i = m, j = n;
while (i > 0 && j > 0)
{
// If current character in X[] and Y are same, then
// current character is part of LCS
if (X[i-1] == Y[j-1])
{
lcs[index-1] = X[i-1]; // Put current character in result
i--; j--; index--; // reduce values of i, j and index
}
// If not same, then find the larger of two and

// go in the direction of larger value
else if (L[i-1][j] > L[i][j-1])
i--;
else
j--;
}
// Print the lcs

cout << "LCS of " << X << " and " << Y << " is " << lcs;
}

int main()
{
int m = strlen(X);
int n = strlen(Y);
lcs(X, Y, m, n);
return 0;
}

Output:

LCS of AGGTAB and GXTXAYB is GTAB

References:
http://en.wikipedia.org/wiki/Longest_common_subsequence_problem
discussed above
Bucket Sort
Bucket sort is mainly useful when input is uniformly distributed over a range. For example, consider the
following problem.
Sort a large set of floating point numbers which are in range from 0.0 to 1.0 and are uniformly distributed
across the range. How do we sort the numbers efficiently?
A simple way is to apply a comparison based sorting algorithm. The lower bound for Comparison based
sorting algorithm (Merge Sort, Heap Sort, Quick-Sort .. etc) is
, i.e., they cannot do better than nLogn.

Can we sort the array in linear time? Counting sort can not be applied here as we use keys as index in
counting sort. Here keys are floating point numbers.
The idea is to use bucket sort. Following is bucket algorithm.
bucketSort(arr[], n)
1) Create n empty buckets (Or lists).
2) Do following for every array element arr[i].
.......a) Insert arr[i] into bucket[n*array[i]]
3) Sort individual buckets using insertion sort.
4) Concatenate all sorted buckets.

Following diagram (taken from CLRS book) demonstrates working of bucket sort.
Time Complexity: If we assume that insertion in a bucket takes O(1) time then steps 1 and 2 of the above
algorithm clearly take O(n) time. The O(1) is easily possible if we use a linked list to represent a bucket (In
the following code, C++ vector is used for simplicity). Step 4 also takes O(n) time as there will be n items in
all buckets.
The main step to analyze is step 3. This step also takes O(n) time on average if all numbers are uniformly
distributed (please refer CLRS book for more details)

// C++ program to sort an array using bucket sort

#include <iostream>
#include <vector>
// Function to sort arr[] of size n using bucket sort

void bucketSort(float arr[], int n)
{
// 1) Create n empty buckets
vector<float> b[n];

// 2) Put array elements in different buckets
{
int bi = n*arr[i]; // Index in bucket
b[bi].push_back(arr[i]);
}
// 3) Sort individual buckets

sort(b[i].begin(), b[i].end());
// 4) Concatenate all buckets into arr[]

int index = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < b[i].size(); j++)
arr[index++] = b[i][j];
}
/* Driver program to test above funtion */

int main()
{
float arr[] = {0.897, 0.565, 0.656, 0.1234, 0.665, 0.3434};
bucketSort(arr, n);
cout << "Sorted array is \n";

cout << arr[i] << " ";
return 0;
}

Output:

Sorted array is
0.1234 0.3434 0.565 0.656 0.665 0.897

References:
L. Rivest
http://en.wikipedia.org/wiki/Bucket_sort
discussed above
Divide and Conquer | Set 6 (Search in a Row-wise and Column-wise Sorted
2D Array)
Given an n x n matrix, where every row and column is sorted in increasing order. Given a key, how to decide
whether this key is in the matrix.
A linear time complexity is discussed in the previous post. This problem can also be a very good example for
divide and conquer algorithms. Following is divide and conquer algorithm.
1) Find the middle element.

2) If middle element is same as key return.
3) If middle element is lesser than key then
….3a) search submatrix on lower side of middle element
….3b) Search submatrix on right hand side.of middle element
4) If middle element is greater than key then
….4a) search vertical submatrix on left side of middle element
….4b) search submatrix on right hand side.
Following Java implementation of above algorithm.
// Java program for implementation of divide and conquer algorithm

// to find a given key in a row-wise and column-wise sorted 2D array
class SearchInMatrix
{
{
{
int[][] mat = new int[][] { {10, 20, 30, 40},
{15, 25, 35, 45},
{27, 29, 37, 48},
{32, 33, 39, 50}};
int rowcount = 4,colCount=4,key=50;
for (int i=0; i<rowcount; i++)
for (int j=0; j<colCount; j++)
search(mat, 0, rowcount-1, 0, colCount-1, mat[i][j]);
}
// A divide and conquer method to search a given key in mat[]

// in rows from fromRow to toRow and columns from fromCol to
// toCol
public static void search(int[][] mat, int fromRow, int toRow,
int fromCol, int toCol, int key)
{
// Find middle and compare with middle
int i = fromRow + (toRow-fromRow )/2;
int j = fromCol + (toCol-fromCol )/2;
if (mat[i][j] == key) // If key is present at middle
System.out.println("Found "+ key + " at "+ i +
" " + j);
else
{
// right-up quarter of matrix is searched in all cases.
// Provided it is different from current call
if (i!=toRow || j!=fromCol)
search(mat,fromRow,i,j,toCol,key);
// Special case for iteration with 1*2 matrix

// mat[i][j] and mat[i][j+1] are only two elements.
// So just check second element
if (fromRow == toRow && fromCol + 1 == toCol)
if (mat[fromRow][toCol] == key)
System.out.println("Found "+ key+ " at "+
fromRow + " " + toCol);
// If middle key is lesser then search lower horizontal

// matrix and right hand side matrix
if (mat[i][j] < key)
{
// search lower horizontal if such matrix exists
if (i+1<=toRow)
search(mat, i+1, toRow, fromCol, toCol, key);
}
// If middle key is greater then search left vertical

// matrix and right hand side matrix
else
{
// search left vertical if such matrix exists
if (j-1>=fromCol)
search(mat, fromRow, toRow, fromCol, j-1, key);
}
}
}
}

Time complexity:
We are given a n*n matrix, the algorithm can be seen as recurring for 3 matrices of size n/2 x n/2. Following
is recurrence for time complexity
T(n) = 3T(n/2) + O(1)

The solution of recurrence is O(n1.58) using Master Method.

But the actual implementation calls for one submatrix of size n x n/2 or n/2 x n, and other submatrix of size
n/2 x n/2.
This article is contributed by Kaushik Lele. Please write comments if you find anything incorrect, or you
Print all possible words from phone digits
Before advent of QWERTY keyboards, texts and numbers were placed on the same key. For example 2 has
“ABC” if we wanted to write anything starting with ‘A’ we need to type key 2 once. If we wanted to type ‘B’,
press key 2 twice and thrice for typing ‘C’. below is picture of such keypad.
Given a keypad as shown in diagram, and a n digit number, list all words which are possible
by pressing these numbers.
For example if input number is 234, possible words which can be formed are (Alphabetical order):
adg adh adi aeg aeh aei afg afh afi bdg bdh bdi beg beh bei bfg bfh bfi cdg cdh cdi ceg ceh cei cfg cfh cfi
Let’s do some calculations first. How many words are possible with seven digits with each digit representing
n letters? For first digit we have at most four choices, and for each choice for first letter, we have at most four
choices for second digit and so on. So it’s simple maths it will be O(4n). Since keys 0 and 1 don’t have any
corresponding alphabet and many characters have 3 characters, 4n would be the upper bound of number of
words and not the minimum words.
Now let’s do some examples.

For number above 234. Do you see any pattern? Yes, we notice that the last character always either G,H or I
and whenever it resets its value from I to G, the digit at the left of it gets changed.
Similarly whenever the second last alphabet resets its value, the third last alphabet gets changes and so on.
First character resets only once when we have generated all words. This can be looked from other end also.
That is to say whenever character at position i changes, character at position i+1 goes through all possible
characters and it creates ripple effect till we reach at end.
Since 0 and 1 don’t have any characters associated with them. we should break as there will no iteration for
these digits.
Let’s take the second approach as it will be easy to implement it using recursion. We go till the end and come
back one by one. Perfect condition for recursion. let’s search for base case.
When we reach at the last character, we print the word with all possible characters for last digit and return.
Simple base case.
When we reach at the last character, we print the word with all possible characters for last digit and return.
Simple base case.
Following is C implementation of recursive approach to print all possible word corresponding to a n digit
input number. Note that input number is represented as an array to simplify the code.

#include <stdio.h>
#include <string.h>
// hashTable[i] stores all characters that correspond to digit i in phone

const char hashTable[10][5] = {"", "", "abc", "def", "ghi", "jkl",
"mno", "pqrs", "tuv", "wxyz"};
// A recursive function to print all possible words that can be obtained

// by input number[] of size n. The output words are one by one stored
// in output[]
void printWordsUtil(int number[], int curr_digit, char output[], int n)
{
// Base case, if current output word is prepared
int i;
if (curr_digit == n)
{
printf("%s ", output);
return ;
}
// Try all 3 possible characters for current digir in number[]

// and recur for remaining digits
for (i=0; i<strlen(hashTable[number[curr_digit]]); i++)
{
output[curr_digit] = hashTable[number[curr_digit]][i];
printWordsUtil(number, curr_digit+1, output, n);
if (number[curr_digit] == 0 || number[curr_digit] == 1)
return;
}
}
// A wrapper over printWordsUtil(). It creates an output array and

// calls printWordsUtil()
void printWords(int number[], int n)
{
char result[n+1];
result[n] ='\0';
printWordsUtil(number, 0, result, n);
}
//Driver program
int main(void)
{
int number[] = {2, 3, 4};
int n = sizeof(number)/sizeof(number[0]);
printWords(number, n);
return 0;
}

Output:

adg adh adi aeg aeh aei afg afh afi bdg
bdh bdi beg beh bei bfg bfh bfi cdg cdh
cdi ceg ceh cei cfg cfh cfi
Process returned 0 (0x0) execution time : 0.025 s
Press any key to continue.

Time Complexity: Time complexity of above code is O(4n) where n is number of digits in input number.
Reference:
Buy Programming Interviews Exposed: Secrets to Landing Your Next Job 3rd Edition from Flipkart.com
This article is contributed by Jitendra Sangar. Please write comments if you find anything incorrect, or
Remove minimum elements from either side such that 2*min becomes
more than max
Given an unsorted array, trim the array such that twice of minimum is greater than maximum in the
trimmed array. Elements should be removed either end of the array.
Number of removals should be minimum.
Examples:
arr[] = {4, 5, 100, 9, 10, 11, 12, 15, 200}

Output: 4
We need to remove 4 elements (4, 5, 100, 200)
so that 2*min becomes more than max.
arr[] = {4, 7, 5, 6}
Output: 0
We don't need to remove any element as
4*2 > 7 (Note that min = 4, max = 8)
arr[] = {20, 7, 5, 6}
Output: 1
We need to remove 20 so that 2*min becomes
more than max
arr[] = {20, 4, 1, 3}
Output: 3
We need to remove any three elements from ends
like 20, 4, 1 or 4, 1, 3 or 20, 3, 1 or 20, 4, 1

Naive Solution:
A naive solution is to try every possible case using recurrence. Following is the naive recursive algorithm.
Note that the algorithm only returns minimum numbers of removals to be made, it doesn’t print the
trimmed array. It can be easily modified to print the trimmed array as well.
// Returns minimum number of removals to be made in

// arr[l..h]
minRemovals(int arr[], int l, int h)
1) Find min and max in arr[l..h]
2) If 2*min > max, then return 0.
3) Else return minimum of "minRemovals(arr, l+1, h) + 1"
and "minRemovals(arr, l, h-1) + 1"


#include <iostream>

int min(int a, int b) {return (a < b)? a : b;}
// A utility function to find minimum in arr[l..h]

int min(int arr[], int l, int h)
{
int mn = arr[l];
for (int i=l+1; i<=h; i++)
if (mn > arr[i])
mn = arr[i];
return mn;
}
// A utility function to find maximum in arr[l..h]

int max(int arr[], int l, int h)
{
int mx = arr[l];
if (mx < arr[i])
mx = arr[i];
return mx;
}
// Returns the minimum number of removals from either end

// in arr[l..h] so that 2*min becomes greater than max.
int minRemovals(int arr[], int l, int h)
{
// If there is 1 or less elements, return 0
// For a single element, 2*min > max
// (Assumption: All elements are positive in arr[])
if (l >= h) return 0;
// 1) Find minimum and maximum in arr[l..h]

int mn = min(arr, l, h);
int mx = max(arr, l, h);
//If the property is followed, no removals needed

if (2*mn > mx)
return 0;
// Otherwise remove a character from left end and recur,

// then remove a character from right end and recur, take
// the minimum of two is returned
return min(minRemovals(arr, l+1, h),
minRemovals(arr, l, h-1)) + 1;
}

int main()
{
int arr[] = {4, 5, 100, 9, 10, 11, 12, 15, 200};
cout << minRemovals(arr, 0, n-1);
return 0;
}

Output:
Time complexity: Time complexity of the above function can be written as following

T(n) = 2T(n-1) + O(n)

An upper bound on solution of above recurrence would be O(n x 2n).
Dynamic Programming:
The above recursive code exhibits many overlapping subproblems. For example minRemovals(arr, l+1, h-1)
is evaluated twice. So Dynamic Programming is the choice to optimize the solution. Following is Dynamic
Programming based solution.

#include <iostream>

int min(int a, int b) {return (a < b)? a : b;}
// A utility function to find minimum in arr[l..h]

int min(int arr[], int l, int h)
{
int mn = arr[l];
if (mn > arr[i])
mn = arr[i];
return mn;
}
// A utility function to find maximum in arr[l..h]

int max(int arr[], int l, int h)
{
int mx = arr[l];
if (mx < arr[i])
mx = arr[i];
return mx;
}

int minRemovalsDP(int arr[], int n)
{
// Create a table to store solutions of subproblems
int table[n][n], gap, i, j, mn, mx;
// is filled in diagonal fashion (similar to http://goo.gl/PQqoS),
// from diagonal elements to table[0][n-1] which is the result.
{
for (i = 0, j = gap; j < n; ++i, ++j)
{
mn = min(arr, i, j);
mx = max(arr, i, j);
table[i][j] = (2*mn > mx)? 0: min(table[i][j-1]+1,
table[i+1][j]+1);
}
}
}

int main()
{
int arr[] = {20, 4, 1, 3};
cout << minRemovalsDP(arr, n);
return 0;
}

Time Complexity: O(n3) where n is the number of elements in arr[].

Further Optimizations:
The above code can be optimized in many ways.
1) We can avoid calculation of min() and/or max() when min and/or max is/are not changed by removing
corner elements.
2) We can pre-process the array and build segment tree in O(n) time. After the segment tree is built, we can
query range minimum and maximum in O(Logn) time. The overall time complexity is reduced to O(n2Logn)
time.
A O(n^2) Solution
The idea is to find the maximum sized subarray such that 2*min > max. We run two nested loops, the outer
loop chooses a starting point and the inner loop chooses ending point for the current starting point. We keep
track of longest subarray with the given property.
Following is C++ implementation of the above approach. Thanks to Richard Zhang for suggesting this
solution.

// A O(n*n) solution to find the minimum of elements to

// be removed
#include <iostream>
#include <climits>

int minRemovalsDP(int arr[], int n)
{
// Initialize starting and ending indexes of the maximum
// sized subarray with property 2*min > max
int longest_start = -1, longest_end = 0;
// Choose different elements as starting point

for (int start=0; start<n; start++)
{
// Initialize min and max for the current start
int min = INT_MAX, max = INT_MIN;
// Choose different ending points for current start

for (int end = start; end < n; end ++)
{
// Update min and max if necessary
int val = arr[end];
if (val < min) min = val;
if (val > max) max = val;
// If the property is violated, then no

// point to continue for a bigger array
if (2 * min <= max) break;
// Update longest_start and longest_end if needed

if (end - start > longest_end - longest_start ||
longest_start == -1)
{
longest_start = start;
longest_end = end;
}
}
}
// If not even a single element follow the property,

// then return n
if (longest_start == -1) return n;
// Return the number of elements to be removed

return (n - (longest_end - longest_start + 1));
}

int main()
{
int arr[] = {4, 5, 100, 9, 10, 11, 12, 15, 200};
cout << minRemovalsDP(arr, n);
return 0;
}

This article is contributed by Rahul Jain. Please write comments if you find anything incorrect, or you
Program for nth Catalan Number
Catalan numbers are a sequence of natural numbers that occurs in many interesting counting problems like
following.
1) Count the number of expressions containing n pairs of parentheses which are correctly matched. For n =
3, possible expressions are ((())), ()(()), ()()(), (())(), (()()).
2) Count the number of possible Binary Search Trees with n keys (See this)
3) Count the number of full binary trees (A rooted binary tree is full if every vertex has either two children or
no children) with n+1 leaves.
See this for more applications.
The first few Catalan numbers for n = 0, 1, 2, 3, … are 1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, …
Recursive Solution
Catalan numbers satisfy the following recursive formula.
Following is C++ implementation of above recursive formula.
#include<iostream>
// A recursive function to find nth catalan number

unsigned long int catalan(unsigned int n)
{
// Base case
if (n <= 1) return 1;
// catalan(n) is sum of catalan(i)*catalan(n-i-1)

unsigned long int res = 0;
res += catalan(i)*catalan(n-i-1);
return res;
}

int main()
{
for (int i=0; i<10; i++)
cout << catalan(i) << " ";
return 0;
}

Output :

1 1 2 5 14 42 132 429 1430 4862

Time complexity of above implementation is equivalent to nth catalan number.

The value of nth catalan number is exponential that makes the time complexity exponential.

We can observe that the above recursive implementation does a lot of repeated work (we can the same by
drawing recursion tree). Since there are overlapping subproblems, we can use dynamic programming for
this. Following is a Dynamic programming based implementation in C++.
#include<iostream>
// A dynamic programming based function to find nth

// Catalan number
unsigned long int catalanDP(unsigned int n)
{
// Table to store results of subproblems
unsigned long int catalan[n+1];
// Initialize first two values in table

catalan[0] = catalan[1] = 1;
// Fill entries in catalan[] using recursive formula

for (int i=2; i<=n; i++)
{
catalan[i] = 0;
for (int j=0; j<i; j++)
catalan[i] += catalan[j] * catalan[i-j-1];
}
// Return last entry

return catalan[n];
}

int main()
{
for (int i = 0; i < 10; i++)
cout << catalanDP(i) << " ";
return 0;
}

Output:

1 1 2 5 14 42 132 429 1430 4862

Time Complexity: Time complexity of above implementation is O(n2)
Using Binomial Coefficient

We can also use the below formula to find nth catalan number in O(n) time.
We have discussed a O(n) approach to find binomial coefficient nCr.

#include<iostream>

unsigned long int binomialCoeff(unsigned int n, unsigned int k)
{
unsigned long int res = 1;
// Since C(n, k) = C(n, n-k)

if (k > n - k)
k = n - k;
// Calculate value of [n*(n-1)*---*(n-k+1)] / [k*(k-1)*---*1]

for (int i = 0; i < k; ++i)
{
res *= (n - i);
res /= (i + 1);
}
return res;
}
// A Binomial coefficient based function to find nth catalan

// number in O(n) time
unsigned long int catalan(unsigned int n)
{
// Calculate value of 2nCn
unsigned long int c = binomialCoeff(2*n, n);
// return 2nCn/(n+1)
return c/(n+1);
}

int main()
{
for (int i = 0; i < 10; i++)
cout << catalan(i) << " ";
return 0;
}

Output:

1 1 2 5 14 42 132 429 1430 4862

Time Complexity: Time complexity of above implementation is O(n).
We can also use below formula to find nth catalan number in O(n) time.
References:
http://en.wikipedia.org/wiki/Catalan_number
discussed above
Count trailing zeroes in factorial of a number
Given an integer n, write a function that returns count of trailing zeroes in n!.
Examples:
Input: n = 5
Output: 1
Factorial of 5 is 20 which has one trailing 0.
Input: n = 20
Output: 4
Factorial of 20 is 2432902008176640000 which has
4 trailing zeroes.
Input: n = 100
Output: 24

A simple method is to first calculate factorial of n, then count trailing 0s in the result (We can count trailing
0s by repeatedly dividing the factorial by 10 till the remainder is 0).
The above method can cause overflow for a slightly bigger numbers as factorial of a number is a big number
(See factorial of 20 given in above examples). The idea is to consider prime factors of a factorial n. A trailing
zero is always produced by prime factors 2 and 5. If we can count the number of 5s and 2s, our task is done.
Consider the following examples.
n = 5: There is one 5 and 3 2s in prime factors of 5! (2 * 2 * 2 * 3 * 5). So count of trailing 0s is 1.
n = 11: There are two 5s and three 2s in prime factors of 11! (2 8 * 34 * 52 * 7). So count of trailing 0s is 2.
We can easily observe that the number of 2s in prime factors is always more than or equal to the number of
5s. So if we count 5s in prime factors, we are done. How to count total number of 5s in prime factors of n!? A
simple way is to calculate floor(n/5). For example, 7! has one 5, 10! has two 5s. It is done yet, there is one
more thing to consider. Numbers like 25, 125, etc have more than one 5. For example if we consider 28!, we
get one extra 5 and number of 0s become 6. Handling this is simple, first divide n by 5 and remove all single
5s, then divide by 25 to remove extra 5s and so on. Following is the summarized formula for counting
trailing 0s.
Trailing 0s in n! = Count of 5s in prime factors of n!

= floor(n/5) + floor(n/25) + floor(n/125) + ....

Following is C++ program based on above formula.

// C++ program to count trailing 0s in n!

#include <iostream>
// Function to return trailing 0s in factorial of n

int findTrailingZeros(int n)
{
int count = 0;
// Keep dividing n by powers of 5 and update count

for (int i=5; n/i>=1; i *= 5)
count += n/i;
return count;
}

int main()
{
int n = 100;
cout << "Count of trailing 0s in " << 100
<< "! is " << findTrailingZeros(n);
return 0;
}

Output:

Count of trailing 0s in 100! is 24

Smallest subarray with sum greater than a given value
Given an array of integers and a number x, find the smallest subarray with sum greater than the given value.
Examples:
arr[] = {1, 4, 45, 6, 0, 19}
x = 51
Output: 3
Minimum length subarray is {4, 45, 6}
arr[] = {1, 10, 5, 2, 7}

x = 9
Output: 1
Minimum length subarray is {10}
arr[] = {1, 11, 100, 1, 0, 200, 3, 2, 1, 250}

x = 280
Output: 4
Minimum length subarray is {100, 1, 0, 200}

A simple solution is to use two nested loops. The outer loop picks a starting element, the inner loop
considers all elements (on right side of current start) as ending element. Whenever sum of elements between
current start and end becomes more than the given number, update the result if current length is smaller
than the smallest length so far.
Following is C++ implementation of simple approach.

# include <iostream>
// Returns length of smallest subarray with sum greater than x.

// If there is no subarray with given sum, then returns n+1
int smallestSubWithSum(int arr[], int n, int x)
{
// Initilize length of smallest subarray as n+1
int min_len = n + 1;
// Pick every element as starting point

for (int start=0; start<n; start++)
{
// Initialize sum starting with current start
int curr_sum = arr[start];
// If first element itself is greater

if (curr_sum > x) return 1;
// Try different ending points for curremt start

for (int end=start+1; end<n; end++)
{
// add last element to current sum
curr_sum += arr[end];
// If sum becomes more than x and length of

// this subarray is smaller than current smallest
// length, update the smallest length (or result)
if (curr_sum > x && (end - start + 1) < min_len)
min_len = (end - start + 1);
}
}
return min_len;
}

int main()
{
int arr1[] = {1, 4, 45, 6, 10, 19};
int x = 51;
cout << smallestSubWithSum(arr1, n1, x) << endl;
int arr2[] = {1, 10, 5, 2, 7};

x = 9;
int arr3[] = {1, 11, 100, 1, 0, 200, 3, 2, 1, 250};

x = 280;
return 0;
}

Output:

3
1
4

Time Complexity: Time complexity of the above approach is clearly O(n2).
Efficient Solution: This problem can be solved in O(n) time using the idea used in this post. Thanks to
Ankit and Nitin for suggesting this optimized solution.

// O(n) solution for finding smallest subarray with sum

// greater than x
#include <iostream>
// Returns length of smallest subarray with sum greater than x.

// If there is no subarray with given sum, then returns n+1
int smallestSubWithSum(int arr[], int n, int x)
{
// Initialize current sum and minimum length
int curr_sum = 0, min_len = n+1;
// Initialize starting and ending indexes

int start = 0, end = 0;
while (end < n)
{
// Keep adding array elements while current sum
// is smaller than x
while (curr_sum <= x && end < n)
curr_sum += arr[end++];
// If current sum becomes greater than x.

while (curr_sum > x && start < n)
{
// Update minimum length if needed
if (end - start < min_len)
min_len = end - start;
// remove starting elements

curr_sum -= arr[start++];
}
}
return min_len;
}

int main()
{
int arr1[] = {1, 4, 45, 6, 10, 19};
int x = 51;
int arr2[] = {1, 10, 5, 2, 7};

x = 9;
int arr3[] = {1, 11, 100, 1, 0, 200, 3, 2, 1, 250};

x = 280;
cout << smallestSubWithSum(arr3, n3, x);
return 0;
}

Output:

3
1
4

Create a matrix with alternating rectangles of O and X
Write a code which inputs two numbers m and n and creates a matrix of size m x n (m rows and n columns)
in which every elements is either X or 0. The Xs and 0s must be filled alternatively, the matrix should have
outermost rectangle of Xs, then a rectangle of 0s, then a rectangle of Xs, and so on.
Examples:
Input: m = 3, n = 3
Output: Following matrix
X X X
X 0 X
X X X
Input: m = 4, n = 5
X X X X X
X 0 0 0 X
X 0 0 0 X
X X X X X
Input: m = 5, n = 5
X X X X X
X 0 0 0 X
X 0 X 0 X
X 0 0 0 X
X X X X X
Input: m = 6, n = 7
X X X X X X X
X 0 0 0 0 0 X
X 0 X X X 0 X
X 0 X X X 0 X
X 0 0 0 0 0 X
X X X X X X X

This question was asked in campus recruitment of Shreepartners Gurgaon. I followed the following
approach.
1) Use the code for Printing Matrix in Spiral form.

2) Instead of printing the array, inserted the element ‘X’ or ‘0’ alternatively in the array.
#include <stdio.h>
// Function to print alternating rectangles of 0 and X

void fill0X(int m, int n)
{
/* k - starting row index
l - starting column index
i - iterator */
int i, k = 0, l = 0;
// Store given number of rows and columns for later use

int r = m, c = n;
// A 2D array to store the output to be printed

char a[m][n];
char x = 'X'; // Iniitialize the character to be stoed in a[][]
// Fill characters in a[][] in spiral form. Every iteration fills

// one rectangle of either Xs or Os
while (k < m && l < n)
{
/* Fill the first row from the remaining rows */
for (i = l; i < n; ++i)
a[k][i] = x;
k++;
/* Fill the last column from the remaining columns */

for (i = k; i < m; ++i)
a[i][n-1] = x;
n--;
/* Fill the last row from the remaining rows */

if (k < m)
{
for (i = n-1; i >= l; --i)
a[m-1][i] = x;
m--;
}
/* Print the first column from the remaining columns */

if (l < n)
{
for (i = m-1; i >= k; --i)
a[i][l] = x;
l++;
}
// Flip character for next iteration

x = (x == '0')? 'X': '0';
}
// Print the filled matrix

for (i = 0; i < r; i++)
{
for (int j = 0; j < c; j++)
printf("%c ", a[i][j]);
printf("\n");
}
}

int main()
{
puts("Output for m = 5, n = 6");
fill0X(5, 6);
puts("\nOutput for m = 4, n = 4");

fill0X(4, 4);
puts("\nOutput for m = 3, n = 4");

fill0X(3, 4);
return 0;
}

Output:

Output for m = 5, n = 6
X X X X X X
X 0 0 0 0 X
X 0 X X 0 X
X 0 0 0 0 X
X X X X X X
X X X X
X 0 0 X
X 0 0 X
X X X X
X X X X
X 0 0 X
X X X X

Time Complexity: O(mn)

Auxiliary Space: O(mn)
Please suggest if someone has a better solution which is more efficient in terms of space and time.
This article is contributed by Deepak Bisht. Please write comments if you find anything incorrect, or you
How to turn off a particular bit in a number?
Given a number n and a value k, turn of the k’th bit in n.
Examples:
Input: n = 15, k = 1
Output: 14
Input: n = 15, k = 2
Output: 13
Input: n = 15, k = 3
Output: 11
Input: n = 15, k = 4
Output: 7
Input: n = 15, k >= 5

Output: 15

The idea is to use bitwise ~(1 “, we get a number which has all bits set, except the k’th bit. If we do bitwise &
of this expression with n, we get a number which has all bits same as n except the k’th bit which is 0.
Following is C++ implementation of this.
#include <iostream>
// Returns a number that has all bits same as n

// except the k'th bit which is made 0
int turnOffK(int n, int k)
{
// k must be greater than 0
if (k <= 0) return n;
// Do & of n with a number with all set bits except

// the k'th bit
return (n & ~(1 << (k - 1)));
}

int main()
{
int n = 15;
int k = 4;
cout << turnOffK(n, k);
return 0;
}

Output:

7

Exercise: Write a function turnOnK() that turns the k’th bit on.
Horner’s Method for Polynomial Evaluation
Given a polynomial of the form cnxn + cn-1 xn-1 + cn-2xn-2 + … + c1x + c0 and a value of x, find the value of
polynomial for a given value of x. Here cn, cn-1 , .. are integers (may be negative) and n is a positive integer.
Input is in the form of an array say poly[] where poly[0] represents coefficient for xn and poly[1] represents
coefficient for xn-1 and so on.
Examples:
// Evaluate value of 2x3 - 6x2 + 2x - 1 for x = 3

Input: poly[] = {2, -6, 2, -1}, x = 3
Output: 5
// Evaluate value of 2x3 + 3x + 1 for x = 2

Input: poly[] = {2, 0, 3, 1}, x = 2
Output: 23

n
A naive way to evaluate a polynomial is to one by one evaluate all terms. First calculate x, multiply the value
with cn, repeat the same steps for other terms and return the sum. Time complexity of this approach is O(n2)
if we use a simple loop for evaluation of xn. Time complexity can be improved to O(nLogn) if we use O(Logn)
approach for evaluation of xn.
Horner’s method can be used to evaluate polynomial in O(n) time. To understand the method, let us
consider the example of 2x3 – 6x2 + 2x – 1. The polynomial can be evaluated as ((2x – 6)x + 2)x – 1. The idea
is to initialize result as coefficient of xn which is 2 in this case, repeatedly multiply result with x and add next
coefficient to result. Finally return result.
Following is C++ implementation of Horner’s Method.

#include <iostream>
// returns value of poly[0]x(n-1) + poly[1]x(n-2) + .. + poly[n-1]

int horner(int poly[], int n, int x)
{
int result = poly[0]; // Initialize result
// Evaluate value of polynomial using Horner's method

result = result*x + poly[i];
return result;
}

int main()
{
// Let us evaluate value of 2x3 - 6x2 + 2x - 1 for x = 3
int poly[] = {2, -6, 2, -1};
int x = 3;
int n = sizeof(poly)/sizeof(poly[0]);
cout << "Value of polynomial is " << horner(poly, n, x);
return 0;
}

Output:

Value of polynomial is 5

discussed above
Swap two nibbles in a byte
A nibble is a four-bit aggregation, or half an octet. There are two nibbles in a byte.
Given a byte, swap the two nibbles in it. For example 100 is be represented as 01100100 in a byte (or 8 bits).
The two nibbles are (0110) and (0100). If we swap the two nibbles, we get 01000110 which is 70 in decimal.
To swap the nibbles, we can use bitwise &, bitwise ‘>’ operators. A byte can be represented using a unsigned
char in C as size of char is 1 byte in a typical C compiler. Following is C program to swap the two nibbles in a
byte.
#include <stdio.h>
unsigned char swapNibbles(unsigned char x)

{
return ( (x & 0x0F)<<4 | (x & 0xF0)>>4 );
}
int main()
{
unsigned char x = 100;
printf("%u", swapNibbles(x));
return 0;
}

Output:

70

Explanation:
100 is 01100100 in binary. The operation can be split mainly in two parts
1) The expression “x & 0x0F” gives us last 4 bits of x. For x = 100, the result is 00000100. Using bitwise ‘2)
The expression “x & 0xF0” gives us first four bits of x. For x = 100, the result is 01100000. Using bitwise
‘>>’ operator, we shift the digit to the right 4 times and make the first four bits as 0. The result after shift is
00000110.
At the end we use the bitwise OR ‘|’ operation of the two expressions explained above. The OR operator
places first nibble to the end and last nibble to first. For x = 100, the value of (01000000) OR (00000110)
gives the result 01000110 which is equal to 70 in decimal.
This article is contributed by Anuj Garg. Please write comments if you find anything incorrect, or you want
Write a function that generates one of 3 numbers according to given
probabilities
You are given a function rand(a, b) which generates equiprobable random numbers between [a, b] inclusive.
Generate 3 numbers x, y, z with probability P(x), P(y), P(z) such that P(x) + P(y) + P(z) = 1 using the given
rand(a,b) function.
The idea is to utilize the equiprobable feature of the rand(a,b) provided. Let the given probabilities be
in percentage form, for example P(x)=40%, P(y)=25%, P(z)=35%..

1) Generate a random number between 1 and 100. Since they are equiprobable, the probability of each
number appearing is 1/100.
2) Following are some important points to note about generated random number ‘r’.
a) ‘r’ is smaller than or equal to P(x) with probability P(x)/100.
b) ‘r’ is greater than P(x) and smaller than or equal P(x) + P(y) with P(y)/100.
c) ‘r’ is greater than P(x) + P(y) and smaller than or equal 100 (or P(x) + P(y) + P(z)) with probability
P(z)/100.
// This function generates 'x' with probability px/100, 'y' with

// probability py/100 and 'z' with probability pz/100:
// Assumption: px + py + pz = 100 where px, py and pz lie
// between 0 to 100
int random(int x, int y, int z, int px, int py, int pz)
{
// Generate a number from 1 to 100
int r = rand(1, 100);

// r is smaller than px with probability px/100
if (r <= px)
return x;
// r is greater than px and smaller than or equal to px+py

// with probability py/100
if (r <= (px+py))
return y;
// r is greater than px+py and smaller than or equal to 100

// with probability pz/100
else
return z;
}

This function will solve the purpose of generating 3 numbers with given three probabilities.
This article is contributed by Harsh Agarwal. Please write comments if you find anything incorrect, or you
Find the smallest number whose digits multiply to a given number n
Given a number ‘n’, find the smallest number ‘p’ such that if we multiply all digits of ‘p’, we get ‘n’. The result
‘p’ should have minimum two digits.
Examples:
Input: n = 36
Output: p = 49
// Note that 4*9 = 36 and 49 is the smallest such number
Input: n = 100
Output: p = 455
// Note that 4*5*5 = 100 and 455 is the smallest such number
Input: n = 1
Output:p = 11
// Note that 1*1 = 1
Input: n = 13
Output: Not Possible

For a given n, following are the two cases to be considered.

Case 1: n When n is smaller than n, the output is always n+10. For example for n = 7, output
is 17. For n = 9, output is 19.
Case 2: n >= 10 Find all factors of n which are between 2 and 9 (both inclusive). The idea is to start
searching from 9 so that the number of digits in result are minimized. For example 9 is preferred over 33
and 8 is preferred over 24.
Store all found factors in an array. The array would contain digits in non-increasing order, so finally print
the array in reverse order.
Following is C implementation of above concept.

#include<stdio.h>
// Maximum number of digits in output

#define MAX 50
// prints the smallest number whose digits multiply to n

void findSmallest(int n)
{
int i, j=0;
int res[MAX]; // To sore digits of result in reverse order
// Case 1: If number is smaller than 10

if (n < 10)
{
printf("%d", n+10);
return;
}
// Case 2: Start with 9 and try every possible digit

for (i=9; i>1; i--)
{
// If current digit divides n, then store all
// occurrences of current digit in res
while (n%i == 0)
{
n = n/i;
res[j] = i;
j++;
}
}
// If n could not be broken in form of digits (prime factors of n

// are greater than 9)
if (n > 10)
{
printf("Not possible");
return;
}
// Print the result array in reverse order

for (i=j-1; i>=0; i--)
printf("%d", res[i]);
}

int main()
{
findSmallest(7);
printf("\n");
findSmallest(36);
printf("\n");
findSmallest(13);
printf("\n");
findSmallest(100);
return 0;
}

Output:

17
49
Not possible
455

This article is contributed by Ashish Bansal. Please write comments if you find anything incorrect, or you
Check if a given string is a rotation of a palindrome
Given a string, check if it is a rotation of a palindrome. For example your function should return true for
“aab” as it is a rotation of “aba”.
Examples:
Input: str = "aaaad"

Output: 1
// "aaaad" is a rotation of a palindrome "aadaa"
Input: str = "abcd"

Output: 0
// "abcd" is not a rotation of any palindrome.

A Simple Solution is to take the input string, try every possible rotation of it and return true if a rotation is
a palindrome. If no rotation is palindrome, then return false.
Following is C++ implementation of this approach.

#include<iostream>
#include<string>
// A utility function to check if a string str is palindrome

bool isPalindrome(string str)
{
// Start from leftmost and rightmost corners of str
int l = 0;
int h = str.length() - 1;
// Keep comparing characters while they are same

while (h > l)
if (str[l++] != str[h--])
return false;
// If we reach here, then all characters were matching

return true;
}
// Function to chech if a given string is a rotation of a

// palindrome.
bool isRotationOfPalindrome(string str)
{
// If string iteself is palindrome
if (isPalindrome(str))
return true;
// Now try all rotations one by one

int n = str.length();
for (int i = 0; i < n-1; i++)
{
string str1 = str.substr(i+1, n-i-1);
string str2 = str.substr(0, i+1);
// Check if this rotation is palindrome

if (isPalindrome(str1.append(str2)))
return true;
}
return false;
}

int main()
{
cout << isRotationOfPalindrome("aab") << endl;
cout << isRotationOfPalindrome("abcde") << endl;
cout << isRotationOfPalindrome("aaaad") << endl;
return 0;
}

Output:

1
0
1


Auxiliary Space: O(n) for storing rotations.
Note that the above algorithm can be optimized to work in O(1) extra space as we can rotate a string in O(n)
time and O(1) extra space.
An Optimized Solution can work in O(n) time. The idea is similar to this post. Following are steps.
1) Let the given string be ‘str’ and length of string be ‘n’. Create a temporary string ‘temp’ which is of size 2n
and contains str followed by str again. For example, let str be “aab”, temp would be “aabaab”.
2) Now the problem reduces to find a palindromic substring of length n in str. If there is palindromic
substring of length n, then return true, else return false.
We can find whether there is a palindromic substring of size n or not in O(n) time (See Longest palindromic
substring)
This article is contributed Abhay Rathi. Please write comments if you find anything incorrect, or you want
Find k closest elements to a given value
Given a sorted array arr[] and a value X, find the k closest elements to X in arr[].
Examples:
Input: K = 4, X = 35
arr[] = {12, 16, 22, 30, 35, 39, 42,
45, 48, 50, 53, 55, 56}
Output: 30 39 42 45

Note that if the element is present in array, then it should not be in output, only the other closest elements
are required.
In the following solutions, it is assumed that all elements of array are distinct.
A simple solution is to do linear search for k closest elements.

1) Start from the first element and search for the crossover point (The point before which elements are
smaller than or equal to X and after which elements are greater). This step takes O(n) time.
2) Once we find the crossover point, we can compare elements on both sides of crossover point to print k
closest elements. This step takes O(k) time.
The time complexity of the above solution is O(n).
An Optimized Solution is to find k elements in O(Logn + k) time. The idea is to use Binary Search to find
the crossover point. Once we find index of crossover point, we can print k closest elements in O(k) time.
#include<stdio.h>
/* Function to find the cross over point (the point before

which elements are smaller than or equal to x and after
which greater than x)*/
int findCrossOver(int arr[], int low, int high, int x)
{
// Base cases
if (arr[high] <= x) // x is greater than all
return high;
if (arr[low] > x) // x is smaller than all
return low;

int mid = (low + high)/2; /* low + (high - low)/2 */

if (arr[mid] <= x && arr[mid+1] > x)
return mid;

is ceiling of x or ceiling lies in arr[mid+1...high] */
if(arr[mid] < x)
return findCrossOver(arr, mid+1, high, x);
return findCrossOver(arr, low, mid - 1, x);

}
// This function prints k closest elements to x in arr[].

// n is the number of elements in arr[]
// n is the number of elements in arr[]
void printKclosest(int arr[], int x, int k, int n)
{
// Find the crossover point
int l = findCrossOver(arr, 0, n-1, x); // le
int r = l+1; // Right index to search
int count = 0; // To keep track of count of elements already printed
// If x is present in arr[], then reduce left index

// Assumption: all elements in arr[] are distinct
if (arr[l] == x) l--;
// Compare elements on left and right of crossover

// point to find the k closest elements
while (l >= 0 && r < n && count < k)
{
if (x - arr[l] < arr[r] - x)
printf("%d ", arr[l--]);
else
printf("%d ", arr[r++]);
count++;
}
// If there are no more elements on right side, then

// print left elements
while (count < k && l >= 0)
printf("%d ", arr[l--]), count++;
// If there are no more elements on left side, then

// print right elements
while (count < k && r < n)
printf("%d ", arr[r++]), count++;
}

int main()
{
int arr[] ={12, 16, 22, 30, 35, 39, 42,
45, 48, 50, 53, 55, 56};
int x = 35, k = 4;
printKclosest(arr, x, 4, n);
return 0;
}

Output:

39 30 42 45

The time complexity of this method is O(Logn + k).
Exercise: Extend the optimized solution to work for duplicates also, i.e., to work for arrays where elements
don’t have to be distinct.
Check if binary representation of a number is palindrome
Given an integer ‘x’, write a C function that returns true if binary representation of x is palindrome else
return false.
For example a numbers with binary representation as 10..01 is palindrome and number with binary
representation as 10..00 is not palindrome.
The idea is similar to checking a string is palindrome or not. We start from leftmost and rightmost bits and
compare bits one by one. If we find a mismatch, then return false.
Algorithm:
isPalindrome(x)
1) Find number of bits in x using sizeof() operator.
2) Initialize left and right positions as 1 and n respectively.
3) Do following while left ‘l’ is smaller than right ‘r’.
..…..a) If bit at position ‘l’ is not same as bit at position ‘r’, then return false.
..…..b) Increment ‘l’ and decrement ‘r’, i.e., do l++ and r–-.
4) If we reach here, it means we didn’t find a mismatching bit.
To find the bit at a given position, we can use the idea similar to this post. The expression “x & (1 ” gives us
non-zero value if bit at k’th position from right is set and gives a zero value if if k’th bit is not
set.

#include<iostream>
// This function returns true if k'th bit in x is set (or 1).

// For example if x (0010) is 2 and k is 2, then it returns true
bool isKthBitSet(unsigned int x, unsigned int k)
{
return (x & (1 << (k-1)))? true: false;
}
// This function returns true if binary representation of x is

// palindrome. For example (1000...001) is paldindrome
bool isPalindrome(unsigned int x)
{
int l = 1; // Initialize left position
int r = sizeof(unsigned int)*8; // initialize right position
// One by one compare bits

while (l < r)
{
if (isKthBitSet(x, l) != isKthBitSet(x, r))
return false;
l++; r--;
}
return true;
}

int main()
{
unsigned int x = 1<<15 + 1<<16;
cout << isPalindrome(x) << endl;
x = 1<<31 + 1;
cout << isPalindrome(x) << endl;
return 0;
}

Output:

1
1

This article is contributed by Saurabh Gupta. Please write comments if you find anything incorrect, or you
Dynamic Programming | Set 37 (Boolean Parenthesization Problem)
Given a boolean expression with following symbols.
Symbols
'T' ---> true
'F' ---> false

And following operators filled between symbols
Operators
& ---> boolean AND
| ---> boolean OR
^ ---> boolean XOR

Count the number of ways we can parenthesize the expression so that the value of expression evaluates to
true.
Let the input be in form of two arrays one contains the symbols (T and F) in order and other contains
operators (&, | and ^}
Examples:
Input: symbol[] = {T, F, T}

operator[] = {^, &}
Output: 2
The given expression is "T ^ F & T", it evaluates true
in two ways "((T ^ F) & T)" and "(T ^ (F & T))"
Input: symbol[] = {T, F, F}

operator[] = {^, |}
Output: 2
The given expression is "T ^ F | F", it evaluates true
in two ways "( (T ^ F) | F )" and "( T ^ (F | F) )".
Input: symbol[] = {T, T, F, T}

operator[] = {|, &, ^}
Output: 4
The given expression is "T | T & F ^ T", it evaluates true
in 4 ways ((T|T)&(F^T)), (T|(T&(F^T))), (((T|T)&F)^T)
and (T|((T&F)^T)).

Solution:
Let T(i, j) represents the number of ways to parenthesize the symbols between i and j (both inclusive) such
that the subexpression between i and j evaluates to true.
Let F(i, j) represents the number of ways to parenthesize the symbols between i and j (both inclusive) such
that the subexpression between i and j evaluates to false.
Base Cases:
T(i, i) = 1 if symbol[i] = 'T'

T(i, i) = 0 if symbol[i] = 'F'
F(i, i) = 1 if symbol[i] = 'F'

F(i, i) = 0 if symbol[i] = 'T'

If we draw recursion tree of above recursive solution, we can observe that it many overlapping subproblems.
Like other dynamic programming problems, it can be solved by filling a table in bottom up manner.
Following is C++ implementation of dynamic programming solution.
#include<iostream>
#include<cstring>
// Returns count of all possible parenthesizations that lead to

// result true for a boolean expression with symbols like true
// and false and operators like &, | and ^ filled between symbols
int countParenth(char symb[], char oper[], int n)
{
int F[n][n], T[n][n];
// Fill diaginal entries first

// All diagonal entries in T[i][i] are 1 if symbol[i]
// is T (true). Similarly, all F[i][i] entries are 1 if
// symbol[i] is F (False)
for (int i = 0; i < n; i++)
{
F[i][i] = (symb[i] == 'F')? 1: 0;
T[i][i] = (symb[i] == 'T')? 1: 0;
}
// Now fill T[i][i+1], T[i][i+2], T[i][i+3]... in order

// And F[i][i+1], F[i][i+2], F[i][i+3]... in order
for (int gap=1; gap<n; ++gap)
{
for (int i=0, j=gap; j<n; ++i, ++j)
{
T[i][j] = F[i][j] = 0;
for (int g=0; g<gap; g++)
{
// Find place of parenthesization using current value
// Find place of parenthesization using current value
// of gap
int k = i + g;
// Store Total[i][k] and Total[k+1][j]

int tik = T[i][k] + F[i][k];
int tkj = T[k+1][j] + F[k+1][j];
// Follow the recursive formulas according to the current

// operator
if (oper[k] == '&')
{
T[i][j] += T[i][k]*T[k+1][j];
F[i][j] += (tik*tkj - T[i][k]*T[k+1][j]);
}
if (oper[k] == '|')
{
F[i][j] += F[i][k]*F[k+1][j];
T[i][j] += (tik*tkj - F[i][k]*F[k+1][j]);
}
if (oper[k] == '^')
{
T[i][j] += F[i][k]*T[k+1][j] + T[i][k]*F[k+1][j];
F[i][j] += T[i][k]*T[k+1][j] + F[i][k]*F[k+1][j];
}
}
}
}
return T[0][n-1];
}

int main()
{
char symbols[] = "TTFT";
char operators[] = "|&^";
int n = strlen(symbols);
// There are 4 ways

// ((T|T)&(F^T)), (T|(T&(F^T))), (((T|T)&F)^T) and (T|((T&F)^T))
cout << countParenth(symbols, operators, n);
return 0;
}

Output:

Auxiliary Space: O(n2)
References:
http://people.cs.clemson.edu/~bcdean/dp_practice/dp_9.swf
discussed above
Count number of binary strings without consecutive 1’s
Given a positive integer N, count all possible distinct binary strings of length N such that there are no
consecutive 1’s.
Examples:
Input: N = 2
Output: 3
// The 3 strings are 00, 01, 10
Input: N = 3
Output: 5
// The 5 strings are 000, 001, 010, 100, 101

This problem can be solved using Dynamic Programming. Let a[i] be the number of binary strings of length i
which do not contain any two consecutive 1’s and which end in 0. Similarly, let b[i] be the number of such
strings which end in 1. We can append either 0 or 1 to a string ending in 0, but we can only append 0 to a
string ending in 1. This yields the recurrence relation:
a[i] = a[i - 1] + b[i - 1]

b[i] = a[i - 1]

The base cases of above recurrence are a[1] = b[1] = 1. The total number of strings of length i is just a[i] +
b[i].
Following is C++ implementation of above solution. In the following implementation, indexes start from 0.
So a[i] represents the number of binary strings for input length i+1. Similarly, b[i] represents binary strings
for input length i+1.

// C++ program to count all distinct binary strings

// without two consecutive 1's
#include <iostream>
int countStrings(int n)
{
int a[n], b[n];
a[0] = b[0] = 1;
for (int i = 1; i < n; i++)
{
a[i] = a[i-1] + b[i-1];
b[i] = a[i-1];
}
return a[n-1] + b[n-1];
}

int main()
{
cout << countStrings(3) << endl;
return 0;
}

Output:
Source:
courses.csail.mit.edu/6.006/oldquizzes/solutions/q2-f2009-sol.pdf
Question 1
#include <iostream>
#include <string.h>
int main()
{
cout << sizeof("GeeksforGeeks") << endl;
cout << strlen("GeeksforGeeks");
return 0;
}

Output:

14
13

Sizeof operator returns the size of string including null character so output is 14. While strlen() function
returns the exact length of string excluding null character so output is 13.
Question 2:
#include <iostream>
using std::cout;
class Test
{
public:
Test();
~Test();
};
Test::Test()
{
cout << "Constructor is executed\n";
}
Test::~Test()
{
cout << "Destructor is executed\n";
}
int main()
{
delete new Test();
return 0;
}

Output:

Constructor is executed
Destructor is executed

The first statement inside the main () function looks strange, but it is perfectly valid. It is possible to create
an object without giving its handle to any pointer in C++. This statement will create an object of class Test
without any pointer pointing to it. This can be also done in languages like Java & C#.
For example consider following statement:
new student(); // valid both in Java & C#

The above statement will create an object of student class without any reference pointing to it.
Question 3:
#include <iostream>
using std::cout;
class main
{
public:
main() {cout << "ctor is called\n";}
~main() {cout << "dtor is called\n";}
};
int main()
{
main m; // LINE 11
}

Output:
Compiler error:
11 8 [Error] expected ';' before 'm'

The above program looks syntactically correct but it fails in compilation. The reason class name. Class name
is main so it is necessary to tell the compiler that main is the name of class. Generally struct or class keyword
is not required to write to create an object of the class or struct. But when the name of class is main it
becomes necessary to write struct or class when creating object of class or struct. Remember main is not a
reserved word.
Following is a correct version of the above program:

#include <iostream>
using std::cout;
class main
{
public:
main() { cout << "ctor is called\n";}
~main() { cout << "dtor is called\n";}
};
int main()
{
class main m;
}

Now predict the output of following program:
#include <iostream>
using std::cout;
class main
{
public:
main() { cout << "ctor is called\n"; }
~main() { cout << "dtor is called\n"; }
};
main m; // Global object
int main()
{
}

The above program compiles and runs fine because object is global. Global object‘s constructor executes
before main() function and it’s destructor executes when main() terminates.
Conclusion: When the class/struct name is main and whenever the local object is created it is mandatory to
write class or struct when the object of class / and struct is created. Because C++ program execution begins
from main () function. But this rule is not applied to global objects. Again, main isn’t a keyword but treat it
as if it were.
This article is contributed Meet Pravasi. Please write comments if you find anything incorrect, or you want
Channel Assignment Problem
There are M transmitter and N receiver stations. Given a matrix that keeps track of the number of packets to
be transmitted from a given transmitter to a receiver. If the (i; j)-th entry of the matrix is k, it means at that
time the station i has k packets for transmission to station j.
During a time slot, a transmitter can send only one packet and a receiver can receive only one packet. Find
the channel assignments so that maximum number of packets are transferred from transmitters to receivers
during the next time slot.
Example:
0 2 0
3 0 1
2 4 0

The above is the input format. We call the above matrix M. Each value M[i; j] represents the number of
packets Transmitter ‘i’ has to send to Receiver ‘j’. The output should be:
The number of maximum packets sent in the time slot is 3

T1 -> R2
T2 -> R3
T3 -> R1

Note that the maximum number of packets that can be transferred in any slot is min(M, N).
Algorithm:
The channel assignment problem between sender and receiver can be easily transformed into Maximum
Bipartite Matching(MBP) problem that can be solved by converting it into a flow network.
Step 1: Build a Flow Network

There must be a source and sink in a flow network. So we add a dummy source and add edges from source to
all senders. Similarly, add edges from all receivers to dummy sink. The capacity of all added edges is marked
as 1 unit.
Step 2: Find the maximum flow.

We use Ford-Fulkerson algorithm to find the maximum flow in the flow network built in step 1. The
maximum flow is actually the maximum number of packets that can be transmitted without bandwidth
interference in a time slot.
Implementation:
Let us first define input and output forms. Input is in the form of Edmonds matrix which is a 2D array
‘table[M][N]‘ with M rows (for M senders) and N columns (for N receivers). The value table[i][j] is the
number of packets that has to be sent from transmitter ‘i’ to receiver ‘j’. Output is the maximum number of
packets that can be transmitted without bandwidth interference in a time slot.
A simple way to implement this is to create a matrix that represents adjacency matrix representation of a
directed graph with M+N+2 vertices. Call the fordFulkerson() for the matrix. This implementation requires
O((M+N)*(M+N)) extra space.
Extra space can be reduced and code can be simplified using the fact that the graph is bipartite. The idea is
to use DFS traversal to find a receiver for a transmitter (similar to augmenting path in Ford-Fulkerson). We
call bpm() for every applicant, bpm() is the DFS based function that tries all possibilities to assign a receiver
to the sender. In bpm(), we one by one try all receivers that a sender ‘u’ is interested in until we find a
receiver, or all receivers are tried without luck.
For every receiver we try, we do following:
If a receiver is not assigned to anybody, we simply assign it to the sender and return true. If a receiver is
assigned to somebody else say x, then we recursively check whether x can be assigned some other receiver.
To make sure that x doesn’t get the same receiver again, we mark the receiver ‘v’ as seen before we make
recursive call for x. If x can get other receiver, we change the sender for receiver ‘v’ and return true. We use
an array maxR[0..N-1] that stores the senders assigned to different receivers.
If bmp() returns true, then it means that there is an augmenting path in flow network and 1 unit of flow is
added to the result in maxBPM().
Time and space complexity analysis:

In case of bipartite matching problem, F ? |V| since there can be only |V| possible edges coming out from
source node. So the total running time is O(m’n) = O((m + n)n). The space complexity is also substantially
reduces from O ((M+N)*(M+N)) to just a single dimensional array of size M thus storing the mapping
between M and N.
#include <iostream>
#include <string.h>
#include <vector>
#define M 3
#define N 4
// A Depth First Search based recursive function that returns true

// if a matching for vertex u is possible
bool bpm(int table[M][N], int u, bool seen[], int matchR[])
{
// Try every receiver one by one
for (int v = 0; v < N; v++)
{
// If sender u has packets to send to receiver v and
// receiver v is not already mapped to any other sender
// just check if the number of packets is greater than '0'
// because only one packet can be sent in a time frame anyways
if (table[u][v]>0 && !seen[v])
{
seen[v] = true; // Mark v as visited
// If receiver 'v' is not assigned to any sender OR

// previously assigned sender for receiver v (which is
// matchR[v]) has an alternate receiver available. Since
// v is marked as visited in the above line, matchR[v] in
// the following recursive call will not get receiver 'v' again
if (matchR[v] < 0 || bpm(table, matchR[v], seen, matchR))
{
matchR[v] = u;
return true;
}
}
}
return false;
}
// Returns maximum number of packets that can be sent parallely in 1

// time slot from sender to receiver
int maxBPM(int table[M][N])
{
// An array to keep track of the receivers assigned to the senders.
// The value of matchR[i] is the sender ID assigned to receiver i.
// the value -1 indicates nobody is assigned.
int matchR[N];
// Initially all receivers are not mapped to any senders

memset(matchR, -1, sizeof(matchR));
int result = 0; // Count of receivers assigned to senders

for (int u = 0; u < M; u++)
{
// Mark all receivers as not seen for next sender
bool seen[N];
memset(seen, 0, sizeof(seen));
// Find if the sender 'u' can be assigned to the receiver

if (bpm(table, u, seen, matchR))
result++;
}
cout << "The number of maximum packets sent in the time slot is "
<< result << "\n";
for (int x=0; x<N; x++)

if (matchR[x]+1!=0)
cout << "T" << matchR[x]+1 << "-> R" << x+1 << "\n";
return result;
}

int main()
{
int table[M][N] = {{0, 2, 0}, {3, 0, 1}, {2, 4, 0}};
int max_flow = maxBPM(table);
return 0;
}

Output:

The number of maximum packets sent in the time slot is 3
T3-> R1
T1-> R2
T2-> R3

This article is contributed by Vignesh Narayanan. Please write comments if you find anything incorrect, or
Transform a BST to greater sum tree
Given a BST, transform it into greater sum tree where each node contains sum of all nodes greater than that
node.
We strongly recommend to minimize the gbrowser and try this yourself first.
Method 1 (Naive):
This method doesn’t require the tree to be a BST. Following are steps.
1. Traverse node by node(Inorder, preorder, etc.)
2. For each node find all the nodes greater than that of the current node, sum the values. Store all these
sums.
3. Replace each node value with their corresponding sum by traversing in the same order as in Step 1.
This takes O(n^2) Time Complexity.
Method 2 (Using only one traversal)

By leveraging the fact that the tree is a BST, we can find an O(n) solution. The idea is to traverse BST in
reverse inorder. Reverse inorder traversal of a BST gives us keys in decreasing order. Before visiting a node,
we visit all greater nodes of that node. While traversing we keep track of sum of keys which is the sum of all
the keys greater than the key of current node.
// C++ program to transform a BST to sum tree

#include<iostream>
// A BST node
struct Node
{
int data;
};

{
struct Node *temp = new Node;
temp->data = item;
return temp;
}
// Recursive function to transform a BST to sum tree.

// This function traverses the tree in reverse inorder so
// that we have visited all greater key nodes of the currently
// visited node
void transformTreeUtil(struct Node *root, int *sum)
{
{
// Base case

transformTreeUtil(root->right, sum);
// Update sum
*sum = *sum + root->data;
// Store old sum in current node

root->data = *sum - root->data;

transformTreeUtil(root->left, sum);
}
// A wrapper over transformTreeUtil()

void transformTree(struct Node *root)
{
int sum = 0; // Initialize sum
transformTreeUtil(root, &sum);
}
// A utility function to print indorder traversal of a

// binary tree
void printInorder(struct Node *root)
{
printInorder(root->left);
printInorder(root->right);
}

int main()
{
cout << "Inorder Traversal of given tree\n";

printInorder(root);
transformTree(root);
cout << "\n\nInorder Traversal of transformed tree\n";

printInorder(root);
return 0;
}

Output:

Inorder Traversal of given tree
1 2 7 11 15 29 35 40
Inorder Traversal of transformed tree

139 137 130 119 104 75 40 0

Time complexity of this method is O(n) as it does a simple traversal of tree.
This article is contributed by Bhavana. Please write comments if you find anything incorrect, or you want
Reverse alternate levels of a perfect binary tree
Given a Perfect Binary Tree, reverse the alternate level nodes of the binary tree.

Given tree:
a
/ \
b c
/ \ / \
d e f g
/ \ / \ / \ / \
h i j k l m n o
Modified tree:
a
/ \
c b
/ \ / \
d e f g
/ \ / \ / \ / \
o n m l k j i h

A simple solution is to do following steps.

1) Access nodes level by level.
2) If current level is odd, then store nodes of this level in an array.
3) Reverse the array and store elements back in tree.
A tricky solution is to do two inorder traversals. Following are steps to be followed.

1) Traverse the given tree in inorder fashion and store all odd level nodes in an auxiliary array. For the above
example given tree, contents of array become {h, i, b, j, k, l, m, c, n, o}
2) Reverse the array. The array now becomes {o, n, c, m, l, k, j, b, i, h}
3) Traverse the tree again inorder fashion. While traversing the tree, one by one take elements from array
and store elements from array to every odd level traversed node.
For the above example, we traverse ‘h’ first in above array and replace ‘h’ with ‘o’. Then we traverse ‘i’ and
replace it with n.
// C++ program to reverse alternate levels of a binary tree

#include<iostream>
#define MAX 100

struct Node
{
char data;
};

struct Node *newNode(char item)
struct Node *newNode(char item)
{
temp->data = item;
return temp;
}
// Function to store nodes of alternate levels in an array

void storeAlternate(Node *root, char arr[], int *index, int l)
{
// Base case
// Store elements of left subtree

storeAlternate(root->left, arr, index, l+1);
// Store this node only if this is a odd level node

if (l%2 != 0)
{
arr[*index] = root->data;
(*index)++;
}
// Store elements of right subtree

storeAlternate(root->right, arr, index, l+1);
}
// Function to modify Binary Tree (All odd level nodes are

// updated by taking elements from array in inorder fashion)
void modifyTree(Node *root, char arr[], int *index, int l)
{
// Base case
// Update nodes in left subtree

modifyTree(root->left, arr, index, l+1);
// Update this node only if this is an odd level node

if (l%2 != 0)
{
root->data = arr[*index];
(*index)++;
}
// Update nodes in right subtree

modifyTree(root->right, arr, index, l+1);
}
// A utility function to reverse an array from index

// 0 to n-1
void reverse(char arr[], int n)
{
int l = 0, r = n-1;
while (l < r)
{
int temp = arr[l];
arr[l] = arr[r];
arr[r] = temp;
l++; r--;
}
}
// The main function to reverse alternate nodes of a binary tree

void reverseAlternate(struct Node *root)
void reverseAlternate(struct Node *root)
{
// Create an auxiliary array to store nodes of alternate levels
char *arr = new char[MAX];
int index = 0;
// First store nodes of alternate levels

storeAlternate(root, arr, &index, 0);
// Reverse the array

reverse(arr, index);
// Update tree by taking elements from array

index = 0;
modifyTree(root, arr, &index, 0);
}
// A utility function to print indorder traversal of a

// binary tree
void printInorder(struct Node *root)
{
}

int main()
{
struct Node *root = newNode('a');
root->left = newNode('b');
root->right = newNode('c');
root->left->left = newNode('d');
root->left->right = newNode('e');
root->right->left = newNode('f');
root->right->right = newNode('g');
root->left->left->left = newNode('h');
root->left->left->right = newNode('i');
root->left->right->left = newNode('j');
root->left->right->right = newNode('k');
root->right->left->left = newNode('l');
root->right->left->right = newNode('m');
root->right->right->left = newNode('n');
root->right->right->right = newNode('o');
cout << "Inorder Traversal of given tree\n";

printInorder(root);
reverseAlternate(root);
cout << "\n\nInorder Traversal of modified tree\n";

printInorder(root);
return 0;
}
Output:

Inorder Traversal of given tree
h d i b j e k a l f m c n g o
Inorder Traversal of modified tree

o d n c m e l a k f j b i g h

Time complexity of the above solution is O(n) as it does two inorder traversals of binary tree.
This article is contributed by Kripal Gaurav. Please write comments if you find anything incorrect, or you
Calculate the angle between hour hand and minute hand
This problem is know as Clock angle problem where we need to find angle between hands of an analog clock
at .
Examples:
Input: h = 12:00, m = 30.00

Output: 165 degree
Input: h = 3.00, m = 30.00

Output: 75 degree

The idea is to take 12:00 (h = 12, m = 0) as a reference. Following are detailed steps.
1) Calculate the angle made by hour hand with respect to 12:00 in h hours and m minutes.
2) Calculate the angle made by minute hand with respect to 12:00 in h hours and m minutes.
3) The difference between two angles is the angle between two hands.
How to calculate the two angles with respect to 12:00?

The minute hand moves 360 degree in 60 minute(or 6 degree in one minute) and hour hand moves 360
degree in 12 hours(or 0.5 degree in 1 minute). In h hours and m minutes, the minute hand would move
(h*60 + m)*6 and hour hand would move (h*60 + m)*0.5.

// C program to find angle between hour and minute hands

#include <stdio.h>
#include <stdlib.h>
// Utility function to find minimum of two integers

int calcAngle(double h, double m)

{
// validate the input
if (h <0 || m < 0 || h >12 || m > 60)
printf("Wrong input");
if (h == 12) h = 0;
if (m == 60) m = 0;
// Calculate the angles moved by hour and minute hands

// with reference to 12:00
int hour_angle = 0.5 * (h*60 + m);
int minute_angle = 6*m;
// Find the difference between two angles

int angle = abs(hour_angle - minute_angle);
// Return the smaller angle of two possible angles

angle = min(360-angle, angle);
return angle;
}

int main()
{
printf("%d \n", calcAngle(9, 60));
printf("%d \n", calcAngle(3, 30));
return 0;
}

Output:

90
75

Exercise: Find all times when hour and minute hands get superimposed.
Find the maximum path sum between two leaves of a binary tree
Given a binary tree in which each node element contains a number. Find the maximum possible sum from
one leaf node to another.
The maximum sum path may or may not go through root. For example, in the following binary tree, the
maximum sum is 27(3 + 6 + 9 + 0 – 1 + 10). Expected time complexity is O(n).
A simple solution is to traverse the tree and do following for every traversed node X.
1) Find maximum sum from leaf to root in left subtree of X (we can use this post for this and next steps)
2) Find maximum sum from leaf to root in right subtree of X.
3) Add the above two calculated values and X->data and compare the sum with the maximum value
obtained so far and update the maximum value.
4) Return the maximum value.
The time complexity of above solution is O(n2)
We can find the maximum sum using single traversal of binary tree . The idea is to maintain two
values in recursive calls
1) Maximum root to leaf path sum for the subtree rooted under current node.
2) The maximum path sum between leaves (desired output).
For every visited node X, we find the maximum root to leaf sum in left and right subtrees of X. We add the
two values with X->data, and compare the sum with maximum path sum found so far.
Following is C++ implementation of the above O(n) solution.
// C++ program to find maximum path sum between two leaves of

// a binary tree
#include <iostream>

struct Node
{
int data;
};
// Utility function to allocate memory for a new node

{
struct Node* node = new(struct Node);
node->data = data;
return (node);
return (node);
}
// Utility function to find maximum of two integers

{ return (a >= b)? a: b; }
// A utility function to find the maximum sum between any two leaves.
// This function calculates two values:
// 1) Maximum path sum between two leaves which is stored in res.
// 2) The maximum root to leaf path sum which is returned.
int maxPathSumUtil(struct Node *root, int &res)
{
// Base cases
if (root==NULL) return 0;
if (!root->left && !root->right) return root->data;
// Find maximum sum in left and right subtree. Also find

// maximum root to leaf sums in left and right subtrees
// and store them in ls and rs
int ls = maxPathSumUtil(root->left, res);
int rs = maxPathSumUtil(root->right, res);
// Find the maximum path sum passing through current root.

// Note that every path will pass through some node and
// recursive function is called for every node
int curr_sum = ls + rs + root->data;
// Update res (or result) if needed

if (res < curr_sum)
res = curr_sum;
// This is needed to handle cases when node has a single child

if (!ls || !rs) return (!ls)? rs + root->data: ls + root->data;
else return max(ls, rs) + root->data;
// Return the maximum root to leaf path sum

return max(ls, rs)+root->data;
}
// The main function which returns sum of the maximum

// sum path between two leaves. This function mainly uses
// maxPathSumUtil()
int maxPathSum(struct Node *root)
{
int res = INT_MIN;
maxPathSumUtil(root, res);
return res;
}

int main()
{
struct Node *root = newNode(-15);
root->left->left = newNode(-8);
root->right->right->right= newNode(0);
root->right->right->right->left= newNode(4);
root->right->right->right->right= newNode(-1);
root->right->right->right->right->left= newNode(10);
cout << "Max pathSum of the given binary tree is " << maxPathSum(root);
return 0;
}

Output:

Max pathSum of the given binary tree is 27.

This article is contributed by Kripal Gaurav. Please write comments if you find anything incorrect, or you
Count Possible Decodings of a given Digit Sequence
Let 1 represent ‘A’, 2 represents ‘B’, etc. Given a digit sequence, count the number of possible decodings of
the given digit sequence.
Examples:
Input: digits[] = "121"

Output: 3
// The possible decodings are "ABA", "AU", "LA"
Input: digits[] = "1234"

Output: 3
// The possible decodings are "ABCD", "LCD", "AWD"

An empty digit sequence is considered to have one decoding. It may be assumed that the input contains valid
digits from 0 to 9 and there are no leading 0’s, no extra trailing 0’s and no two or more consecutive 0’s.
This problem is recursive and can be broken in sub-problems. We start from end of the given digit sequence.
We initialize the total count of decodings as 0. We recur for two subproblems.
1) If the last digit is non-zero, recur for remaining (n-1) digits and add the result to total count.
2) If the last two digits form a valid character (or smaller than 27), recur for remaining (n-2) digits and add
the result to total count.

// A naive recursive C++ implementation to count number of decodings

// that can be formed from a given digit sequence
#include <iostream>
#include <cstring>
// Given a digit sequence of length n, returns count of possible

// decodings by replacing 1 with A, 2 woth B, ... 26 with Z
int countDecoding(char *digits, int n)
{
// base cases
if (n == 0 || n == 1)
return 1;
int count = 0; // Initialize count
// If the last digit is not 0, then last digit must add to

// the number of words
if (digits[n-1] > '0')
count = countDecoding(digits, n-1);
// If the last two digits form a number smaller than or equal to 26,
// then consider last two digits and recur
if (digits[n-2] < '2' || (digits[n-2] == '2' && digits[n-1] < '7') )
count += countDecoding(digits, n-2);
return count;
}

int main()
{
char digits[] = "1234";
int n = strlen(digits);
cout << "Count is " << countDecoding(digits, n);
return 0;
}

Output:

Count is 3

The time complexity of above the code is exponential. If we take a closer look at the above program, we can
observe that the recursive solution is similar to Fibonacci Numbers. Therefore, we can optimize the above
solution to work in O(n) time using Dynamic Programming. Following is C++ implementation for the same.

// A Dynamic Programming based C++ implementation to count decodings

#include <iostream>
#include <cstring>
// A Dynamic Programming based function to count decodings

int countDecodingDP(char *digits, int n)
{
int count[n+1]; // A table to store results of subproblems
count[0] = 1;
count[1] = 1;
for (int i = 2; i <= n; i++)

{
count[i] = 0;
// If the last digit is not 0, then last digit must add to

// the number of words
if (digits[i-1] > '0')
count[i] = count[i-1];
// If second last digit is smaller than 2 and last digit is

// smaller than 7, then last two digits form a valid character
if (digits[i-2] < '2' || (digits[i-2] == '2' && digits[i-1] < '7') )
}
return count[n];
}

int main()
{
cout << "Count is " << countDecodingDP(digits, n);
return 0;
}

Output:

Count is 3

Time Complexity of the above solution is O(n) and it requires O(n) auxiliary space. We can reduce auxiliary
space to O(1) by using space optimized version discussed in the Fibonacci Number Post.
discussed above
Find next greater number with same set of digits
Given a number n, find the smallest number that has same set of digits as n and is greater than n. If x is the
greatest possible number with its set of digits, then print “not possible”.
Examples:
For simplicity of implementation, we have considered input number as a string.
Input: n = "218765"
Output: "251678"
Input: n = "1234"
Output: "1243"
Input: n = "4321"
Output: "Not Possible"
Input: n = "534976"
Output: "536479"

Following are few observations about the next greater number.

1) If all digits sorted in descending order, then output is always “Not Possible”. For example, 4321.
2) If all digits are sorted in ascending order, then we need to swap last two digits. For example, 1234.
3) For other cases, we need to process the number from rightmost side (why? because we need to find the
smallest of all greater numbers)
You can now try developing an algorithm yourself.
Following is the algorithm for finding the next greater number.

I) Traverse the given number from rightmost digit, keep traversing till you find a digit which is smaller than
the previously traversed digit. For example, if the input number is “534976”, we stop at 4 because 4 is
smaller than next digit 9. If we do not find such a digit, then output is “Not Possible”.
II) Now search the right side of above found digit ‘d’ for the smallest digit greater than ‘d’. For “534976″, the
right side of 4 contains “976”. The smallest digit greater than 4 is 6.
III) Swap the above found two digits, we get 536974 in above example.
IV) Now sort all digits from position next to ‘d’ to the end of number. The number that we get after sorting is
the output. For above example, we sort digits in bold 536974. We get “536479” which is the next greater
number for input 534976.
// C++ program to find the smallest number which greater than a given number
// and has same set of digits as given number
#include <iostream>
#include <cstring>
// Utility function to swap two digits

void swap(char *a, char *b)
void swap(char *a, char *b)
{
char temp = *a;
*a = *b;
*b = temp;
}
// Given a number as a char array number[], this function finds the

// next greater number. It modifies the same array to store the result
void findNext(char number[], int n)
{
int i, j;
// I) Start from the right most digit and find the first digit that is
// smaller than the digit next to it.
for (i = n-1; i > 0; i--)
if (number[i] > number[i-1])
break;
// If no such digit is found, then all digits are in descending order

// means there cannot be a greater number with same set of digits
if (i==0)
{
cout << "Next number is not possible";
return;
}
// II) Find the smallest digit on right side of (i-1)'th digit that is
// greater than number[i-1]
int x = number[i-1], smallest = i;
for (j = i+1; j < n; j++)
if (number[j] > x && number[j] < number[smallest])
smallest = j;
// III) Swap the above found smallest digit with number[i-1]

swap(&number[smallest], &number[i-1]);
// IV) Sort the digits after (i-1) in ascending order

sort(number + i, number + n);
cout << "Next number with same set of digits is " << number;
return;
}

int main()
{
findNext(digits, n);
return 0;
}

Output:

Next number with same set of digits is 536479

The above implementation can be optimized in following ways.

1) We can use binary search in step II instead of linear search.
2) In step IV, instead of doing simple sort, we can apply some clever technique to do it in linear time. Hint:
We know that all digits are linearly sorted in reverse order except one digit which was swapped.
With above optimizations, we can say that the time complexity of this method is O(n).
Maximum Sum Path in Two Arrays
Given two sorted arrays such the arrays may have some common elements. Find the sum of the maximum
sum path to reach from beginning of any array to end of any of the two arrays. We can switch from one array
to another array only at common elements.
Expected time complexity is O(m+n) where m is the number of elements in ar1[] and n is the number of
elements in ar2[].
Examples:
Input: ar1[] = {2, 3, 7, 10, 12}, ar2[] = {1, 5, 7, 8}

Output: 35
35 is sum of 1 + 5 + 7 + 10 + 12.
We start from first element of arr2 which is 1, then we
move to 5, then 7. From 7, we switch to ar1 (7 is common)
and traverse 10 and 12.
Input: ar1[] = {10, 12}, ar2 = {5, 7, 9}

Output: 22
22 is sum of 10 and 12.
Since there is no common element, we need to take all
elements from the array with more sum.
Input: ar1[] = {2, 3, 7, 10, 12, 15, 30, 34}

ar2[] = {1, 5, 7, 8, 10, 15, 16, 19}
Output: 122
122 is sum of 1, 5, 7, 8, 10, 12, 15, 30, 34

The idea is to do something similar to merge process of merge sort. We need to calculate sums of elements
between all common points for both arrays. Whenever we see a common point, we compare the two sums
and add the maximum of two to the result. Following are detailed steps.
1) Initialize result as 0. Also initialize two variables sum1 and sum2 as 0. Here sum1 and sum2 are used to
store sum of element in ar1[] and ar2[] respectively. These sums are between two common points.
2) Now run a loop to traverse elements of both arrays. While traversing compare current elements of ar1[]
and ar2[].
2.a) If current element of ar1[] is smaller than current element of ar2[], then update sum1, else if current
element of ar2[] is smaller, then update sum2.
2.b) If current element of ar1[] and ar2[] are same, then take the maximum of sum1 and sum2 and add it
to the result. Also add the common element to the result.
#include<iostream>
// Utility function to find maximum of two integers

// This function returns the sum of elements on maximum path

// This function returns the sum of elements on maximum path
// from beginning to end
int maxPathSum(int ar1[], int ar2[], int m, int n)
{
// initialize indexes for ar1[] and ar2[]
int i = 0, j = 0;
// Initialize result and current sum through ar1[] and ar2[].

int result = 0, sum1 = 0, sum2 = 0;
// Below 3 loops are similar to merge in merge sort

{
// Add elements of ar1[] to sum1
if (ar1[i] < ar2[j])
sum1 += ar1[i++];
// Add elements of ar2[] to sum2

else if (ar1[i] > ar2[j])
sum2 += ar2[j++];
else // we reached a common point

{
// Take the maximum of two sums and add to result
result += max(sum1, sum2);
// Update sum1 and sum2 for elements after this

// intersection point
sum1 = 0, sum2 = 0;
// Keep updating result while there are more common

// elements
while (i < m && j < n && ar1[i] == ar2[j])
{
result = result + ar1[i++];
j++;
}
}
}
// Add remaining elements of ar1[]

while (i < m)
sum1 += ar1[i++];
// Add remaining elements of ar2[]

while (j < n)
sum2 += ar2[j++];
// Add maximum of two sums of remaining elements

result += max(sum1, sum2);
return result;
}

int main()
{
int ar1[] = {2, 3, 7, 10, 12, 15, 30, 34};
int ar2[] = {1, 5, 7, 8, 10, 15, 16, 19};
int m = sizeof(ar1)/sizeof(ar1[0]);
int n = sizeof(ar2)/sizeof(ar2[0]);
cout << maxPathSum(ar1, ar2, m, n);
return 0;
}

Output:

122

Time complexity: In every iteration of while loops, we process an element from either of the two arrays.
There are total m + n elements. Therefore, time complexity is O(m+n).
This article is contributed by Piyush Gupta. Please write comments if you find anything incorrect, or you
Find Excel column name from a given column number
MS Excel columns has a pattern like A, B, C, … ,Z, AA, AB, AC,…. ,AZ, BA, BB, … ZZ, AAA, AAB ….. etc. In
other words, column 1 is named as “A”, column 2 as “B”, column 27 as “AA”.
Given a column number, find its corresponding Excel column name. Following are more examples.
Input Output
26 Z
51 AY
52 AZ
80 CB
676 YZ
702 ZZ
705 AAC

Thanks to Mrigank Dembla for suggesting the below solution in a comment.
Suppose we have a number n, let’s say 28. so corresponding to it we need to print the column name. We need
to take remainder with 26.
If remainder with 26 comes out to be 0 (meaning 26, 52 and so on) then we put ‘Z’ in the output string and
new n becomes n/26 -1 because here we are considering 26 to be ‘Z’ while in actual it’s 25th with respect to
‘A’.
Similarly if the remainder comes out to be non zero. (like 1, 2, 3 and so on) then we need to just insert the
char accordingly in the string and do n = n/26.
Finally we reverse the string and print.
Example:
n = 700
Remainder (n%26) is 24. So we put ‘X’ in output string and n becomes n/26 which is 26.
Remainder (26%26) is 0. So we put ‘Z’ in output string and n becomes n/26 -1 which is 0.

#include<iostream>
#include<cstring>
#define MAX 50
// Function to print Excel column name for a given column number

void printString(int n)
{
char str[MAX]; // To store result (Excel column name)
int i = 0; // To store current index in str which is result
while (n>0)
{
// Find remainder
int rem = n%26;
// If remainder is 0, then a 'Z' must be there in output

if (rem==0)
{
str[i++] = 'Z';
n = (n/26)-1;
}
else // If remainder is non-zero
{
str[i++] = (rem-1) + 'A';
n = n/26;
}
}
str[i] = '\0';
// Reverse the string and print result

cout << strrev(str) << endl;
return;
}

int main()
{
printString(26);
printString(51);
printString(52);
printString(80);
printString(676);
printString(702);
printString(705);
return 0;
}

Output

Z
AY
AZ
CB
YZ
ZZ
AAC

This article is contributed by Kartik. Please write comments if you find anything incorrect, or you want to
Anagram Substring Search (Or Search for all permutations)
occurrences of pat[] and its permutations (or anagrams) in txt[]. You may assume that n > m.
Expected time complexity is O(n)
Examples:
1) Input: txt[] = "BACDGABCDA" pat[] = "ABCD"

Output: Found at Index 0
Found at Index 5
Found at Index 6
2) Input: txt[] = "AAABABAA" pat[] = "AABA"
Output: Found at Index 0
Found at Index 1
Found at Index 4

This problem is slightly different from standard pattern searching problem, here we need to search for
anagrams as well. Therefore, we cannot directly apply standard pattern searching algorithms like KMP,
Rabin Karp, Boyer Moore, etc.
A simple idea is to modify Rabin Karp Algorithm. For example we can keep the hash value as sum of ASCII
values of all characters under modulo of a big prime number. For every character of text, we can add the
current character to hash value and subtract the first character of previous window. This solution looks
good, but like standard Rabin Karp, the worst case time complexity of this solution is O(mn). The worst case
occurs when all hash values match and we one by one match all characters.
We can achieve O(n) time complexity under the assumption that alphabet size is fixed which is typically true
as we have maximum 256 possible characters in ASCII. The idea is to use two count arrays:
1) The first count array store frequencies of characters in pattern.

2) The second count array stores frequencies of characters in current window of text.
The important thing to note is, time complexity to compare two count arrays is O(1) as the number of
elements in them are fixed (independent of pattern and text sizes). Following are steps of this algorithm.
1) Store counts of frequencies of pattern in first count array countP[]. Also store counts of frequencies of
characters in first window of text in array countTW[].
2) Now run a loop from i = M to N-1. Do following in loop.

…..a) If the two count arrays are identical, we found an occurrence.
…..b) Increment count of current character of text in countTW[]
…..c) Decrement count of first character in previous window in countWT[]
3) The last window is not checked by above loop, so explicitly check it.

// C++ program to search all anagrams of a pattern in a text

#include<iostream>
#include<cstring>
#define MAX 256
// This function returns true if contents of arr1[] and arr2[]

// are same, otherwise false.
bool compare(char arr1[], char arr2[])
{
for (int i=0; i<MAX; i++)
if (arr1[i] != arr2[i])
return false;
return true;
}
// This function search for all permutations of pat[] in txt[]

{
int M = strlen(pat), N = strlen(txt);
// countP[]: Store count of all characters of pattern

// countTW[]: Store count of current window of text
char countP[MAX] = {0}, countTW[MAX] = {0};
for (int i = 0; i < M; i++)
{
(countP[pat[i]])++;
(countTW[txt[i]])++;
}
// Traverse through remaining characters of pattern

for (int i = M; i < N; i++)
{
// Compare counts of current window of text with
// counts of pattern[]
if (compare(countP, countTW))
cout << "Found at Index " << (i - M) << endl;
// Add current character to current window

(countTW[txt[i]])++;
// Remove the first character of previous window

countTW[txt[i-M]]--;
}
// Check for the last window in text

if (compare(countP, countTW))
cout << "Found at Index " << (N - M) << endl;
}

int main()
{
char txt[] = "BACDGABCDA";
char pat[] = "ABCD";
search(pat, txt);
return 0;
}

Output:
Found at Index 0
Found at Index 5
Found at Index 6

Given a sorted dictionary of an alien language, find order of characters
Given a sorted dictionary (array of words) of an alien language, find order of characters in the language.
Examples:

Input: words[] = {"baa", "abcd", "abca", "cab", "cad"}
Output: Order of characters is 'b', 'd', 'a', 'c'
Note that words are sorted and in the given language "baa"
comes before "abcd", therefore 'b' is before 'a' in output.
Similarly we can find other orders.
Input: words[] = {"caa", "aaa", "aab"}

Output: Order of characters is 'c', 'a', 'b'

The idea is to create a graph of characters and then find topological sorting of the created graph. Following
are the detailed steps.
1) Create a graph g with number of vertices equal to the size of alphabet in the given alien language. For
example, if the alphabet size is 5, then there can be 5 characters in words. Initially there are no edges in
graph.
2) Do following for every pair of adjacent words in given sorted array.

…..a) Let the current pair of words be word1 and word2. One by one compare characters of both words and
find the first mismatching characters.
…..b) Create an edge in g from mismatching character of word1 to that of word2.
3) Print topological sorting of the above created graph.
// A C++ program to order of characters in an alien language

#include<iostream>
#include <list>
#include <stack>
#include <cstring>
// Class to represent a graph

class Graph
{
// Pointer to an array containing adjacency listsList

list<int> *adj;
// A function used by topologicalSort

public:

// prints a Topological Sort of the complete graph

void topologicalSort();
};
Graph::Graph(int V)
{
this->V = V;
}

{
}
// A recursive function used by topologicalSort

{
// Mark the current node as visited.
visited[v] = true;

if (!visited[*i])
topologicalSortUtil(*i, visited, Stack);
// Push current vertex to stack which stores result

Stack.push(v);
}
// The function to do Topological Sort. It uses recursive topologicalSortUtil()

void Graph::topologicalSort()
{
stack<int> Stack;

for (int i = 0; i < V; i++)
visited[i] = false;

for (int i = 0; i < V; i++)

{
cout << (char) ('a' + Stack.top()) << " ";
Stack.pop();
}
}

{
}
// This function fidns and prints order of characer from a sorted

// array of words. n is size of words[]. alpha is set of possible
// alphabets.
// For simplicity, this function is written in a way that only
// first 'alpha' characters can be there in words array. For
// first 'alpha' characters can be there in words array. For
// example if alpha is 7, then words[] should have only 'a', 'b',
// 'c' 'd', 'e', 'f', 'g'
void printOrder(string words[], int n, int alpha)
{
// Create a graph with 'aplha' edges
Graph g(alpha);
// Process all adjacent pairs of words and create a graph

for (int i = 0; i < n-1; i++)
{
// Take the current two words and find the first mismatching
// character
string word1 = words[i], word2 = words[i+1];
for (int j = 0; j < min(word1.length(), word2.length()); j++)
{
// If we find a mismatching character, then add an edge
// from character of word1 to that of word2
if (word1[j] != word2[j])
{
g.addEdge(word1[j]-'a', word2[j]-'a');
break;
}
}
}
// Print topological sort of the above created graph

g.topologicalSort();
}

int main()
{
string words[] = {"caa", "aaa", "aab"};
printOrder(words, 3, 3);
return 0;
}

Output:

c a b

Time Complexity: The first step to create a graph takes O(n + alhpa) time where n is number of given
words and alpha is number of characters in given alphabet. The second step is also topological sorting. Note
that there would be alpha vertices and at-most (n-1) edges in the graph. The time complexity of topological
sorting is O(V+E) which is O(n + aplha) here. So overall time complexity is O(n + aplha) + O(n + aplha)
which is O(n + aplha).
Exercise:
The above code doesn’t work when the input is not valid. For example {“aba”, “bba”, “aaa”} is not valid,
because from first two words, we can deduce ‘a’ should appear before ‘b’, but from last two words, we can
deduce ‘b’ should appear before ‘a’ which is not possible. Extend the above program to handle invalid inputs
and generate the output as “Not valid”.
Given an array of strings, find if the strings can be chained to form a circle
Given an array of strings, find if the given strings can be chained to form a circle. A string X can be put before
another string Y in circle if the last character of X is same as first character of Y.
Examples:
Input: arr[] = {"geek", "king"}

Output: Yes, the given strings can be chained.
Note that the last character of first string is same
as first character of second string and vice versa is
also true.
Input: arr[] = {"for", "geek", "rig", "kaf"}

The strings can be chained as "for", "rig", "geek"
and "kaf"
Input: arr[] = {"aab", "bac", "aaa", "cda"}

The strings can be chained as "aaa", "aab", "bac"
and "cda"
Input: arr[] = {"aaa", "bbb", "baa", "aab"};

The strings can be chained as "aaa", "aab", "bbb"
and "baa"
Input: arr[] = {"aaa"};

Output: Yes
Input: arr[] = {"aaa", "bbb"};

Output: No

The idea is to create a directed graph of all characters and then find if their is an
eulerian circuit in the graph
or not. If there is an eulerian circuit, then chain can be formed, otherwise not.
Note that a directed graph has eulerian circuit only if in degree and out degree of every vertex is same, and
all non-zero degree vertices form a single strongly connected component.
Following are detailed steps of the algorithm.
1) Create a directed graph g with number of vertices equal to the size of alphabet. We have created a graph
with 26 vertices in the below program.
2) Do following for every string in the given array of strings.

…..a) Add an edge from first character to last character of the given graph.
3) If the created graph has eulerian circuit, then return true, else return false.
// A C++ program to check if a given directed graph is Eulerian or not

#include<iostream>
#include <list>
#define CHARS 26

class Graph
{
int *in;
public:
Graph(int V);
~Graph() { delete [] adj; delete [] in; }

void addEdge(int v, int w) { adj[v].push_back(w); (in[w])++; }

bool isEulerianCycle();

bool isSC();

};
Graph::Graph(int V)
{
this->V = V;
in = new int[V];
for (int i = 0; i < V; i++)
in[i] = 0;
}
/* This function returns true if the directed graph has an eulerian

cycle, otherwise returns false */
bool Graph::isEulerianCycle()
{
if (isSC() == false)
return false;
// Check if in degree and out degree of every vertex is same

for (int i = 0; i < V; i++)
if (adj[i].size() != in[i])
return false;
return true;
}
// A recursive function to do DFS starting from v

{
visited[v] = true;

if (!visited[*i])
}

// This function is needed in isSC()
{
Graph g(V);
for (int v = 0; v < V; v++)
{
{
(g.in[v])++;
}
}
return g;
}
// This function returns true if all non-zero degree vertices of

// graph are strongly connected. Please refer
// http://www.geeksforgeeks.org/connectivity-in-a-directed-graph/
bool Graph::isSC()
{
bool visited[V];
for (int i = 0; i < V; i++)
visited[i] = false;
// Find the first vertex with non-zero degree

int n;
for (n = 0; n < V; n++)
if (adj[n].size() > 0)
break;
// Do DFS traversal starting from first non zero degree vertex.

DFSUtil(n, visited);

for (int i = 0; i < V; i++)
if (adj[i].size() > 0 && visited[i] == false)
return false;


for (int i = 0; i < V; i++)
visited[i] = false;
// Do DFS for reversed graph starting from first vertex.

gr.DFSUtil(n, visited);

// return false
for (int i = 0; i < V; i++)
return false;
return true;
}
}
// This function takes an of strings and returns true

// if the given array of strings can be chained to
// form cycle
bool canBeChained(string arr[], int n)
{
// Create a graph with 'aplha' edges
Graph g(CHARS);
// Create an edge from first character to last character

// of every string
for (int i = 0; i < n; i++)
{
string s = arr[i];
g.addEdge(s[0]-'a', s[s.length()-1]-'a');
}
// The given array of strings can be chained if there

// is an eulerian cycle in the created graph
return g.isEulerianCycle();
}

int main()
{
string arr1[] = {"for", "geek", "rig", "kaf"};
canBeChained(arr1, n1)? cout << "Can be chained \n" :
cout << "Can't be chained \n";
string arr2[] = {"aab", "abb"};

canBeChained(arr2, n2)? cout << "Can be chained \n" :
cout << "Can't be chained \n";
return 0;
}

Output:

Can be chained
Can't be chained

An Interesting Method to Generate Binary Numbers from 1 to n
Given a number n, write a function that generates and prints all binary numbers with decimal values from 1
to n.
Examples:
Input: n = 2
Output: 1, 10
Input: n = 5
Output: 1, 10, 11, 100, 101

A simple method is to run a loop from 1 to n, call decimal to binary inside the loop.
Following is an interesting method that uses queue data structure to print binary numbers. Thanks to Vivek
for suggesting this approach.
1) Create an empty queue of strings
2) Enqueue the first binary number “1” to queue.
3) Now run a loop for generating and printing n binary numbers.
……a) Dequeue and Print the front of queue.
……b) Append “0” at the end of front item and enqueue it.
……c) Append “1” at the end of front item and enqueue it.

// C++ program to generate binary numbers from 1 to n

#include <iostream>
#include <queue>
// This function uses queue data structure to print binary numbers

void generatePrintBinary(int n)
{
// Create an empty queue of strings
queue<string> q;
// Enqueue the first binary number

q.push("1");
// This loops is like BFS of a tree with 1 as root

// 0 as left child and 1 as right child and so on
while (n--)
{
// print the front of queue
string s1 = q.front();
q.pop();
cout << s1 << "\n";
string s2 = s1; // Store s1 before changing it

// Append "0" to s1 and enqueue it
q.push(s1.append("0"));
// Append "1" to s2 and enqueue it. Note that s2 contains

// the previous front
q.push(s2.append("1"));
}
}

int main()
{
int n = 10;
generatePrintBinary(n);
return 0;
}

Output:

1
10
11
100
101
110
111
1000
1001
1010

This article is contributed by Abhishek. Please write comments if you find anything incorrect, or you want
Inorder predecessor and successor for a given key in BST
I recently encountered with a question in an interview at e-commerce company. The interviewer asked the
following question:
There is BST given with root node with key part as integer only. The structure of each node is as follows:
struct Node
{
int key;
struct Node *left, *right ;
};

You need to find the inorder successor and predecessor of a given key. In case the given key is not found in
BST, then return the two values within which this key will lie.
Following is the algorithm to reach the desired result. Its a recursive method:
Input: root node, key

output: predecessor node, successor node
1. If root is NULL
then return
2. if key is found then
a. If its left subtree is not null
Then predecessor will be the right most
child of left subtree or left child itself.
b. If its right subtree is not null
The successor will be the left most child
of right subtree or right child itself.
return
3. If key is smaller then root node
set the successor as root
search recursively into left subtree
else
set the predecessor as root
search recursively into right subtree

Following is C++ implementation of the above algorithm:
// C++ program to find predecessor and successor in a BST

#include <iostream>
// BST Node
struct Node
{
int key;
};
// This function finds predecessor and successor of key in BST.

// It sets pre and suc as predecessor and successor respectively
void findPreSuc(Node* root, Node*& pre, Node*& suc, int key)
{
// Base case
if (root == NULL) return ;
// If key is present at root

if (root->key == key)
{
// the maximum value in left subtree is predecessor
{
Node* tmp = root->left;
while (tmp->right)
tmp = tmp->right;
pre = tmp ;
}
// the minimum value in right subtree is successor

if (root->right != NULL)
{
Node* tmp = root->right ;
while (tmp->left)
tmp = tmp->left ;
suc = tmp ;
}
return ;
}
// If key is smaller than root's key, go to left subtree

{
suc = root ;
findPreSuc(root->left, pre, suc, key) ;
}
else // go to right subtree
{
pre = root ;
findPreSuc(root->right, pre, suc, key) ;
}
}

Node *newNode(int item)
{
temp->key = item;
return temp;
}
/* A utility function to insert a new node with given key in BST */

Node* insert(Node* node, int key)
{
if (node == NULL) return newNode(key);
else
return node;
}

int main()
{
int key = 65; //Key to be searched in BST

50
/ \
30 70
/ \ / \
20 40 60 80 */
Node *root = NULL;
insert(root, 30);
insert(root, 20);
insert(root, 40);
insert(root, 70);
insert(root, 60);
insert(root, 80);
Node* pre = NULL, *suc = NULL;
findPreSuc(root, pre, suc, key);

if (pre != NULL)
cout << "Predecessor is " << pre->key << endl;
else
cout << "No Predecessor";
if (suc != NULL)
cout << "Successor is " << suc->key;
else
cout << "No Successor";
return 0;
}

Output:

Predecessor is 60
Successor is 70

This article is contributed by algoLover. Please write comments if you find anything incorrect, or you want
Check if a binary tree is subtree of another binary tree | Set 2
Given two binary trees, check if the first tree is subtree of the second one. A subtree of a tree T is a tree S
consisting of a node in T and all of its descendants in T.
The subtree corresponding to the root node is the entire tree; the subtree corresponding to any other node is
called a proper subtree.
For example, in the following case, Tree1 is a subtree of Tree2.
Tree1
x
/ \
a b
\
c
Tree2
z
/ \
x e
/ \ \
a b k
\
c

We have discussed a O(n2) solution for this problem. In this post a O(n) solution is discussed. The idea is
based on the fact that inorder and preorder/postorder uniquely identify a binary tree. Tree S is a subtree of T
if both inorder and preorder traversals of S arew substrings of inorder and preorder traversals of T
respectively.
Following are detailed steps.
1) Find inorder and preorder traversals of T, store them in two auxiliary arrays inT[] and preT[].
2) Find inorder and preorder traversals of S, store them in two auxiliary arrays inS[] and preS[].
3) If inS[] is a subarray of inT[] and preS[] is a subarray preT[], then S is a subtree of T. Else not.
We can also use postorder traversal in place of preorder in the above algorithm.
Let us consider the above example

Inorder and Preorder traversals of the big tree are.

inT[] = {a, c, x, b, z, e, k}
preT[] = {z, x, a, c, b, e, k}
Inorder and Preorder traversals of small tree are

inS[] = {a, c, x, b}
preS[] = {x, a, c, b}
We can easily figure out that inS[] is a subarray of

inT[] and preS[] is a subarray of preT[].

EDIT
The above algorithm doesn't work for cases where a tree is present
in another tree, but not as a subtree. Consider the following example.
Tree1
x
/ \
a b
/
c
Tree2
x
/ \
a b
/ \
c d
Inorder and Preorder traversals of the big tree or Tree2 are.
Inorder and Preorder traversals of small tree or Tree1 are
The Tree2 is not a subtree of Tree1, but inS[] and preS[] are
subarrays of inT[] and preT[] respectively.

The above algorithm can be extended to handle such cases by adding a special character whenever we
encounter NULL in inorder and preorder traversals. Thanks to Shivam Goel for suggesting this extension.
#include <iostream>
#include <cstring>
#define MAX 100
// Structure of a tree node

struct Node
{
char key;
};

Node *newNode(char item)
{
temp->key = item;
return temp;
}
// A utility function to store inorder traversal of tree rooted

// with root in an array arr[]. Note that i is passed as reference
void storeInorder(Node *root, char arr[], int &i)
{
if (root == NULL)
{
arr[i++] = '$';
return;
}
storeInorder(root->left, arr, i);
arr[i++] = root->key;
storeInorder(root->right, arr, i);
}
// A utility function to store preorder traversal of tree rooted

// with root in an array arr[]. Note that i is passed as reference
void storePreOrder(Node *root, char arr[], int &i)
{
if (root == NULL)
{
arr[i++] = '$';
return;
}
arr[i++] = root->key;
storePreOrder(root->left, arr, i);
storePreOrder(root->right, arr, i);
}
/* This function returns true if S is a subtree of T, otherwise false */

bool isSubtree(Node *T, Node *S)
{
/* base cases */
if (S == NULL) return true;
if (T == NULL) return false;
// Store Inorder traversals of T and S in inT[0..m-1]

// and inS[0..n-1] respectively
int m = 0, n = 0;
char inT[MAX], inS[MAX];
storeInorder(T, inT, m);
storeInorder(S, inS, n);
inT[m] = '\0', inS[n] = '\0';
// If inS[] is not a substring of preS[], return false

if (strstr(inT, inS) == NULL)
return false;
// Store Preorder traversals of T and S in inT[0..m-1]

// and inS[0..n-1] respectively
m = 0, n = 0;
char preT[MAX], preS[MAX];
storePreOrder(T, preT, m);
storePreOrder(S, preS, n);
preT[m] = '\0', preS[n] = '\0';
// If inS[] is not a substring of preS[], return false

// Else return true
return (strstr(preT, preS) != NULL);
}

int main()
{
Node *T = newNode('a');
T->left = newNode('b');
T->right = newNode('d');
T->left->left = newNode('c');
T->right->right = newNode('e');
Node *S = newNode('a');
S->left = newNode('b');
S->left->left = newNode('c');
S->right = newNode('d');
if (isSubtree(T, S))
cout << "Yes: S is a subtree of T";
else
cout << "No: S is NOT a subtree of T";
return 0;
}
Output:

No: S is NOT a subtree of T

Time Complexity: Inorder and Preorder traversals of Binary Tree take O(n) time. The function strstr() can
also be implemented in O(n) time using KMP string matching algorithm.
Thanks to Ashwini Singh for suggesting this method. Please write comments if you find anything
Euler Circuit in a Directed Graph
Eulerian Path is a path in graph that visits every edge exactly once. Eulerian Circuit is an Eulerian Path
which starts and ends on the same vertex.
A graph is said to be eulerian if it has eulerian cycle. We have discussed eulerian circuit for an undirected
graph. In this post, same is discussed for a directed graph.
For example, the following graph has eulerian cycle as {1, 0, 3, 4, 0, 2, 1}
How to check if a directed graph is eulerian?

A directed graph has an eulerian cycle if following conditions are true (Source: Wiki)
1) All vertices with nonzero degree belong to a single strongly connected component.
2) In degree and out degree of every vertex is same.
We can detect singly connected component using Kosaraju’s DFS based simple algorithm.
To compare in degree and out degree, we need to store in degree an out degree of every vertex. Out degree
can be obtained by size of adjacency list. In degree can be stored by creating an array of size equal to number
of vertices.
// A C++ program to check if a given directed graph is Eulerian or not

#include<iostream>
#include <list>
#define CHARS 26

class Graph
{
int *in;
public:
Graph(int V);
~Graph() { delete [] adj; delete [] in; }

void addEdge(int v, int w) { adj[v].push_back(w); (in[w])++; }

bool isEulerianCycle();

bool isSC();

};
Graph::Graph(int V)
{
this->V = V;
in = new int[V];
for (int i = 0; i < V; i++)
in[i] = 0;
}
/* This function returns true if the directed graph has an eulerian

cycle, otherwise returns false */
bool Graph::isEulerianCycle()
{
if (isSC() == false)
return false;
// Check if in degree and out degree of every vertex is same

for (int i = 0; i < V; i++)
if (adj[i].size() != in[i])
return false;
return true;
}
// A recursive function to do DFS starting from v

{
visited[v] = true;

if (!visited[*i])
}

// This function is needed in isSC()
{
Graph g(V);
for (int v = 0; v < V; v++)
{
{
(g.in[v])++;
}
}
return g;
}
// This function returns true if all non-zero degree vertices of

// graph are strongly connected (Please refer
// http://www.geeksforgeeks.org/connectivity-in-a-directed-graph/ )
bool Graph::isSC()
{
bool visited[V];
for (int i = 0; i < V; i++)
visited[i] = false;
// Find the first vertex with non-zero degree

int n;
for (n = 0; n < V; n++)
if (adj[n].size() > 0)
break;
// Do DFS traversal starting from first non zero degree vertex.

DFSUtil(n, visited);

for (int i = 0; i < V; i++)
return false;


for (int i = 0; i < V; i++)
visited[i] = false;
// Do DFS for reversed graph starting from first vertex.

gr.DFSUtil(n, visited);

// return false
for (int i = 0; i < V; i++)
return false;
return true;
}

int main()
{
Graph g(5);
g.addEdge(1, 0);
g.addEdge(0, 2);
g.addEdge(2, 1);
g.addEdge(0, 3);
g.addEdge(3, 4);
g.addEdge(4, 0);
if (g.isEulerianCycle())
cout << "Given directed graph is eulerian \n";
else
cout << "Given directed graph is NOT eulerian \n";
return 0;
}

Output:

Given directed graph is eulerian

Time complexity of the above implementation is O(V + E) as Kosaraju’s algorithm takes O(V + E) time. After
running Kosaraju’s algorithm we traverse all vertices and compare in degree with out degree which takes
O(V) time.
See following as an application of this.

Find if the given array of strings can be chained to form a circle.
discussed above.
Check if two nodes are cousins in a Binary Tree
Given the binary Tree and the two nodes say ‘a’ and ‘b’, determine whether the two nodes are cousins of each
other or not.
Two nodes are cousins of each other if they are at same level and have different parents.
Example
6
/ \
3 5
/ \ / \
7 8 1 3
Say two node be 7 and 1, result is TRUE.
Say two nodes are 3 and 5, result is FALSE.
Say two nodes are 7 and 5, result is FALSE.

The idea is to find level of one of the nodes. Using the found level, check if ‘a’ and ‘b’ are at this level. If ‘a’
and ‘b’ are at given level, then finally check if they are not children of same parent.
// C program to check if two Nodes in a binary tree are cousins

#include <stdio.h>
#include <stdlib.h>

struct Node
{
int data;
};

{
struct Node *temp = (struct Node *)malloc(sizeof(struct Node));
temp->data = item;
return temp;
}
// Recursive function to check if two Nodes are siblings

int isSibling(struct Node *root, struct Node *a, struct Node *b)
{
// Base case
if (root==NULL) return 0;
return ((root->left==a && root->right==b)||

(root->left==b && root->right==a)||
isSibling(root->left, a, b)||
isSibling(root->right, a, b));
}
// Recursive function to find level of Node 'ptr' in a binary tree
int level(struct Node *root, struct Node *ptr, int lev)
{
// base cases
if (root == NULL) return 0;
if (root == ptr) return lev;
// Return level if Node is present in left subtree

int l = level(root->left, ptr, lev+1);
if (l != 0) return l;
// Else search in right subtree

return level(root->right, ptr, lev+1);
}
// Returns 1 if a and b are cousins, otherwise 0

int isCousin(struct Node *root, struct Node *a, struct Node *b)
{
//1. The two Nodes should be on the same level in the binary tree.
//2. The two Nodes should not be siblings (means that they should
// not have the same parent Node).
if ((level(root,a,1) == level(root,b,1)) && !(isSibling(root,a,b)))
return 1;
else return 0;
}

int main()
{
struct Node *Node1,*Node2;

Node1 = root->left->left;
Node2 = root->right->right;
isCousin(root,Node1,Node2)? puts("Yes"): puts("No");
return 0;
}

Ouput:

Yes

Time Complexity of the above solution is O(n) as it does at most three traversals of binary tree.
This article is contributed by Ayush Srivastava. Please write comments if you find anything incorrect, or
Search in an almost sorted array
Given an array which is sorted, but after sorting some elements are moved to either of the adjacent
positions, i.e., arr[i] may be present at arr[i+1] or arr[i-1]. Write an efficient function to search an element in
this array. Basically the element arr[i] can only be swapped with either arr[i+1] or arr[i-1].
For example consider the array {2, 3, 10, 4, 40}, 4 is moved to next position and 10 is moved to previous
position.
Example:
Input: arr[] = {10, 3, 40, 20, 50, 80, 70}, key = 40

Output: 2
Output is index of 40 in given array
Input: arr[] = {10, 3, 40, 20, 50, 80, 70}, key = 90

Output: -1
-1 is returned to indicate element is not present

A simple solution is to linearly search the given key in given array. Time complexity of this solution is O(n).
We cab modify binary search to do it in O(Logn) time.
The idea is to compare the key with middle 3 elements, if present then return the index. If not present, then
compare the key with middle element to decide whether to go in left half or right half. Comparing with
middle element is enough as all the elements after mid+2 must be greater than element mid and all elements
before mid-2 must be smaller than mid element.

// C++ program to find an element in an almost sorted array

#include <stdio.h>
// A recursive binary search based function. It returns index of x in

// given array arr[l..r] is present, otherwise -1
int binarySearch(int arr[], int l, int r, int x)
{
if (r >= l)
{
int mid = l + (r - l)/2;
// If the element is present at one of the middle 3 positions

if (arr[mid] == x) return mid;
if (mid > l && arr[mid-1] == x) return (mid - 1);
if (mid < r && arr[mid+1] == x) return (mid + 1);
// If element is smaller than mid, then it can only be present

// in left subarray
if (arr[mid] > x) return binarySearch(arr, l, mid-2, x);
// Else the element can only be present in right subarray

return binarySearch(arr, mid+2, r, x);
}
// We reach here when element is not present in array

return -1;
}

int main(void)
{
int arr[] = {3, 2, 10, 4, 40};
int n = sizeof(arr)/ sizeof(arr[0]);
int x = 4;
int result = binarySearch(arr, 0, n-1, x);
(result == -1)? printf("Element is not present in array")
: printf("Element is present at index %d", result);
return 0;
}

Output:

Element is present at index 3

Time complexity of the above function is O(Logn).
Count all possible walks from a source to a destination with exactly k edges
Given a directed graph and two vertices ‘u’ and ‘v’ in it, count all possible walks from ‘u’ to ‘v’ with exactly k
edges on the walk.
The graph is given as adjacency matrix representation where value of graph[i][j] as 1 indicates that there is
an edge from vertex i to vertex j and a value 0 indicates no edge from i to j.
For example consider the following graph. Let source ‘u’ be vertex 0, destination ‘v’ be 3 and k be 2. The
output should be 2 as there are two walk from 0 to 3 with exactly 2 edges. The walks are {0, 2, 3} and {0, 1,
3}
A simple solution is to start from u, go to all adjacent vertices and recur for adjacent vertices with k as k-1,
source as adjacent vertex and destination as v. Following is C++ implementation of this simple solution.

// C++ program to count walks from u to v with exactly k edges

#include <iostream>

#define V 4
// A naive recursive function to count walks from u to v with k edges

int countwalks(int graph[][V], int u, int v, int k)
{
// Base cases
if (k == 0 && u == v) return 1;
if (k == 1 && graph[u][v]) return 1;
if (k <= 0) return 0;
int count = 0;
// Go to all adjacents of u and recur

for (int i = 0; i < V; i++)
if (graph[u][i]) // Check if is adjacent of u
count += countwalks(graph, i, v, k-1);
return count;
}

int main()
{
/* Let us create the graph shown in above diagram*/
int graph[V][V] = { {0, 1, 1, 1},
{0, 0, 0, 1},
{0, 0, 0, 1},
{0, 0, 0, 0}
};
int u = 0, v = 3, k = 2;
cout << countwalks(graph, u, v, k);
return 0;
}

Output:
The worst case time complexity of the above function is O(Vk) where V is the number of vertices in the given
graph. We can simply analyze the time complexity by drawing recursion tree. The worst occurs for a
complete graph. In worst case, every internal node of recursion tree would have exactly n children.
We can optimize the above solution using Dynamic Programming. The idea is to build a 3D table where
first dimension is source, second dimension is destination, third dimension is number of edges from source
to destination, and the value is count of walks. Like other Dynamic Programming problems, we fill the 3D
table in bottom up manner.

// C++ program to count walks from u to v with exactly k edges

#include <iostream>

#define V 4
// A Dynamic programming based function to count walks from u

// to v with k edges
int countwalks(int graph[][V], int u, int v, int k)
{
// Table to be filled up using DP. The value count[i][j][e] will
// store count of possible walks from i to j with exactly k edges
int count[V][V][k+1];
// Loop for number of edges from 0 to k

for (int e = 0; e <= k; e++)
{
for (int i = 0; i < V; i++) // for source
{
for (int j = 0; j < V; j++) // for destination
{
// initialize value
count[i][j][e] = 0;
// from base cases

if (e == 0 && i == j)
count[i][j][e] = 1;
if (e == 1 && graph[i][j])
count[i][j][e] = 1;
// go to adjacent only when number of edges is more than 1

if (e > 1)
{
for (int a = 0; a < V; a++) // adjacent of source i
if (graph[i][a])
count[i][j][e] += count[a][j][e-1];
}
}
}
}
return count[u][v][k];
}

int main()
{
int graph[V][V] = { {0, 1, 1, 1},
{0, 0, 0, 1},
{0, 0, 0, 1},
{0, 0, 0, 0}
};
int u = 0, v = 3, k = 2;
cout << countwalks(graph, u, v, k);
return 0;
}

Output:

2

Time complexity of the above DP based solution is O(V3K) which is much better than the naive solution.
We can also use Divide and Conquer to solve the above problem in O(V3Logk) time. The count of walks of
length k from u to v is the [u][v]’th entry in (graph[V][V])k. We can calculate power of by doing O(Logk)
multiplication by using the divide and conquer technique to calculate power. A multiplication between two
matrices of size V x V takes O(V3) time. Therefore overall time complexity of this method is O(V 3Logk).
discussed above.
A Problem in Many Binary Search Implementations
Consider the following C implementation of Binary Search function, is there anything wrong in this?
// A iterative binary search function. It returns location of x in

// given array arr[l..r] if present, otherwise -1
{
while (l <= r)
{
// find index of middle element
int m = (l+r)/2;
// Check if x is present at mid

if (arr[m] == x) return m;
// If x greater, ignore left half

if (arr[m] < x) l = m + 1;
// If x is smaller, ignore right half

else r = m - 1;
}
// if we reach here, then element was not present

return -1;
}

The above looks fine except one subtle thing, the expression “m = (l+r)/2″. It fails for large values of l and r.
Specifically, it fails if the sum of low and high is greater than the maximum positive int value (231 – 1). The
sum overflows to a negative value, and the value stays negative when divided by two. In C this causes an
array index out of bounds with unpredictable results.
What is the way to resolve this problem?

Following is one way:
int mid = low + ((high - low) / 2);

Probably faster, and arguably as clear is (works only in Java, refer this):
int mid = (low + high) >>> 1;

In C and C++ (where you don’t have the >>> operator), you can do this:
mid = ((unsigned int)low + (unsigned int)high)) >> 1

The similar problem appears in Merge Sort as well.
The above content is taken from google reasearch blog.
Please refer this as well, it points out that the above solutions may not always work.
The above problem occurs when array length is 230 or greater and the search repeatedly moves to second
half of the array. This much size of array is not likely to appear most of the time. For example, when we try
the below program with 32 bit Code Blocks compiler, we get compiler error.
int main()
{
int arr[1<<30];
return 0;
}

Output:

error: size of array 'arr' is too large

Even when we try boolean array, the program compiles fine, but crashes when run in Windows 7.0 and
Code
Blocks 32 bit compiler
int main()
{
bool arr[1<<30];
return 0;
}

Output: No compiler error, but crashes at run time.
Sources:
http://googleresearch.blogspot.in/2006/06/extra-extra-read-all-about-it-nearly.html
http://locklessinc.com/articles/binary_search/
Count ways to reach the n’th stair
There are n stairs, a person standing at the bottom wants to reach the top. The person can climb either 1
stair or 2 stairs at a time. Count the number of ways, the person can reach the top.
Consider the example shown in diagram. The value of n is 3. There are 3 ways to reach the top. The diagram
is taken from Easier Fibonacci puzzles
More Examples:
Input: n = 1
Output: 1
There is only one way to climb 1 stair
Input: n = 2
Output: 2
There are two ways: (1, 1) and (2)
Input: n = 4
Output: 5
(1, 1, 1, 1), (1, 1, 2), (2, 1, 1), (1, 2, 1), (2, 2)

We can easily find recursive nature in above problem. The person can reach n’th stair from either (n-1)’th
stair or from (n-2)’th stair. Let the total number of ways to reach n’t stair be ‘ways(n)’. The value of ‘ways(n)’
can be written as following.
ways(n) = ways(n-1) + ways(n-2)

The above expression is actually the expression for Fibonacci numbers, but there is one thing to notice, the
value of ways(n) is equal to fibonacci(n+1).
ways(1) = fib(2) = 1
ways(2) = fib(3) = 2
ways(3) = fib(4) = 3
So we can use function for fibonacci numbers to find the value of ways(n). Following is C++ implementation
of the above idea.
// A C program to count number of ways to reach n't stair when

// a person can climb 1, 2, ..m stairs at a time.
#include<stdio.h>
// A simple recursive program to find n'th fibonacci number

int fib(int n)
{
if (n <= 1)
return n;
}
// Returns number of ways to reach s'th stair

int countWays(int s)
{
return fib(s + 1);
}

int main ()
{
int s = 4;
printf("Number of ways = %d", countWays(s));
getchar();
return 0;
}

Output:

Number of ways = 5

The time complexity of the above implementation is exponential (golden ratio raised to power n). It can be
optimized to work in O(Logn) time using the previously discussed Fibonacci function optimizations.
Generalization of the above problem

How to count number of ways if the person can climb up to m stairs for a given value m? For example if m is
4, the person can climb 1 stair or 2 stairs or 3 stairs or 4 stairs at a time.
We can write the recurrence as following.
ways(n, m) = ways(n-1, m) + ways(n-2, m) + ... ways(n-m, m)

Following is C++ implementation of above recurrence.


// a person can climb either 1 or 2 stairs at a time
#include<stdio.h>
// A recursive function used by countWays

int countWaysUtil(int n, int m)
{
if (n <= 1)
return n;
int res = 0;
for (int i = 1; i<=m && i<=n; i++)
res += countWaysUtil(n-i, m);
return res;
}

int countWays(int s, int m)
{
return countWaysUtil(s+1, m);
}

int main ()
{
int s = 4, m = 2;
printf("Nuber of ways = %d", countWays(s, m));
return 0;
}

Output:

Number of ways = 5

The time complexity of above solution is exponential. It can be optimized to O(mn) by using dynamic
programming. Following is dynamic programming based solution. We build a table res[] in bottom up
manner.


// a person can climb 1, 2, ..m stairs at a time
#include<stdio.h>
// A recursive function used by countWays

int countWaysUtil(int n, int m)
{
int res[n];
res[0] = 1; res[1] = 1;
{
res[i] = 0;
for (int j=1; j<=m && j<=i; j++)
res[i] += res[i-j];
}
return res[n-1];
}

int countWays(int s, int m)
{
return countWaysUtil(s+1, m);
}

int main ()
{
int s = 4, m = 2;
printf("Nuber of ways = %d", countWays(s, m));
return 0;
}

Output:

Number of ways = 5

Sort an array according to the order defined by another array
Given two arrays A1[] and A2[], sort A1 in such a way that the relative order among the elements will be
same as those are in A2. For the elements not present in A2, append them at last in sorted order.
Input: A1[] = {2, 1, 2, 5, 7, 1, 9, 3, 6, 8, 8}

A2[] = {2, 1, 8, 3}
Output: A1[] = {2, 2, 1, 1, 8, 8, 3, 5, 6, 7, 9}

The code should handle all cases like number of elements in A2[] may be more or less compared to A1[].
A2[] may have some elements which may not be there in A1[] and vice versa is also possible.
Source: Amazon Interview | Set 110 (On-Campus)
Method 1 (Using Sorting and Binary Search)

Let size of A1[] be m and size of A2[] be n.
1) Create a temporary array temp of size m and copy contents of A1[] to it.
2) Create another array visited[] and initialize all entries in it as false. visited[] is used to mark those
elements in temp[] which are copied to A1[].
3) Sort temp[]
4) Initialize the output index ind as 0.
5) Do following for every element of A2[i] in A2[]
…..a) Binary search for all occurrences of A2[i] in temp[], if present then copy all occurrences to A1[ind] and
increment ind. Also mark the copied elements visited[]
6) Copy all unvisited elements from temp[] to A1[].
Time complexity: The steps 1 and 2 require O(m) time. Step 3 requires O(mLogm) time. Step 5 requires
O(nLogm) time. Therefore overall time complexity is O(m + nLogm).
Thanks to vivek for suggesting this method. Following is C++ implementation of above algorithm.
// A C++ program to sort an array according to the order defined

// by another array
#include <iostream>
/* A Binary Search based function to find index of FIRST occurrence

of x in arr[]. If x is not present, then it returns -1 */
int first(int arr[], int low, int high, int x, int n)
{
if (high >= low)
{
int mid = low + (high-low)/2; /* (low + high)/2; */
if ((mid == 0 || x > arr[mid-1]) && arr[mid] == x)
return mid;
if (x > arr[mid])
return first(arr, (mid + 1), high, x, n);
return first(arr, low, (mid -1), x, n);
}
return -1;
}
// Sort A1[0..m-1] according to the order defined by A2[0..n-1].
void sortAccording(int A1[], int A2[], int m, int n)
{
// The temp array is used to store a copy of A1[] and visited[]
// is used mark the visited elements in temp[].
int temp[m], visited[m];
{
temp[i] = A1[i];
visited[i] = 0;
}
// Sort elements in temp

sort(temp, temp + m);
int ind = 0; // for index of output which is sorted A1[]
// Consider all elements of A2[], find them in temp[]

// and copy to A1[] in order.
{
// Find index of the first occurrence of A2[i] in temp
int f = first(temp, 0, m-1, A2[i], m);
// If not present, no need to proceed

if (f == -1) continue;
// Copy all occurrences of A2[i] to A1[]

for (int j = f; (j<m && temp[j]==A2[i]); j++)
{
A1[ind++] = temp[j];
visited[j] = 1;
}
}
// Now copy all items of temp[] which are not present in A2[]
if (visited[i] == 0)
A1[ind++] = temp[i];
}
// Utility function to print an array

{
cout << arr[i] << " ";
cout << endl;
}

int main()
{
int A1[] = {2, 1, 2, 5, 7, 1, 9, 3, 6, 8, 8};
int A2[] = {2, 1, 8, 3};
int m = sizeof(A1)/sizeof(A1[0]);
int n = sizeof(A2)/sizeof(A2[0]);
sortAccording(A1, A2, m, n);
printArray(A1, m);
return 0;
}

Output:

Sorted array is
2 2 1 1 8 8 3 5 6 7 9

Method 2 (Using Self-Balancing Binary Search Tree)

We can also use a self balancing BST like AVL Tree, Red Black Tree, etc. Following are detailed steps.
1) Create a self balancing BST of all elements in A1[]. In every node of BST, also keep track of count of
occurrences of the key and a bool field visited which is initialized as false for all nodes.
2) Initialize the output index ind as 0.
3) Do following for every element of A2[i] in A2[]
…..a) Search for A2[i] in the BST, if present then copy all occurrences to A1[ind] and increment ind. Also
mark the copied elements visited in the BST node.
4) Do an inorder traversal of BST and copy all unvisited keys to A1[].
Time Complexity of this method is same as the previous method. Note that in a self balancing Binary Search
Tree, all operations require logm time.

1. Loop through A1[], store the count of every number in a HashMap (key: number, value: count of number) .
2. Loop through A2[], check if it is present in HashMap, if so, put in output array that many times and
remove the number from HashMap.
3. Sort the rest of the numbers present in HashMap and put in output array.
Thanks to Anurag Sigh for suggesting this method.
The steps 1 and 2 on average take O(m+n) time under the assumption that we have a good hashing function
that takes O(1) time for insertion and search on average. The third step takes O(pLogp) time where p is the
number of elements remained after considering elements of A2[].
Method 4 (By Writing a Customized Compare Method)

We can also customize compare method of a sorting algorithm to solve the above problem. For example
qsort() in C allows us to pass our own customized compare method.
1. If num1 and num2 both are in A2 then number with lower index in A2 will be treated smaller than other.
2. If only one of num1 or num2 present in A2, then that number will be treated smaller than the other which
doesn’t present in A2.
3. If both are not in A2, then natural ordering will be taken.
Time complexity of this method is O(mnLogm) if we use a O(nLogn) time complexity sorting algorithm. We
can improve time complexity to O(mLogm) by using a Hashing instead of doing linear search.
Following is C implementation of this method.
// A C++ program to sort an array according to the order defined

// by another array
#include <stdio.h>
#include <stdlib.h>
// A2 is made global here so that it can be accesed by compareByA2()

// The syntax of qsort() allows only two parameters to compareByA2()
int A2[5];
int size = 5; // size of A2[]
int search(int key)
{
int i=0, idx = 0;
for (i=0; i<size; i++)
if (A2[i] == key)
return i;
return -1;
}
// A custom comapre method to compare elements of A1[] according

// to the order defined by A2[].
int compareByA2(const void * a, const void * b)
{
int idx1 = search(*(int*)a);
int idx2 = search(*(int*)b);
if (idx1 != -1 && idx2 != -1)
return idx1 - idx2;
else if(idx1 != -1)
return -1;
else if(idx2 != -1)
return 1;
else
return ( *(int*)a - *(int*)b );
}
// This method mainly uses qsort to sort A1[] according to A2[]

void sortA1ByA2(int A1[], int size1)
{
qsort(A1, size1, sizeof (int), compareByA2);
}

int main(int argc, char *argv[])
{
int A1[] = {2, 1, 2, 5, 7, 1, 9, 3, 6, 8, 8, 7, 5, 6, 9, 7, 5};
//A2[] = {2, 1, 8, 3, 4};

A2[0] = 2;
A2[1] = 1;
A2[2] = 8;
A2[3] = 3;
A2[4] = 4;
int size1 = sizeof(A1)/sizeof(A1[0]);
sortA1ByA2(A1, size1);
printf("Sorted Array is ");

int i;
for (i=0; i<size1; i++)
printf("%d ", A1[i]);
return 0;
}

Output:

Sorted Array is 2 2 1 1 8 8 3 5 5 5 6 6 7 7 7 9 9

This method is based on comments by readers (Xinuo Chen, Pranay Doshi and javakurious) and compiled
by Anurag Singh.
This article is compiled by Piyush. Please write comments if you find anything incorrect, or you want to
Data Structure for Dictionary and Spell Checker?
Which data structure can be used for efficiently building a word dictionary and Spell
Checker?
The answer depends upon the functionalists required in Spell Checker and availability of memory. For
example following are few possibilities.
Hashing is one simple option for this. We can put all words in a hash table. Refer this paper which
compares hashing with self-balancing Binary Search Trees and Skip List, and shows that hashing performs
better.
Hashing doesn’t support operations like prefix search. Prefix search is something where a user types a prefix
and your dictionary shows all words starting with that prefix. Hashing also doesn’t support efficient printing
of all words in dictionary in alphabetical order and nearest neighbor search.
If we want both operations, look up and prefix search, Trie is suited. With Trie, we can support all
operations like insert, search, delete in O(n) time where n is length of the word to be processed. Another
advantage of Trie is, we can print all words in alphabetical order which is not possible with hashing.
The disadvantage of Trie is, it requires lots of space. If space is concern, then Ternary Search Tree can be
preferred. In Ternary Search Tree, time complexity of search operation is O(h) where h is height of the tree.
Ternary Search Trees also supports other operations supported by Trie like prefix search, alphabetical order
printing and nearest neighbor search.
If we want to support suggestions, like google shows “did you mean …”, then we need to find the closest
word in dictionary. The closest word can be defined as the word that can be obtained with minimum number
of character transformations (add, delete, replace). A Naive way is to take the given word and generate all
words which are 1 distance (1 edit or 1 delete or 1 replace) away and one by one look them in dictionary. If
nothing found, then look for all words which are 2 distant and so on. There are many complex algorithms for
this. As per the wiki page, The most successful algorithm to date is Andrew Golding and Dan Roth’s
Window-based spelling correction algorithm.
See this for a simple spell checker implementation.
This article is compiled by Piyush. Please write comments if you find anything incorrect, or you want to
Connect n ropes with minimum cost
There are given n ropes of different lengths, we need to connect these ropes into one rope. The cost to
connect two ropes is equal to sum of their lengths. We need to connect the ropes with minimum cost.
For example if we are given 4 ropes of lengths 4, 3, 2 and 6. We can connect the ropes in following ways.
1) First connect ropes of lengths 2 and 3. Now we have three ropes of lengths 4, 6 and 5.
2) Now connect ropes of lengths 4 and 5. Now we have two ropes of lengths 6 and 9.
3) Finally connect the two ropes and all ropes have connected.
Total cost for connecting all ropes is 5 + 9 + 15 = 29. This is the optimized cost for connecting ropes. Other
ways of connecting ropes would always have same or more cost. For example, if we connect 4 and 6 first (we
get three strings of 3, 2 and 10), then connect 10 and 3 (we get two strings of 13 and 2). Finally we connect 13
and 2. Total cost in this way is 10 + 13 + 15 = 38.
If we observe the above problem closely, we can notice that the lengths of the ropes which are picked first are
included more than once in total cost. Therefore, the idea is to connect smallest two ropes first and recur for
remaining ropes. This approach is similar to Huffman Coding. We put smallest ropes down the tree so that
they can be repeated multiple times rather than the longer ropes.
Following is complete algorithm for finding the minimum cost for connecting n ropes.
Let there be n ropes of lengths stored in an array len[0..n-1]
1) Create a min heap and insert all lengths into the min heap.
2) Do following while number of elements in min heap is not one.
……a) Extract the minimum and second minimum from min heap
……b) Add the above two extracted values and insert the added value to the min-heap.
3) Return the value of only left item in min heap.
// C++ program for connecting n ropes with minimum cost

#include <iostream>
// A Min Heap: Collection of min heap nodes

struct MinHeap
{
unsigned size; // Current size of min heap
unsigned capacity; // capacity of min heap
int *harr; // Attay of minheap nodes
};
// A utility function to create a min heap of given capacity

struct MinHeap* createMinHeap(unsigned capacity)
{
struct MinHeap* minHeap = new MinHeap;
minHeap->size = 0; // current size is 0
minHeap->harr = new int[capacity];
return minHeap;
}
// A utility function to swap two min heap nodes

void swapMinHeapNode(int* a, int* b)
{
int temp = *a;
*a = *b;
*a = *b;
*b = temp;
}

{
int smallest = idx;
int left = 2 * idx + 1;
int right = 2 * idx + 2;

minHeap->harr[left] < minHeap->harr[smallest])
smallest = left;

minHeap->harr[right] < minHeap->harr[smallest])
smallest = right;
{
swapMinHeapNode(&minHeap->harr[smallest], &minHeap->harr[idx]);
}
}
// A utility function to check if size of heap is 1 or not

int isSizeOne(struct MinHeap* minHeap)
{
return (minHeap->size == 1);
}
// A standard function to extract minimum value node from heap

int extractMin(struct MinHeap* minHeap)
{
int temp = minHeap->harr[0];
minHeap->harr[0] = minHeap->harr[minHeap->size - 1];
--minHeap->size;
return temp;
}
// A utility function to insert a new node to Min Heap

void insertMinHeap(struct MinHeap* minHeap, int val)
{
++minHeap->size;
while (i && (val < minHeap->harr[(i - 1)/2]))
{
minHeap->harr[i] = minHeap->harr[(i - 1)/2];
i = (i - 1)/2;
}
minHeap->harr[i] = val;
}
// A standard funvtion to build min heap

void buildMinHeap(struct MinHeap* minHeap)
{
int n = minHeap->size - 1;
int i;
for (i = (n - 1) / 2; i >= 0; --i)
}
// Creates a min heap of capacity equal to size and inserts all values
// Creates a min heap of capacity equal to size and inserts all values
// from len[] in it. Initially size of min heap is equal to capacity
struct MinHeap* createAndBuildMinHeap(int len[], int size)
{
struct MinHeap* minHeap = createMinHeap(size);
minHeap->harr[i] = len[i];
minHeap->size = size;
buildMinHeap(minHeap);
return minHeap;
}
// The main function that returns the minimum cost to connect n ropes of
// lengths stored in len[0..n-1]
int minCost(int len[], int n)
{
int cost = 0; // Initialize result
// Create a min heap of capacity equal to n and put all ropes in it

struct MinHeap* minHeap = createAndBuildMinHeap(len, n);
// Iterate while size of heap doesn't become 1

while (!isSizeOne(minHeap))
{
// Extract two minimum length ropes from min heap
int min = extractMin(minHeap);
int sec_min = extractMin(minHeap);
cost += (min + sec_min); // Update total cost
// Insert a new rope in min heap with length equal to sum

// of two extracted minimum lengths
insertMinHeap(minHeap, min+sec_min);
}
// Finally return total minimum cost for connecting all ropes

return cost;
}

int main()
{
int len[] = {4, 3, 2, 6};
int size = sizeof(len)/sizeof(len[0]);
cout << "Total cost for connecting ropes is " << minCost(len, size);
return 0;
}

Output:

Total cost for connecting ropes is 29

Time Complexity: Time complexity of the algorithm is O(nLogn) assuming that we use a O(nLogn) sorting
algorithm. Note that heap operations like insert and extract take O(Logn) time.
Algorithmic Paradigm: Greedy Algorithm

A simple implementation with STL in C++
Following is a simple implementation that uses priority_queue available in STL. Thanks to Pango89 for
providing below code.
#include<iostream>
#include<queue>
int minCost(int arr[], int n)

{
// Create a priority queue ( http://www.cplusplus.com/reference/queue/priority_queue/
)
// By default 'less' is used which is for decreasing order
// and 'greater' is used for increasing order
priority_queue< int, vector<int>, greater<int> > pq(arr, arr+n);
int res = 0;
// While size of priority queue is more than 1

while (pq.size() > 1)
{
// Extract shortest two ropes from pq
int first = pq.top();
pq.pop();
int second = pq.top();
pq.pop();
// Connect the ropes: update result and

// insert the new rope to pq
res += first + second;
pq.push(first + second);
}
return res;
}

int main()
{
int len[] = {4, 3, 2, 6};
int size = sizeof(len)/sizeof(len[0]);
cout << "Total cost for connecting ropes is " << minCost(len, size);
return 0;
}
Output:

Total cost for connecting ropes is 29

This article is compiled by Abhishek. Please write comments if you find anything incorrect, or you want to
Shortest path with exactly k edges in a directed and weighted graph
Given a directed and two vertices ‘u’ and ‘v’ in it, find shortest path from ‘u’ to ‘v’ with exactly k edges on the
path.
The graph is given as adjacency matrix representation where value of graph[i][j] indicates the weight of an
edge from vertex i to vertex j and a value INF(infinite) indicates no edge from i to j.
For example consider the following graph. Let source ‘u’ be vertex 0, destination ‘v’ be 3 and k be 2. There
are two walks of length 2, the walks are {0, 2, 3} and {0, 1, 3}. The shortest among the two is {0, 2, 3} and
weight of path is 3+6 = 9.
The idea is to browse through all paths of length k from u to v using the approach discussed in the previous
post and return weight of the shortest path. A simple solution is to start from u, go to all adjacent vertices
and recur for adjacent vertices with k as k-1, source as adjacent vertex and destination as v. Following is C++
implementation of this simple solution.

// C++ program to find shortest path with exactly k edges

#include <iostream>
#include <climits>
// Define number of vertices in the graph and inifinite value

#define V 4
#define INF INT_MAX
// A naive recursive function to count walks from u to v with k edges

int shortestPath(int graph[][V], int u, int v, int k)
{
// Base cases
if (k == 0 && u == v) return 0;
if (k == 1 && graph[u][v] != INF) return graph[u][v];
if (k <= 0) return INF;
int res = INF;
// Go to all adjacents of u and recur

for (int i = 0; i < V; i++)
{
if (graph[u][i] != INF && u != i && v != i)
{
int rec_res = shortestPath(graph, i, v, k-1);
if (rec_res != INF)
res = min(res, graph[u][i] + rec_res);
}
}
return res;
}

int main()
{
int graph[V][V] = { {0, 10, 3, 2},
{INF, 0, INF, 7},
{INF, INF, 0, 6},
{INF, INF, INF, 0}
};
int u = 0, v = 3, k = 2;
cout << "Weight of the shortest path is " <<
shortestPath(graph, u, v, k);
return 0;
}

Output:

Weight of the shortest path is 9

The worst case time complexity of the above function is O(Vk) where V is the number of vertices in the given
graph. We can simply analyze the time complexity by drawing recursion tree. The worst occurs for a
complete graph. In worst case, every internal node of recursion tree would have exactly V children.
We can optimize the above solution using Dynamic Programming. The idea is to build a 3D table where
first dimension is source, second dimension is destination, third dimension is number of edges from source
to destination, and the value is count of walks. Like other Dynamic Programming problems, we fill the 3D
table in bottom up manner.
// Dynamic Programming based C++ program to find shortest path with

// exactly k edges
#include <iostream>
#include <climits>
// Define number of vertices in the graph and inifinite value

#define V 4
#define INF INT_MAX
// A Dynamic programming based function to find the shortest path from

// u to v with exactly k edges.
int shortestPath(int graph[][V], int u, int v, int k)
{
// Table to be filled up using DP. The value sp[i][j][e] will store
// weight of the shortest path from i to j with exactly k edges
int sp[V][V][k+1];
// Loop for number of edges from 0 to k

for (int e = 0; e <= k; e++)
{
for (int i = 0; i < V; i++) // for source
{
for (int j = 0; j < V; j++) // for destination
{
// initialize value
sp[i][j][e] = INF;
// from base cases

if (e == 0 && i == j)
sp[i][j][e] = 0;
if (e == 1 && graph[i][j] != INF)
sp[i][j][e] = graph[i][j];
//go to adjacent only when number of edges is more than 1

if (e > 1)
{
for (int a = 0; a < V; a++)
{
// There should be an edge from i to a and a
// should not be same as either i or j
if (graph[i][a] != INF && i != a &&
j!= a && sp[a][j][e-1] != INF)
sp[i][j][e] = min(sp[i][j][e], graph[i][a] +
sp[a][j][e-1]);
}
}
}
}
}
return sp[u][v][k];
}

int main()
{
{
int graph[V][V] = { {0, 10, 3, 2},
{INF, 0, INF, 7},
{INF, INF, 0, 6},
{INF, INF, INF, 0}
};
int u = 0, v = 3, k = 2;
cout << shortestPath(graph, u, v, k);
return 0;
}

Output:

Weight of the shortest path is 9

Time complexity of the above DP based solution is O(V3K) which is much better than the naive solution.
Tarjan’s Algorithm to find Strongly Connected Components
A directed graph is strongly connected if there is a path between all pairs of vertices. A strongly connected
component (SCC) of a directed graph is a maximal strongly connected subgraph. For example, there are 3
SCCs in the following graph.
We have discussed Kosaraju’s algorithm for strongly connected components. The previously discussed
algorithm requires two DFS traversals of a Graph. In this post, Tarjan’s algorithm is discussed that requires
only one DFS traversal.
Tarjan Algorithm is based on following facts:

1. DFS search produces a DFS tree/forest
2. Strongly Connected Components form subtrees of the DFS tree.
3. If we can find head of such subtrees, we can print/store all the nodes in that subtree (including head) and
that will be one SCC.
4. There is no back edge from one SCC to another (There can be cross edges, but cross edges will not be used
while processing the graph).
To find head of a SCC, we calculate desc and low array (as done for articulation point, bridge, biconnected
component). As discussed in the previous posts, low[u] indicates earliest visited vertex (the vertex with
minimum discovery time) that can be reached from subtree rooted with u. A node u is head if disc[u] =
low[u].
Disc and Low Values

(click on image to see it properly)

Strongly Connected Component relates to directed graph only, but Disc and Low values relate to both
directed and undirected graph, so in above pic we have taken an undirected graph.
In above Figure, we have shown a graph and it’s one of DFS tree (There could be different DFS trees on same
graph depending on order in which edges are traversed).
In DFS tree, continuous arrows are tree edges and dashed arrows are back edges (DFS Tree Edges
Disc and Low values are showin in Figure for every node as (Disc/Low).
Disc: This is the time when a node is visited 1st time while DFS traversal. For nodes A, B, C, .., J in DFS tree,
Disc values are 1, 2, 3, .., 10.
Low: In DFS tree, Tree edges take us forward, from ancestor node to one of it’s descendants. For example,
from node C, tree edges can take us to node node G, node I etc. Back edges take us backward, from a
descendant node to one of it’s ancestors. For example, from node G, Back edges take us to E or C. If we look
at both Tree and Back edge together, then we can see that if we start traversal from one node, we may go
down the tree via Tree edges and then go up via back edges. For example, from node E, we can go down to G
and then go up to C. Similarly from E, we can go down to I or J and then go up to F. “Low” value of a node
tells the topmost reachable ancestor (with minimum possible Disc value) via the subtree of that node. So for
any node, Low value equal to it’s Disc value anyway (A node is ancestor of itself). Then we look into it’s
subtree and see if there is any node which can take us to any of it’s ancestor. If there are multiple back edges
in subtree which take us to different ancestors, then we take the one with minimum Disc value (i.e. the
topmost one). If we look at node F, it has two subtrees. Subtree with node G, takes us to E and C. The other
subtree takes us back to F only. Here topmost ancestor is C where F can reach and so Low value of F is 3
(The Disc value of C).
Based on above discussion, it should be clear that Low values of B, C, and D are 1 (As A is the topmost node
where B, C and D can reach). In same way, Low values of E, F, G are 3 and Low values of H, I, J are 6.
For any node u, when DFS starts, Low will be set to it’s Disc 1st .
Then later on DFS will be performed on each of it’s children v one by one, Low value of u can change it two
case:
Case1 (Tree Edge): If node v is not visited already, then after DFS of v is complete, then minimum of
low[u] and low[v] will be updated to low[u].
Case 2 (Back Edge): When child v is already visited, then minimum of low[u] and Disc[v] will be updated
to low[u].
In case two, can we take low[v] instead of disc[v] ?? . Answer is NO. If you can think why answer is NO, you
probably understood the Low and Disc concept.
Same Low and Disc values help to solve other graph problems like articulation point, bridge and biconnected
component.
To track the subtree rooted at head, we can use a stack (keep pushing node while visiting). When a head node
found, pop all nodes from stack till you get head out of stack.
To make sure, we don’t consider cross edges, when we reach a node which is already visited, we should
process the visited node only if it is present in stack, else ignore the node.
Following is C++ implementation of Tarjan’s algorithm to print all SCCs.
// A C++ program to find strongly connected components in a given

// directed graph using Tarjan's algorithm (single DFS)
#include<iostream>
#include <list>
#include <stack>
#define NIL -1
// A class that represents an directed graph

class Graph
{
// A Recursive DFS based function used by SCC()

void SCCUtil(int u, int disc[], int low[],
stack<int> *st, bool stackMember[]);
public:
void SCC(); // prints strongly connected components
};
Graph::Graph(int V)
{
this->V = V;
}

{
}
// A recursive function that finds and prints strongly connected

// components using DFS traversal
// low[] -- >> earliest visited vertex (the vertex with minimum
// discovery time) that can be reached from subtree
// rooted with current vertex
// *st -- >> To store all the connected ancestors (could be part
// of SCC)
// stackMember[] --> bit/index array for faster check whether
// a node is in stack
// a node is in stack
void Graph::SCCUtil(int u, int disc[], int low[], stack<int> *st,
bool stackMember[])
{
// A static variable is used for simplicity, we can avoid use
// of static variable by passing a pointer.

st->push(u);
stackMember[u] = true;
// Go through all vertices adjacent to this

{
int v = *i; // v is current adjacent of 'u'

if (disc[v] == -1)
{
SCCUtil(v, disc, low, st, stackMember);
// Check if the subtree rooted with 'v' has a

// connection to one of the ancestors of 'u'
// Case 1 (per above discussion on Disc and Low value)
}
// Update low value of 'u' only of 'v' is still in stack

// (i.e. it's a back edge, not cross edge).
// Case 2 (per above discussion on Disc and Low value)
else if (stackMember[v] == true)
}
// head node found, pop the stack and print an SCC

int w = 0; // To store stack extracted vertices
if (low[u] == disc[u])
{
while (st->top() != u)
{
w = (int) st->top();
cout << w << " ";
stackMember[w] = false;
st->pop();
}
w = (int) st->top();
cout << w << "\n";
stackMember[w] = false;
st->pop();
}
}
// The function to do DFS traversal. It uses SCCUtil()

void Graph::SCC()
{
bool *stackMember = new bool[V];
stack<int> *st = new stack<int>();
// Initialize disc and low, and stackMember arrays

for (int i = 0; i < V; i++)
{
disc[i] = NIL;
low[i] = NIL;
stackMember[i] = false;
}
// Call the recursive helper function to find strongly

// connected components in DFS tree with vertex 'i'
for (int i = 0; i < V; i++)
if (disc[i] == NIL)
SCCUtil(i, disc, low, st, stackMember);
}

int main()
{
cout << "\nSCCs in first graph \n";
Graph g1(5);
g1.addEdge(1, 0);
g1.addEdge(0, 2);
g1.addEdge(2, 1);
g1.addEdge(0, 3);
g1.addEdge(3, 4);
g1.SCC();
cout << "\nSCCs in second graph \n";

Graph g2(4);
g2.addEdge(0, 1);
g2.addEdge(1, 2);
g2.addEdge(2, 3);
g2.SCC();
cout << "\nSCCs in third graph \n";

Graph g3(7);
g3.addEdge(0, 1);
g3.addEdge(1, 2);
g3.addEdge(2, 0);
g3.addEdge(1, 3);
g3.addEdge(1, 4);
g3.addEdge(1, 6);
g3.addEdge(3, 5);
g3.addEdge(4, 5);
g3.SCC();
cout << "\nSCCs in fourth graph \n";

Graph g4(11);
g4.addEdge(0,1);g4.addEdge(0,3);
g4.addEdge(3,2);
g4.addEdge(5,6);g4.addEdge(5,7);g4.addEdge(5,8);g4.addEdge(5,9);
g4.addEdge(6,4);
g4.addEdge(7,9);
g4.addEdge(8,9);
g4.addEdge(9,8);
g4.SCC();
cout << "\nSCCs in fifth graph \n";

Graph g5(5);
g5.addEdge(0,1);
g5.addEdge(1,2);
g5.addEdge(2,3);
g5.addEdge(2,4);
g5.addEdge(3,0);
g5.addEdge(4,2);
g5.SCC();
return 0;
}

Output:
SCCs in first graph

4
3
1 2 0
SCCs in second graph

3
2
1
0
SCCs in third graph

5
3
4
6
2 1 0
SCCs in fourth graph

8 9
7
5 4 6
3 2 1 0
10
SCCs in fifth graph

4 3 2 1 0

Time Complexity: The above algorithm mainly calls DFS, DFS takes O(V+E) for a graph represented
using adjacency list.
References:
http://en.wikipedia.org/wiki/Tarjan%27s_strongly_connected_components_algorithm
http://www.ics.uci.edu/~eppstein/161/960220.html#sca
This article is contributed by Anurag Singh. Please write comments if you find anything incorrect, or you
How to efficiently implement k stacks in a single array?
We have discussed space efficient implementation of 2 stacks in a single array. In this post, a general
solution for k stacks is discussed. Following is the detailed problem statement.
Create a data structure kStacks that represents k stacks. Implementation of kStacks should use only one
array, i.e., k stacks should use the same array for storing elements. Following functions must be supported
by kStacks.
push(int x, int sn) –> pushes x to stack number ‘sn’ where sn is from 0 to k-1
pop(int sn) –> pops an element from stack number ‘sn’ where sn is from 0 to k-1
Method 1 (Divide the array in slots of size n/k)

A simple way to implement k stacks is to divide the array in k slots of size n/k each, and fix the slots for
different stacks, i.e., use arr[0] to arr[n/k-1] for first stack, and arr[n/k] to arr[2n/k-1] for stack2 where arr[]
is the array to be used to implement two stacks and size of array be n.
The problem with this method is inefficient use of array space. A stack push operation may result in stack
overflow even if there is space available in arr[]. For example, say the k is 2 and array size (n) is 6 and we
push 3 elements to first and do not push anything to second second stack. When we push 4th element to
first, there will be overflow even if we have space for 3 more elements in array.

The idea is to use two extra arrays for efficient implementation of k stacks in an array. This may not make
much sense for integer stacks, but stack items can be large for example stacks of employees, students, etc
where every item is of hundreds of bytes. For such large stacks, the extra space used is comparatively very
less as we use two integer arrays as extra space.
Following are the two extra arrays are used:

1) top[]: This is of size k and stores indexes of top elements in all stacks.
2) next[]: This is of size n and stores indexes of next item for the items in array arr[]. Here arr[] is actual
array that stores k stacks.
Together with k stacks, a stack of free slots in arr[] is also maintained. The top of this stack is stored in a
variable ‘free’.
All entries in top[] are initialized as -1 to indicate that all stacks are empty. All entries next[i] are initialized
as i+1 because all slots are free initially and pointing to next slot. Top of free stack, ‘free’ is initialized as 0.
// A C++ program to demonstrate implementation of k stacks in a single

// array in time and space efficient way
#include<iostream>
#include<climits>
// A C++ class to represent k stacks in a single array of size n

class kStacks
{
int *arr; // Array of size n to store actual content to be stored in stacks
int *top; // Array of size k to store indexes of top elements of stacks
int *next; // Array of size n to store next entry in all stacks
// and free list
int n, k;
int free; // To store beginning index of free list
public:
//constructor to create k stacks in an array of size n
kStacks(int k, int n);
// A utility function to check if there is space available

bool isFull() { return (free == -1); }
// To push an item in stack number 'sn' where sn is from 0 to k-1

void push(int item, int sn);
// To pop an from stack number 'sn' where sn is from 0 to k-1

int pop(int sn);
// To check whether stack number 'sn' is empty or not

bool isEmpty(int sn) { return (top[sn] == -1); }
};
//constructor to create k stacks in an array of size n

kStacks::kStacks(int k1, int n1)
{
// Initialize n and k, and allocate memory for all arrays
k = k1, n = n1;
arr = new int[n];
top = new int[k];
next = new int[n];
// Initialize all stacks as empty

for (int i = 0; i < k; i++)
top[i] = -1;
// Initialize all spaces as free

free = 0;
next[i] = i+1;
next[n-1] = -1; // -1 is used to indicate end of free list
}
// To push an item in stack number 'sn' where sn is from 0 to k-1

void kStacks::push(int item, int sn)
{
// Overflow check
if (isFull())
{
cout << "\nStack Overflow\n";
return;
}
int i = free; // Store index of first free slot
// Update index of free slot to index of next slot in free list

free = next[i];
// Update next of top and then top for stack number 'sn'
next[i] = top[sn];
top[sn] = i;
// Put the item in array

arr[i] = item;
}
// To pop an from stack number 'sn' where sn is from 0 to k-1

int kStacks::pop(int sn)
{
// Underflow check
if (isEmpty(sn))
{
cout << "\nStack Underflow\n";
return INT_MAX;
}
// Find index of top item in stack number 'sn'

int i = top[sn];
top[sn] = next[i]; // Change top to store next of previous top
// Attach the previous top to the beginning of free list

next[i] = free;
free = i;
// Return the previous top item

return arr[i];
}
/* Driver program to test twStacks class */

int main()
{
// Let us create 3 stacks in an array of size 10
int k = 3, n = 10;
kStacks ks(k, n);
// Let us put some items in stack number 2

ks.push(15, 2);
ks.push(45, 2);

ks.push(17, 1);
ks.push(49, 1);
ks.push(39, 1);

ks.push(11, 0);
ks.push(9, 0);
ks.push(7, 0);
cout << "Popped element from stack 2 is " << ks.pop(2) << endl;
return 0;
}

Output:

Popped element from stack 2 is 45

Time complexities of operations push() and pop() is O(1).
The best part of above implementation is, if there is a slot available in stack, then an item can be pushed in
any of the stacks, i.e., no wastage of space.
This article is contributed by Sachin. Please write comments if you find anything incorrect, or you want to
Print squares of first n natural numbers without using *, / and –
Given a natural number ‘n’, print squares of first n natural numbers without using *, / and -.
Input: n = 5
Output: 0 1 4 9 16
Input: n = 6
Output: 0 1 4 9 16 25

Method 1: The idea is to calculate next square using previous square value. Consider the following relation
between square of x and (x-1). We know square of (x-1) is (x-1)2 – 2*x + 1. We can write x2 as
x2 = (x-1)2 + 2*x - 1
x2 = (x-1)2 + x + (x - 1)

When writing an iterative program, we can keep track of previous value of x and add the current and
previous values of x to current value of square. This way we don’t even use the ‘-‘ operator.

// C++ program to print squares of first 'n' natural numbers

// wothout using *, / and -
#include<iostream>
void printSquares(int n)
{
// Initialize 'square' and previous value of 'x'
int square = 0, prev_x = 0;
// Calculate and print squares

for (int x = 0; x < n; x++)
{
// Update value of square using previous value
square = (square + x + prev_x);
// Print square and update prev for next iteration

cout << square << " ";
prev_x = x;
}
}

int main()
{
int n = 5;
printSquares(n);
}

Output:

0 1 4 9 16

Method 2: Sum of first n odd numbers are squares of natural numbers from 1 to n. For example 1, 1+3,
1+3+5, 1+3+5+7, 1+3+5+7+9, ….
Following is C++ program based on above concept. Thanks to Aadithya Umashanker and raviteja for
suggesting this method.

// C++ program to print squares of first 'n' natural numbers

// wothout using *, / and -
#include<iostream>
void printSquares(int n)
{
// Initialize 'square' and first odd number
int square = 0, odd = 1;
// Calculate and print squares

for (int x = 0; x < n; x++)
{
// Print square
cout << square << " ";
// Update 'square' and 'odd'

square = square + odd;
odd = odd + 2;
}
}

int main()
{
int n = 5;
printSquares(n);
}

Output:

0 1 4 9 16

Rearrange array in alternating positive & negative items with O(1) extra
space
Given an array of positive and negative numbers, arrange them in an alternate fashion such that every
positive number is followed by negative and vice-versa maintaining the order of appearance.
Number of positive and negative numbers need not be equal. If there are more positive numbers they appear
at the end of the array. If there are more negative numbers, they too appear in the end of the array.
Example:
Input: arr[] = {1, 2, 3, -4, -1, 4}

Output: arr[] = {-4, 1, -1, 2, 3, 4}
Input: arr[] = {-5, -2, 5, 2, 4, 7, 1, 8, 0, -8}

output: arr[] = {-5, 5, -2, 2, -8, 4, 7, 1, 8, 0}

This question has been asked at many places (See this and this)
The above problem can be easily solved if O(n) extra space is allowed. It becomes interesting due to the
limitations that O(1) extra space and order of appearances.
The idea is to process array from left to right. While processing, find the first out of place element in the
remaining unprocessed array. An element is out of place if it is negative and at odd index, or it is positive
and at even index. Once we find an out of place element, we find the first element after it with opposite sign.
We right rotate the subarray between these two elements (including these two).
Following is C++ implementation of above idea.
/* C++ program to rearrange positive and negative integers in alternate

fashion while keeping the order of positive and negative numbers. */
#include <iostream>
#include <assert.h>
// Utility function to right rotate all elements between [outofplace, cur]

void rightrotate(int arr[], int n, int outofplace, int cur)
{
char tmp = arr[cur];
for (int i = cur; i > outofplace; i--)
arr[i] = arr[i-1];
arr[outofplace] = tmp;
}

{
int outofplace = -1;
for (int index = 0; index < n; index ++)

{
if (outofplace >= 0)
{
// find the item which must be moved into the out-of-place
// entry if out-of-place entry is positive and current
// entry is negative OR if out-of-place entry is negative
// and current entry is negative then right rotate
//
//
// [...-3, -4, -5, 6...] --> [...6, -3, -4, -5...]
// ^ ^
// | |
// outofplace --> outofplace
//
if (((arr[index] >= 0) && (arr[outofplace] < 0))
|| ((arr[index] < 0) && (arr[outofplace] >= 0)))
{
rightrotate(arr, n, outofplace, index);
// the new out-of-place entry is now 2 steps ahead

if (index - outofplace > 2)
outofplace = outofplace + 2;
else
outofplace = -1;
}
}
// if no entry has been flagged out-of-place

if (outofplace == -1)
{
// check if current entry is out-of-place
if (((arr[index] >= 0) && (!(index & 0x01)))
|| ((arr[index] < 0) && (index & 0x01)))
{
outofplace = index;
}
}
}
}
// A utility function to print an array 'arr[]' of size 'n'

{
for (int i = 0; i < n; i++)
cout << arr[i] << " ";
cout << endl;
}
// Driver program to test abive function

int main()
{
//int arr[n] = {-5, 3, 4, 5, -6, -2, 8, 9, -1, -4};
//int arr[] = {-5, -3, -4, -5, -6, 2 , 8, 9, 1 , 4};
//int arr[] = {5, 3, 4, 2, 1, -2 , -8, -9, -1 , -4};
//int arr[] = {-5, 3, -4, -7, -1, -2 , -8, -9, 1 , -4};
int arr[] = {-5, -2, 5, 2, 4, 7, 1, 8, 0, -8};

printArray(arr, n);
rearrange(arr, n);
cout << "Rearranged array is \n";

printArray(arr, n);
return 0;
}

Output:

Given array is
-5 -2 5 2 4 7 1 8 0 -8
Rearranged array is
-5 5 -2 2 -8 4 7 1 8 0

This article is contributed by Sandeep Joshi. Please write comments if you find anything incorrect, or you
Pattern Searching using a Trie of all Suffixes
Problem Statement: Given a text txt[0..n-1] and a pattern pat[0..m-1], write a function search(char pat[],
char txt[]) that prints all occurrences of pat[] in txt[]. You may assume that n > m.
As discussed in the previous post, we discussed that there are two ways efficiently solve the above problem.
1) Preprocess Pattern: KMP Algorithm, Rabin Karp Algorithm, Finite Automata, Boyer Moore Algorithm.
2) Preoprocess Text: Suffix Tree
The best possible time complexity achieved by first (preprocssing pattern) is O(n) and by second
(preprocessing text) is O(m) where m and n are lengths of pattern and text respectively.
Note that the second way does the searching only in O(m) time and it is preferred when text doesn’t doesn’t
change very frequently and there are many search queries. We have discussed Suffix Tree (A compressed
Trie of all suffixes of Text) .
Implementation of Suffix Tree may be time consuming for problems to be coded in a technical interview or
programming contexts. In this post simple implementation of a Standard Trie of all Suffixes is discussed.
The implementation is close to suffix tree, the only thing is, it’s a simple Trie instead of compressed Trie.
As discussed in Suffix Tree post, the idea is, every pattern that is present in text (or we can say every
substring of text) must be a prefix of one of all possible suffixes. So if we build a Trie of all suffixes, we can
find the pattern in O(m) time where m is pattern length.
Building a Trie of Suffixes

1) Generate all suffixes of given text.
2) Consider all suffixes as individual words and build a trie.
Let us consider an example text “banana\0″ where ‘\0′ is string termination character. Following are all
suffixes of “banana\0″
banana\0
anana\0
nana\0
ana\0
na\0
a\0
\0

If we consider all of the above suffixes as individual words and build a Trie, we get following.
How to search a pattern in the built Trie?
Following are steps to search a pattern in the built Trie.
1) Starting from the first character of the pattern and root of the Trie, do following for every character.
…..a) For the current character of pattern, if there is an edge from the current node, follow the edge.
…..b) If there is no edge, print “pattern doesn’t exist in text” and return.
2) If all characters of pattern have been processed, i.e., there is a path from root for characters of the given
pattern, then print print all indexes where pattern is present. To store indexes, we use a list with every node
that stores indexes of suffixes starting at the node.
// A simple C++ implementation of substring search using trie of suffixes

#include<iostream>
#include<list>
// A Suffix Trie (A Trie of all suffixes) Node

class SuffixTrieNode
{
private:
SuffixTrieNode *children[MAX_CHAR];
list<int> *indexes;
public:
SuffixTrieNode() // Constructor
{
// Create an empty linked list for indexes of
// suffixes starting from this node
indexes = new list<int>;
// Initialize all child pointers as NULL

for (int i = 0; i < MAX_CHAR; i++)
children[i] = NULL;
}
// A recursive function to insert a suffix of the txt

// in subtree rooted with this node
void insertSuffix(string suffix, int index);
// A function to search a pattern in subtree rooted

// with this node.The function returns pointer to a linked
// list containing all indexes where pattern is present.
// list containing all indexes where pattern is present.
// The returned indexes are indexes of last characters
// of matched text.
list<int>* search(string pat);
};
// A Trie of all suffixes

class SuffixTrie
{
private:
SuffixTrieNode root;
public:
// Constructor (Builds a trie of suffies of the given text)
SuffixTrie(string txt)
{
// Consider all suffixes of given string and insert
// them into the Suffix Trie using recursive function
// insertSuffix() in SuffixTrieNode class
for (int i = 0; i < txt.length(); i++)
root.insertSuffix(txt.substr(i), i);
}
// Function to searches a pattern in this suffix trie.

void search(string pat);
};
// A recursive function to insert a suffix of the txt in

// subtree rooted with this node
void SuffixTrieNode::insertSuffix(string s, int index)
{
// Store index in linked list
indexes->push_front(index);
// If string has more characters

if (s.length() > 0)
{
// Find the first character
char cIndex = s.at(0);
// If there is no edge for this character, add a new edge

if (children[cIndex] == NULL)
children[cIndex] = new SuffixTrieNode();
// Recur for next suffix

children[cIndex]->insertSuffix(s.substr(1), index+1);
}
}
// A recursive function to search a pattern in subtree rooted with

// this node
list<int>* SuffixTrieNode::search(string s)
{
// If all characters of pattern have been processed,
if (s.length() == 0)
return indexes;
// if there is an edge from the current node of suffix trie,

// follow the edge.
if (children[s.at(0)] != NULL)
return (children[s.at(0)])->search(s.substr(1));
// If there is no edge, pattern doesn’t exist in text

else return NULL;
}
/* Prints all occurrences of pat in the Suffix Trie S (built for text)*/
void SuffixTrie::search(string pat)
{
// Let us call recursive search function for root of Trie.
// We get a list of all indexes (where pat is present in text) in
// variable 'result'
list<int> *result = root.search(pat);
// Check if the list of indexes is empty or not

if (result == NULL)
cout << "Pattern not found" << endl;
else
{
int patLen = pat.length();
for (i = result->begin(); i != result->end(); ++i)
cout << "Pattern found at position " << *i - patLen<< endl;
}
}
// driver program to test above functions

int main()
{
// Let us build a suffix trie for text "geeksforgeeks.org"
string txt = "geeksforgeeks.org";
SuffixTrie S(txt);
cout << "Search for 'ee'" << endl;

S.search("ee");
cout << "\nSearch for 'geek'" << endl;

S.search("geek");
cout << "\nSearch for 'quiz'" << endl;

S.search("quiz");
cout << "\nSearch for 'forgeeks'" << endl;

S.search("forgeeks");
return 0;
}

Output:

Search for 'ee'
Pattern found at position 9
Search for 'geek'

Search for 'quiz'

Pattern not found
Search for 'forgeeks'


Time Complexity of the above search function is O(m+k) where m is length of the pattern and k is the
number of occurrences of pattern in text.
This article is contributed by Ashish Anand. Please write comments if you find anything incorrect, or you
Clone a Binary Tree with Random Pointers
Given a Binary Tree where every node has following structure.
struct node {
int key;
struct node *left,*right,*random;
}

The random pointer points to any random node of the binary tree and can even point to NULL, clone the
given binary tree.

The idea is to store mapping from given tree nodes to clone tre node in hashtable. Following are detailed
steps.
1) Recursively traverse the given Binary and copy key value, left pointer and right pointer to clone tree.
While copying, store the mapping from given tree node to clone tree node in a hashtable. In the following
pseudo code, ‘cloneNode’ is currently visited node of clone tree and ‘treeNode’ is currently visited node of
given tree.
cloneNode->key = treeNode->key
cloneNode->left = treeNode->left
cloneNode->right = treeNode->right
map[treeNode] = cloneNode

2) Recursively traverse both trees and set random pointers using entries from hash table.
cloneNode->random = map[treeNode->random]

Following is C++ implementation of above idea. The following implementation uses map from C++ STL.
Note that map doesn’t implement hash table, it actually is based on self-balancing binary search tree.
// A hashmap based C++ program to clone a binary tree with random pointers
#include<iostream>
#include<map>
/* A binary tree node has data, pointer to left child, a pointer to right
child and a pointer to random node*/
struct Node
{
int key;
struct Node* left, *right, *random;
};
/* Helper function that allocates a new Node with the

given data and NULL left, right and random pointers. */
{
Node* temp = new Node;
temp->key = key;
temp->random = temp->right = temp->left = NULL;
return (temp);
}
/* Given a binary tree, print its Nodes in inorder*/

{
if (node == NULL)
return;
/* First recur on left sutree */

/* then print data of Node and its random */

cout << "[" << node->key << " ";
if (node->random == NULL)
cout << "NULL], ";
else
cout << node->random->key << "], ";

}
// This function creates clone by copying key and left and right pointers
// This function also stores mapping from given tree node to clone.
Node* copyLeftRightNode(Node* treeNode, map<Node *, Node *> *mymap)
{
if (treeNode == NULL)
return NULL;
Node* cloneNode = newNode(treeNode->key);
(*mymap)[treeNode] = cloneNode;
cloneNode->left = copyLeftRightNode(treeNode->left, mymap);
cloneNode->right = copyLeftRightNode(treeNode->right, mymap);
return cloneNode;
}
// This function copies random node by using the hashmap built by

// copyLeftRightNode()
void copyRandom(Node* treeNode, Node* cloneNode, map<Node *, Node *> *mymap)
{
if (cloneNode == NULL)
return;
cloneNode->random = (*mymap)[treeNode->random];
copyRandom(treeNode->left, cloneNode->left, mymap);
copyRandom(treeNode->right, cloneNode->right, mymap);
}
// This function makes the clone of given tree. It mainly uses

// copyLeftRightNode() and copyRandom()
Node* cloneTree(Node* tree)
{
if (tree == NULL)
return NULL;
map<Node *, Node *> *mymap = new map<Node *, Node *>;
Node* newTree = copyLeftRightNode(tree, mymap);
copyRandom(tree, newTree, mymap);
return newTree;
}
}

int main()
{
//Test No 1
Node *tree = newNode(1);
tree->left = newNode(2);
tree->right = newNode(3);
tree->left->left = newNode(4);
tree->left->right = newNode(5);
tree->random = tree->left->right;
tree->left->left->random = tree;
tree->left->right->random = tree->right;
// Test No 2
// tree = NULL;
// Test No 3
// tree = newNode(1);
// Test No 4
/* tree = newNode(1);
tree->random = tree->right;
tree->left->random = tree;
*/
cout << "Inorder traversal of original binary tree is: \n";

printInorder(tree);
Node *clone = cloneTree(tree);
cout << "\n\nInorder traversal of cloned binary tree is: \n";

printInorder(clone);
return 0;
}

Output:

Inorder traversal of original binary tree is:
[4 1], [2 NULL], [5 3], [1 5], [3 NULL],
Inorder traversal of cloned binary tree is:

[4 1], [2 NULL], [5 3], [1 5], [3 NULL],

Method 2 (Temporarily Modify the Given Binary Tree)
1. Create new nodes in cloned tree and insert each new node in original tree between the left pointer edge of
corresponding node in the original tree (See the below image).
i.e. if current node is A and it’s left child is B ( A — >> B ), then new cloned node with key A wil be created
(say cA) and it will be put as A — >> cA — >> B (B can be a NULL or a non-NULL left child). Right child
pointer will be set correctly i.e. if for current node A, right child is C in original tree (A — >> C) then
corresponding cloned nodes cA and cC will like cA —- >> cC
2. Set random pointer in cloned tree as per original tree
i.e. if node A’s random pointer points to node B, then in cloned tree, cA will point to cB (cA and cB are new
node in cloned tree corresponding to node A and B in original tree)
3. Restore left pointers correctly in both original and cloned tree
#include <iostream>
/* A binary tree node has data, pointer to left child, a pointer to right
child and a pointer to random node*/
struct Node
{
int key;
struct Node* left, *right, *random;
};

given data and NULL left, right and random pointers. */
{
temp->key = key;
temp->random = temp->right = temp->left = NULL;
return (temp);
}
/* Given a binary tree, print its Nodes in inorder*/

{
if (node == NULL)
return;
/* First recur on left sutree */

/* then print data of Node and its random */

cout << "[" << node->key << " ";
if (node->random == NULL)
cout << "NULL], ";
else
cout << node->random->key << "], ";

}
// This function creates new nodes cloned tree and puts new cloned node
// in between current node and it's left child
// i.e. if current node is A and it's left child is B ( A --- >> B ),
// then new cloned node with key A wil be created (say cA) and
// it will be put as
// A --- >> cA --- >> B
// Here B can be a NULL or a non-NULL left child
// Right child pointer will be set correctly
// i.e. if for current node A, right child is C in original tree
// (A --- >> C) then corresponding cloned nodes cA and cC will like
// cA ---- >> cC
Node* copyLeftRightNode(Node* treeNode)
{
return NULL;
Node* left = treeNode->left;

treeNode->left = newNode(treeNode->key);
treeNode->left->left = left;
if(left != NULL)
left->left = copyLeftRightNode(left);
treeNode->left->right = copyLeftRightNode(treeNode->right);
return treeNode->left;
}
// This function sets random pointer in cloned tree as per original tree
// i.e. if node A's random pointer points to node B, then
// in cloned tree, cA wil point to cB (cA and cB are new node in cloned
// tree corresponding to node A and B in original tree)
void copyRandomNode(Node* treeNode, Node* cloneNode)
{
return;
if(treeNode->random != NULL)
cloneNode->random = treeNode->random->left;
else
cloneNode->random = NULL;
if(treeNode->left != NULL && cloneNode->left != NULL)

copyRandomNode(treeNode->left->left, cloneNode->left->left);
copyRandomNode(treeNode->right, cloneNode->right);
}
// This function will restore left pointers correctly in

// both original and cloned tree
void restoreTreeLeftNode(Node* treeNode, Node* cloneNode)
{
return;
if (cloneNode->left != NULL)
{
Node* cloneLeft = cloneNode->left->left;
treeNode->left = treeNode->left->left;
cloneNode->left = cloneLeft;
}
else
treeNode->left = NULL;
restoreTreeLeftNode(treeNode->left, cloneNode->left);
restoreTreeLeftNode(treeNode->right, cloneNode->right);
}
//This function makes the clone of given tree

//This function makes the clone of given tree
Node* cloneTree(Node* treeNode)
{
return NULL;
Node* cloneNode = copyLeftRightNode(treeNode);
copyRandomNode(treeNode, cloneNode);
restoreTreeLeftNode(treeNode, cloneNode);
return cloneNode;
}

int main()
{
/* //Test No 1
tree->random = tree->left->right;
tree->left->left->random = tree;
tree->left->right->random = tree->right;
// Test No 2
// Node *tree = NULL;
/*
// Test No 3
// Test No 4
tree->random = tree->right;
Test No 5
tree->right->left = newNode(6);
tree->right->right = newNode(7);
tree->random = tree->left;
*/
// Test No 6
Node *n2 = newNode(6);
tree->left = n2;
tree->right = n3;
tree->random = n2;
n2->left = n4;
n2->right = n5;
n2->random = n8;
n3->left = n6;
n3->left = n6;
n3->right = n7;
n3->random = n5;
n4->random = n9;
n5->left = n8;
n5->right = n9;
n5->random = tree;
n6->random = n9;
n9->random = n8;
/* Test No 7
tree->right->random = tree->left;
*/
cout << "Inorder traversal of original binary tree is: \n";
printInorder(tree);
Node *clone = cloneTree(tree);
cout << "\n\nInorder traversal of cloned binary tree is: \n";

printInorder(clone);
return 0;
}

Output:

Inorder traversal of original binary tree is:
[5 9], [6 7], [7 NULL], [8 10], [9 7], [10 6], [11 9], [12 8], [13 NULL],
Inorder traversal of cloned binary tree is:

[5 9], [6 7], [7 NULL], [8 10], [9 7], [10 6], [11 9], [12 8], [13 NULL],

Find the smallest positive integer value that cannot be represented as sum
of any subset of a given array
Given a sorted array (sorted in non-decreasing order) of positive numbers, find the smallest positive integer
value that cannot be represented as sum of elements of any subset of given set.
Examples:
Input: arr[] = {1, 3, 6, 10, 11, 15};

Output: 2
Input: arr[] = {1, 1, 1, 1};

Output: 5
Input: arr[] = {1, 1, 3, 4};

Output: 10
Input: arr[] = {1, 2, 5, 10, 20, 40};

Output: 4
Input: arr[] = {1, 2, 3, 4, 5, 6};

Output: 22

A Simple Solution is to start from value 1 and check all values one by one if they can sum to values in the
given array. This solution is very inefficient as it reduces to subset sum problem which is a well known NP
Complete Problem.
We can solve this problem in O(n) time using a simple loop. Let the input array be arr[0..n-1]. We initialize
the result as 1 (smallest possible outcome) and traverse the given array. Let the smallest element that cannot
be represented by elements at indexes from 0 to (i-1) be ‘res’, there are following two possibilities when we
consider element at index i:
1) We decide that ‘res’ is the final result : If arr[i] is greater than ‘res’, then we found the gap which is
‘res’ because the elements after arr[i] are also going to be greater than ‘res’.
2) The value of ‘res’ is incremented after considering arr[i] : The value of ‘res’ is incremented by
arr[i] (why? If elements from 0 to (i-1) can represent 1 to ‘res-1′, then elements from 0 to i can represent
from 1 to ‘res + arr[i] – 1′ be adding ‘arr[i]’ to all subsets that represent 1 to ‘res’)

// C++ program to find the smallest positive value that cannot be

// represented as sum of subsets of a given sorted array
#include <iostream>
// Returns the smallest number that cannot be represented as sum

// of subset of elements from set represented by sorted array arr[0..n-1]
int findSmallest(int arr[], int n)
{
// Traverse the array and increment 'res' if arr[i] is

// smaller than or equal to 'res'.
for (int i = 0; i < n && arr[i] <= res; i++)
res = res + arr[i];
return res;
}

int main()
{
int arr1[] = {1, 3, 4, 5};
cout << findSmallest(arr1, n1) << endl;
int arr2[] = {1, 2, 6, 10, 11, 15};

int arr3[] = {1, 1, 1, 1};

int arr4[] = {1, 1, 3, 4};

return 0;
}

Output:

2
4
5
10

Time Complexity of above program is O(n).
This article is contributed by Rahul Gupta. Please write comments if you find anything incorrect, or you
Find the first repeating element in an array of integers
Given an array of integers, find the first repeating element in it. We need to find the element that occurs
more than once and whose index of first occurrence is smallest.
Examples:
Input: arr[] = {10, 5, 3, 4, 3, 5, 6}

Output: 5 [5 is the first element that repeats]
Input: arr[] = {6, 10, 5, 4, 9, 120, 4, 6, 10}

Output: 6 [6 is the first element that repeats]

A Simple Solution is to use two nested loops. The outer loop picks an element one by one, the inner loop
checks whether the element is repeated or not. Once we find an element that repeats, we break the loops and
print the element. Time Complexity of this solution is O(n2)
We can Use Sorting to solve the problem in O(nLogn) time. Following are detailed steps.
1) Copy the given array to an auxiliary array temp[].
2) Sort the temp array using a O(nLogn) time sorting algorithm.
3) Scan the input array from left to right. For every element, count its occurrences in temp[] using binary
search. As soon as we find an element that occurs more than once, we return the element. This step can be
done in O(nLogn) time.
We can Use Hashing to solve this in O(n) time on average. The idea is to traverse the given array from
right to left and update the minimum index whenever we find an element that has been visited on right side.
Thanks to Mohammad Shahid for suggesting this solution.
Following is Java implementation of this idea.

/* Java program to find first repeating element in arr[] */

import java.util.*;
class Main
{
// This function prints the first repeating element in arr[]
static void printFirstRepeating(int arr[])
{
// Initialize index of first repeating element
int min = -1;
// Creates an empty hashset

HashSet<Integer> set = new HashSet<>();
// Traverse the input array from right to left

for (int i=arr.length-1; i>=0; i--)
{
// If element is already in hash set, update min
if (set.contains(arr[i]))
min = i;
else // Else add element to hash set

set.add(arr[i]);
}
// Print the result

if (min != -1)
System.out.println("The first repeating element is " + arr[min]);
else
System.out.println("There are no repeating elements");
}
// Driver method to test above method

public static void main (String[] args) throws java.lang.Exception
{
int arr[] = {10, 5, 3, 4, 3, 5, 6};
printFirstRepeating(arr);
}
}

Output:

The first repeating element is 5

discussed above.
Find common elements in three sorted arrays
Given three arrays sorted in non-decreasing order, print all common elements in these arrays.
Examples:
ar1[] = {1, 5, 10, 20, 40, 80}

ar2[] = {6, 7, 20, 80, 100}
ar3[] = {3, 4, 15, 20, 30, 70, 80, 120}
Output: 20, 80
ar1[] = {1, 5, 5}
ar2[] = {3, 4, 5, 5, 10}
ar3[] = {5, 5, 10, 20}
Outptu: 5, 5

A simple solution is to first find intersection of two arrays and store the intersection in a temporary array,
then find the intersection of third array and temporary array. Time complexity of this solution is O(n1 + n2 +
n3) where n1, n2 and n3 are sizes of ar1[], ar2[] and ar3[] respectively.
The above solution requires extra space and two loops, we can find the common elements using a single loop
and without extra space. The idea is similar to intersection of two arrays. Like two arrays loop, we run a loop
and traverse three arrays.
Let the current element traversed in ar1[] be x, in ar2[] be y and in ar3[] be z. We can have following cases
inside the loop.
1) If x, y and z are same, we can simply print any of them as common element and move ahead in all three
arrays.
2) Else If x y and y > z), we can simply move ahead in ar3[] as z cannot be a common element.

// C++ program to print common elements in three arrays

#include <iostream>
// This function prints common elements in ar1

int findCommon(int ar1[], int ar2[], int ar3[], int n1, int n2, int n3)
{
// Initialize starting indexes for ar1[], ar2[] and ar3[]
int i = 0, j = 0, k = 0;
// Iterate through three arrays while all arrays have elements

while (i < n1 && j < n2 && k < n3)
{
// If x = y and y = z, print any of them and move ahead in all arrays
if (ar1[i] == ar2[j] && ar2[j] == ar3[k])
{ cout << ar1[i] << " "; i++; j++; k++; }
// x < y
else if (ar1[i] < ar2[j])
i++;
// y < z
else if (ar2[j] < ar3[k])
j++;
// We reach here when x > y and z < y, i.e., z is smallest

else
k++;
}
}

int main()
{
int ar1[] = {1, 5, 10, 20, 40, 80};
int ar2[] = {6, 7, 20, 80, 100};
int ar3[] = {3, 4, 15, 20, 30, 70, 80, 120};
cout << "Common Elements are ";

findCommon(ar1, ar2, ar3, n1, n2, n3);
return 0;
}

Output:

Common Elements are 20 80

Time complexity of the above solution is O(n1 + n2 + n3). In worst case, the largest sized array may have all
small elements and middle sized array has all middle elements.
This article is compiled by Rahul Gupta Please write comments if you find anything incorrect, or you want
Minimum no. of iterations to pass information to all nodes in the tree
Given a very large n-ary tree. Where the root node has some information which it wants to pass to all of its
children down to the leaves with the constraint that it can only pass the information to one of its children at
a time (take it as one iteration).
Now in the next iteration the child node can transfer that information to only one of its children and at the
same time instance the child’s parent i.e. root can pass the info to one of its remaining children. Continuing
in this way we have to find the minimum no of iterations required to pass the information to all nodes in the
tree.
Minimum no of iterations for tree below is 6. The root A first passes information to B. In next iteration, A
passes information to E and B passes information to H and so on.
This can be done using Post Order Traversal. The idea is to consider height and children count on each and
every node.
If a child node i takes ci iterations to pass info below its subtree, then its parent will take (ci + 1) iterations to
pass info to subtree rooted at that child i.
If parent has more children, it will pass info to them in subsequent iterations. Let’s say children of a parent
takes c1, c2, c3, c4, …, cn iterations to pass info in their own subtree, Now parent has to pass info to these n
children one by one in n iterations. If parent picks child i in ith iteration, then parent will take (i + ci)
iterations to pass info to child i and all it’s subtree.
In any iteration, when parent passes info a child i+1, children (1 to i) which got info from parent already in
previous iterations, will pass info to further down in subsequent iterations, if any child (1 to i) has its own
child further down.
To pass info to whole tree in minimum iterations, it needs to be made sure that bandwidth is utilized as
efficiently as possible (i.e. maximum passable no of nodes should pass info further down in any iteration)
The best possible scenario would be that in nth iteration, n different nodes pass info to their child.
Nodes with height = 0: (Trivial case) Leaf node has no children (no information passing needed), so no of
iterations would be ZERO.
Nodes with height = 1: Here node has to pass info to all the children one by one (all children are leaf
node, so no more information passing further down). Since all children are leaf, node can pass info to any
child in any order (pick any child who didn’t receive the info yet). One iteration needed for each child and so
no of iterations would be no of children.So node with height 1 with n children will take n iterations.
Take a counter initialized with ZERO, loop through all children and keep incrementing counter.
Nodes with height > 1: Let’s assume that there are n children (1 to n) of a node and minimum no
iterations for all n children are c1, c2, …., cn.
To make sure maximum no of nodes participate in info passing in any iteration, parent should 1st pass info
to that child who will take maximum iteration to pass info further down in subsequent iterations. i.e. in any
iteration, parent should choose the child who takes maximum iteration later on. It can be thought of as a
greedy approach where parent choose that child 1st, who needs maximum no of iterations so that all
subsequent iterations can be utilized efficiently.
If parent goes in any other fashion, then in the end, there could be some nodes which are done quite early,
sitting idle and so bandwidth is not utilized efficiently in further iterations.
If there are two children i and j with minimum iterations ci and cj where ci > cj, then If parent picks child j
1st then no of iterations needed by parent to pass info to both children and their subtree would be:max (1 +
cj, 2 + ci) = 2 + ci
If parent picks child i 1st then no of iterations needed by parent to pass info to both children and their
subtree would be: max(1 + ci, 2 + cj) = 1 + ci (So picking ci gives better result than picking cj)
This tells that parent should always choose child i with max ci value in any iteration.
SO here greedy approach is:
sort all ci values decreasing order,
let’s say after sorting, values are c1 > c2 > c3 > …. > cn
take a counter c, set c = 1 + c1 (for child with maximum no of iterations)
for all children i from 2 to n, c = c + 1 + ci
then total no of iterations needed by parent is max(n, c)
Let minItr(A) be the minimum iteration needed to pass info from node A to it’s all the sub-tree. Let
child(A) be the count of all children for node A. So recursive relation would be:
1. Get minItr(B) of all children (B) of a node (A)

2. Sort all minItr(B) in descending order
3. Get minItr of A based on all minItr(B)
minItr(A) = child(A)
For children B from i = 0 to child(A)
minItr(A) = max ( minItr(A), minItr(B) + i + 1)
Base cases would be:

If node is leaf, minItr = 0
If node's height is 1, minItr = children count

// C++ program to find minimum number of iterations to pass

// information from root to all nodes in an n-ary tree
#include<iostream>
#include<list>
#include<cmath>
#include <stdlib.h>

// A class to represent n-ary tree (Note that the implementation
// is similar to graph for simplicity of implementation
class NAryTree
{
int N; // No. of nodes in Tree

// Pointer to an array containing list of children
list<int> *adj;

// A function used by getMinIter(), it basically does postorder
void getMinIterUtil(int v, int minItr[]);
public:
NAryTree(int N); // Constructor

// function to add a child w to v
void addChild(int v, int w);

// The main function to find minimum iterations
int getMinIter();
static int compare(const void * a, const void * b);

};

NAryTree::NAryTree(int N)
{
this->N = N;
adj = new list<int>[N];
}

// To add a child w to v
void NAryTree::addChild(int v, int w)
{
}

/* A recursive function to used by getMinIter(). This function
// mainly does postorder traversal and get minimum iteration of all children
// of node u, sort them in decreasing order and then get minimum iteration
// of node u
1. Get minItr(B) of all children (B) of a node (A)

2. Sort all minItr(B) in descending order
3. Get minItr of A based on all minItr(B)
minItr(A) = child(A) -->> child(A) is children count of node A
For children B from i = 0 to child(A)
minItr(A) = max ( minItr(A), minItr(B) + i + 1)
Base cases would be:

If node is leaf, minItr = 0
If node's height is 1, minItr = children count
*/
void NAryTree::getMinIterUtil(int u, int minItr[])

{
minItr[u] = adj[u].size();
int *minItrTemp = new int[minItr[u]];
int k = 0, tmp = 0;
for (i = adj[u].begin(); i!= adj[u].end(); ++i)
{
getMinIterUtil(*i, minItr);
minItrTemp[k++] = minItr[*i];
}
qsort(minItrTemp, minItr[u], sizeof (int), compare);
for (k = 0; k < adj[u].size(); k++)
{
tmp = minItrTemp[k] + k + 1;
minItr[u] = max(minItr[u], tmp);
}
delete[] minItrTemp;
}

// The function to do PostOrder traversal. It uses
// recursive getMinIterUtil()
int NAryTree::getMinIter()
{
// Set minimum iteration all the vertices as zero
int *minItr = new int[N];
int res = -1;
for (int i = 0; i < N; i++)
minItr[i] = 0;

// Start Post Order Traversal from Root
getMinIterUtil(0, minItr);
res = minItr[0];
delete[] minItr;
return res;
}
int NAryTree::compare(const void * a, const void * b)

{
return ( *(int*)b - *(int*)a );
}

// Driver function to test above functions
int main()
{
// TestCase 1
NAryTree tree1(17);
tree1.addChild(0, 1);





cout << "TestCase 1 - Minimum Iteration: "
<< tree1.getMinIter() << endl;

// TestCase 2
NAryTree tree2(3);

// TestCase 3
NAryTree tree3(1);

// TestCase 4
NAryTree tree4(6);
NAryTree tree4(6);

// TestCase 5
NAryTree tree5(6);

// TestCase 6
NAryTree tree6(6);

// TestCase 7
NAryTree tree7(14);

// TestCase 8
NAryTree tree8(14);
// TestCase 9
NAryTree tree9(25);



return 0;
}

Output:

TestCase 1 - Minimum Iteration: 6

Given an n x n square matrix, find sum of all sub-squares of size k x k
Given an n x n square matrix, find sum of all sub-squares of size k x k where k is smaller than or equal to n.
Examples
Input:
n = 5, k = 3
arr[][] = { {1, 1, 1, 1, 1},
{2, 2, 2, 2, 2},
{3, 3, 3, 3, 3},
{4, 4, 4, 4, 4},
{5, 5, 5, 5, 5},
};
Output:
18 18 18
27 27 27
36 36 36
Input:
n = 3, k = 2
arr[][] = { {1, 2, 3},
{4, 5, 6},
{7, 8, 9},
};
Output:
12 16
24 28

A Simple Solution is to one by one pick starting point (leftmost-topmost corner) of all possible sub-
squares. Once the starting point is picked, calculate sum of sub-square starting with the picked starting
point.
Following is C++ implementation of this idea.

// A simple C++ program to find sum of all subsquares of size k x k

#include <iostream>
// Size of given matrix

#define n 5
// A simple function to find sum of all sub-squares of size k x k

// in a given square matrix of size n x n
void printSumSimple(int mat[][n], int k)
{
// k must be smaller than or equal to n
if (k > n) return;
// row number of first cell in current sub-square of size k x k

for (int i=0; i<n-k+1; i++)
{
// column of first cell in current sub-square of size k x k
for (int j=0; j<n-k+1; j++)
{
// Calculate and print sum of current sub-square
int sum = 0;
for (int p=i; p<k+i; p++)
for (int q=j; q<k+j; q++)
sum += mat[p][q];
cout << sum << " ";
}
// Line separator for sub-squares starting with next row

cout << endl;
}
}

int main()
{
int mat[n][n] = {{1, 1, 1, 1, 1},
{2, 2, 2, 2, 2},
{3, 3, 3, 3, 3},
{4, 4, 4, 4, 4},
{5, 5, 5, 5, 5},
};
int k = 3;
printSumSimple(mat, k);
return 0;
}

Output:
18 18 18
27 27 27
36 36 36

Time complexity of above solution is O(k2n2). We can solve this problem in O(n2) time using a Tricky
Solution. The idea is to preprocess the given square matrix. In the preprocessing step, calculate sum of all
vertical strips of size k x 1 in a temporary square matrix stripSum[][]. Once we have sum of all vertical strips,
we can calculate sum of first sub-square in a row as sum of first k strips in that row, and for remaining sub-
squares, we can calculate sum in O(1) time by removing the leftmost strip of previous subsquare and adding
the rightmost strip of new square.
Following is C++ implementation of this idea.
// An efficient C++ program to find sum of all subsquares of size k x k

#include <iostream>
// Size of given matrix

#define n 5
// A O(n^2) function to find sum of all sub-squares of size k x k

// in a given square matrix of size n x n
void printSumTricky(int mat[][n], int k)
{
if (k > n) return;
// 1: PREPROCESSING
// To store sums of all strips of size k x 1
int stripSum[n][n];
// Go column by column
{
// Calculate sum of first k x 1 rectangle in this column
int sum = 0;
for (int i=0; i<k; i++)
sum += mat[i][j];
stripSum[0][j] = sum;
// Calculate sum of remaining rectangles

{
sum += (mat[i+k-1][j] - mat[i-1][j]);
stripSum[i][j] = sum;
}
}
// 2: CALCULATE SUM of Sub-Squares using stripSum[][]

{
// Calculate and print sum of first subsquare in this row
int sum = 0;
for (int j = 0; j<k; j++)
sum += stripSum[i][j];
cout << sum << " ";
// Calculate sum of remaining squares in current row by

// removing the leftmost strip of previous sub-square and
// adding a new strip
for (int j=1; j<n-k+1; j++)
{
sum += (stripSum[i][j+k-1] - stripSum[i][j-1]);
cout << sum << " ";
}
cout << endl;
}
}

int main()
{
int mat[n][n] = {{1, 1, 1, 1, 1},
{2, 2, 2, 2, 2},
{3, 3, 3, 3, 3},
{4, 4, 4, 4, 4},
{5, 5, 5, 5, 5},
};
int k = 3;
printSumTricky(mat, k);
return 0;
}

Output:
18 18 18
27 27 27
36 36 36

Analysis of Algorithm | Set 5 (Amortized Analysis Introduction)
Amortized Analysis is used for algorithms where an occasional operation is very slow, but most of the other
operations are faster. In Amortized Analysis, we analyze a sequence of operations and guarantee a worst case
average time which is lower than the worst case time of a particular expensive operation.
The example data structures whose operations are analyzed using Amortized Analysis are Hash Tables,
Disjoint Sets and Splay Trees.
Let us consider an example of a simple hash table insertions. How do we decide table size? There is a trade-
off between space and time, if we make hash-table size big, search time becomes fast, but space required
becomes high.
The solution to this trade-off problem is to use Dynamic Table (or Arrays). The idea is to increase size of
table whenever it becomes full. Following are the steps to follow when table becomes full.
1) Allocate memory for a larger table of size, typically twice the old table.
2) Copy the contents of old table to new table.
3) Free the old table.
If the table has space available, we simply insert new item in available space.
What is the time complexity of n insertions using the above scheme?

If we use simple analysis, the worst case cost of an insertion is O(n). Therefore, worst case cost of n inserts is
n * O(n) which is O(n2). This analysis gives an upper bound, but not a tight upper bound for n insertions as
all insertions don’t take Θ(n) time.
So using Amortized Analysis, we could prove that the Dynamic Table scheme has O(1) insertion time which
is a great result used in hashing. Also, the concept of dynamic table is used in vectors in C++, ArrayList in
Java.
Following are few important notes.

1) Amortized cost of a sequence of operations can be seen as expenses of a salaried person. The average
monthly expense of the person is less than or equal to the salary, but the person can spend more money in a
particular month by buying a car or something. In other months, he or she saves money for the expensive
month.
2) The above Amortized Analysis done for Dynamic Array example is called Aggregate Method. There are
two more powerful ways to do Amortized analysis called Accounting Method and Potential Method.
We will be discussing the other two methods in separate posts.
3) The amortized analysis doesn’t involve probability. There is also another different notion of average case
running time where algorithms use randomization to make them faster and expected running time is faster
than the worst case running time. These algorithms are analyzed using Randomized Analysis. Examples of
these algorithms are Randomized Quick Sort, Quick Select and Hashing. We will soon be covering
Randomized analysis in a different post.
Sources:
Berkeley Lecture 35: Amortized Analysis
MIT Lecture 13: Amortized Algorithms, Table Doubling, Potential Method
http://www.cs.cornell.edu/courses/cs3110/2011sp/lectures/lec20-amortized/amortized.htm
discussed above.
How to efficiently implement k Queues in a single array?
We have discussed efficient implementation of k stack in an array. In this post, same for queue is discussed.
Following is the detailed problem statement.
Create a data structure kQueues that represents k queues. Implementation of kQueues should use only one
array, i.e., k queues should use the same array for storing elements. Following functions must be
supported by kQueues.
enqueue(int x, int qn) –> adds x to queue number ‘qn’ where qn is from 0 to k-1
dequeue(int qn) –> deletes an element from queue number ‘qn’ where qn is from 0 to k-1
Method 1 (Divide the array in slots of size n/k)

A simple way to implement k queues is to divide the array in k slots of size n/k each, and fix the slots for
different queues, i.e., use arr[0] to arr[n/k-1] for first queue, and arr[n/k] to arr[2n/k-1] for queue2 where
arr[] is the array to be used to implement two queues and size of array be n.
The problem with this method is inefficient use of array space. An enqueue operation may result in overflow
even if there is space available in arr[]. For example, consider k as 2 and array size n as 6. Let we enqueue 3
elements to first and do not enqueue anything to second second queue. When we enqueue 4th element to
first queue, there will be overflow even if we have space for 3 more elements in array.

The idea is similar to the stack post, here we need to use three extra arrays. In stack post, we needed to extra
arrays, one more array is required because in queues, enqueue() and dequeue() operations are done at
different ends.
Following are the three extra arrays are used:

1) front[]: This is of size k and stores indexes of front elements in all queues.
2) rear[]: This is of size k and stores indexes of rear elements in all queues.
2) next[]: This is of size n and stores indexes of next item for all items in array arr[].
Here arr[] is actual array that stores k stacks.
Together with k queues, a stack of free slots in arr[] is also maintained. The top of this stack is stored in a
variable ‘free’.
All entries in front[] are initialized as -1 to indicate that all queues are empty. All entries next[i] are
initialized as i+1 because all slots are free initially and pointing to next slot. Top of free stack, ‘free’ is
initialized as 0.
// A C++ program to demonstrate implementation of k queues in a single

// array in time and space efficient way
#include<iostream>
#include<climits>
// A C++ class to represent k queues in a single array of size n

class kQueues
{
int *arr; // Array of size n to store actual content to be stored in queue
int *front; // Array of size k to store indexes of front elements of queue
int *rear; // Array of size k to store indexes of rear elements of queue
int *next; // Array of size n to store next entry in all queues
// and free list
// and free list
int n, k;
int free; // To store beginning index of free list
public:
//constructor to create k queue in an array of size n
kQueues(int k, int n);
// A utility function to check if there is space available

bool isFull() { return (free == -1); }
// To enqueue an item in queue number 'qn' where qn is from 0 to k-1

void enqueue(int item, int qn);
// To dequeue an from queue number 'qn' where qn is from 0 to k-1

int dequeue(int qn);
// To check whether queue number 'qn' is empty or not

bool isEmpty(int qn) { return (front[qn] == -1); }
};
// Constructor to create k queues in an array of size n

kQueues::kQueues(int k1, int n1)
{
// Initialize n and k, and allocate memory for all arrays
k = k1, n = n1;
arr = new int[n];
front = new int[k];
rear = new int[k];
next = new int[n];
// Initialize all queues as empty

for (int i = 0; i < k; i++)
front[i] = -1;
// Initialize all spaces as free

free = 0;
next[i] = i+1;
next[n-1] = -1; // -1 is used to indicate end of free list
}
// To enqueue an item in queue number 'qn' where qn is from 0 to k-1

void kQueues::enqueue(int item, int qn)
{
// Overflow check
if (isFull())
{
cout << "\nQueue Overflow\n";
return;
}
int i = free; // Store index of first free slot
// Update index of free slot to index of next slot in free list

free = next[i];
if (isEmpty(qn))
front[qn] = i;
else
next[rear[qn]] = i;
next[i] = -1;
// Update next of rear and then rear for queue number 'qn'
rear[qn] = i;
rear[qn] = i;
// Put the item in array

arr[i] = item;
}
// To dequeue an from queue number 'qn' where qn is from 0 to k-1

int kQueues::dequeue(int qn)
{
// Underflow checkSAS
if (isEmpty(qn))
{
cout << "\nQueue Underflow\n";
return INT_MAX;
}
// Find index of front item in queue number 'qn'

int i = front[qn];
front[qn] = next[i]; // Change top to store next of previous top
// Attach the previous front to the beginning of free list

next[i] = free;
free = i;
// Return the previous front item

return arr[i];
}
/* Driver program to test kStacks class */

int main()
{
// Let us create 3 queue in an array of size 10
int k = 3, n = 10;
kQueues ks(k, n);
// Let us put some items in queue number 2

ks.enqueue(15, 2);
ks.enqueue(45, 2);

ks.enqueue(17, 1);
ks.enqueue(49, 1);
ks.enqueue(39, 1);

ks.enqueue(11, 0);
ks.enqueue(9, 0);
ks.enqueue(7, 0);
cout << "Dequeued element from queue 2 is " << ks.dequeue(2) << endl;
return 0;
}

Output:

Dequeued element from queue 2 is 15

Time complexities of enqueue() and dequeue() is O(1).
The best part of above implementation is, if there is a slot available in queue, then an item can be enqueued
in any of the queues, i.e., no wastage of space. This method requires some extra space. Space may not be an
issue because queue items are typically large, for example queues of employees, students, etc where every
item is of hundreds of bytes. For such large queues, the extra space used is comparatively very less as we use
three integer arrays as extra space.
Mobile Numeric Keypad Problem
Given the mobile numeric keypad. You can only press buttons that are up, left, right or down to the current
button. You are not allowed to press bottom row corner buttons (i.e. * and # ).
Given a number N, find out the number of possible numbers of given length.
Examples:
For N=1, number of possible numbers would be 10 (0, 1, 2, 3, …., 9)
For N=2, number of possible numbers would be 36
Possible numbers: 00,08 11,12,14 22,21,23,25 and so on.
If we start with 0, valid numbers will be 00, 08 (count: 2)
If we start with 1, valid numbers will be 11, 12, 14 (count: 3)
If we start with 2, valid numbers will be 22, 21, 23,25 (count: 4)
If we start with 3, valid numbers will be 33, 32, 36 (count: 3)
If we start with 4, valid numbers will be 44,41,45,47 (count: 4)
If we start with 5, valid numbers will be 55,54,52,56,58 (count: 5)
………………………………
………………………………
We need to print the count of possible numbers.
N = 1 is trivial case, number of possible numbers would be 10 (0, 1, 2, 3, …., 9)

For N > 1, we need to start from some button, then move to any of the four direction (up, left, right or down)
which takes to a valid button (should not go to *, #). Keep doing this until N length number is obtained
(depth first traversal).
Recursive Solution:
Mobile Keypad is a rectangular grid of 4X3 (4 rows and 3 columns)
Lets say Count(i, j, N) represents the count of N length numbers starting from position (i, j)
If N = 1
Count(i, j, N) = 10
Else
Count(i, j, N) = Sum of all Count(r, c, N-1) where (r, c) is new
position after valid move of length 1 from current
position (i, j)

Following is C implementation of above recursive formula.
// A Naive Recursive C program to count number of possible numbers

// of given length
#include <stdio.h>
#include <stdio.h>
// left, up, right, down move from current location

int row[] = {0, 0, -1, 0, 1};
int col[] = {0, -1, 0, 1, 0};
// Returns count of numbers of length n starting from key position

// (i, j) in a numeric keyboard.
int getCountUtil(char keypad[][3], int i, int j, int n)
{
if (keypad == NULL || n <= 0)
return 0;
// From a given key, only one number is possible of length 1

if (n == 1)
return 1;
int k=0, move=0, ro=0, co=0, totalCount = 0;
// move left, up, right, down from current location and if

// new location is valid, then get number count of length
// (n-1) from that new position and add in count obtained so far
for (move=0; move<5; move++)
{
ro = i + row[move];
co = j + col[move];
if (ro >= 0 && ro <= 3 && co >=0 && co <= 2 &&
keypad[ro][co] != '*' && keypad[ro][co] != '#')
{
totalCount += getCountUtil(keypad, ro, co, n-1);
}
}
return totalCount;
}
// Return count of all possible numbers of length n

// in a given numeric keyboard
int getCount(char keypad[][3], int n)
{
// Base cases
if (keypad == NULL || n <= 0)
return 0;
if (n == 1)
return 10;
int i=0, j=0, totalCount = 0;

for (i=0; i<4; i++) // Loop on keypad row
{
for (j=0; j<3; j++) // Loop on keypad column
{
// Process for 0 to 9 digits
if (keypad[i][j] != '*' && keypad[i][j] != '#')
{
// Get count when number is starting from key
// position (i, j) and add in count obtained so far
totalCount += getCountUtil(keypad, i, j, n);
}
}
}
return totalCount;
}

{
char keypad[4][3] = {{'1','2','3'},
{'4','5','6'},
{'7','8','9'},
{'*','0','#'}};
printf("Count for numbers of length %d: %d\n", 1, getCount(keypad, 1));
return 0;
}

Output:

Count for numbers of length 1: 10

Dynamic Programming
There are many repeated traversal on smaller paths (traversal for smaller N) to find all possible longer paths
(traversal for bigger N). See following two diagrams for example. In this traversal, for N = 4 from two starting
positions (buttons ‘4’ and ‘8’), we can see there are few repeated traversals for N = 2 (e.g. 4 -> 1, 6 -> 3, 8 ->
9, 8 -> 7 etc).
Since the problem has both properties: Optimal Substructure and Overlapping Subproblems, it can be
efficiently solved using dynamic programming.
Following is C program for dynamic programming implementation.
// A Dynamic Programming based C program to count number of

// possible numbers of given length
#include <stdio.h>

{
if(keypad == NULL || n <= 0)
return 0;
if(n == 1)
return 10;
// left, up, right, down move from current location

int row[] = {0, 0, -1, 0, 1};
int col[] = {0, -1, 0, 1, 0};
// taking n+1 for simplicity - count[i][j] will store

// number count starting with digit i and length j
int count[10][n+1];
int i=0, j=0, k=0, move=0, ro=0, co=0, num = 0;
int nextNum=0, totalCount = 0;
// count numbers starting with digit i and of lengths 0 and 1

for (i=0; i<=9; i++)
{
count[i][0] = 0;
count[i][1] = 1;
}
// Bottom up - Get number count of length 2, 3, 4, ... , n

for (k=2; k<=n; k++)
{
for (i=0; i<4; i++) // Loop on keypad row
{
for (j=0; j<3; j++) // Loop on keypad column
{
// Process for 0 to 9 digits
{
// Here we are counting the numbers starting with
// digit keypad[i][j] and of length k keypad[i][j]
// will become 1st digit, and we need to look for
// (k-1) more digits
num = keypad[i][j] - '0';
count[num][k] = 0;
// move left, up, right, down from current location

// and if new location is valid, then get number
// count of length (k-1) from that new digit and
// add in count we found so far
for (move=0; move<5; move++)
{
ro = i + row[move];
co = j + col[move];
if (ro >= 0 && ro <= 3 && co >=0 && co <= 2 &&
keypad[ro][co] != '*' && keypad[ro][co] != '#')
{
nextNum = keypad[ro][co] - '0';
count[num][k] += count[nextNum][k-1];
}
}
}
}
}
}
// Get count of all possible numbers of length "n" starting

// with digit 0, 1, 2, ..., 9
totalCount = 0;
for (i=0; i<=9; i++)
totalCount += count[i][n];
return totalCount;
}

{
char keypad[4][3] = {{'1','2','3'},
{'4','5','6'},
{'7','8','9'},
{'*','0','#'}};
return 0;
}

Output:


A Space Optimized Solution:

The above dynamic programming approach also runs in O(n) time and requires O(n) auxiliary space, as only
one for loop runs n times, other for loops runs for constant time. We can see that nth iteration needs data
from (n-1)th iteration only, so we need not keep the data from older iterations. We can have a space efficient
dynamic programming approach with just two arrays of size 10. Thanks to Nik for suggesting this solution.
// A Space Optimized C program to count number of possible numbers

// of given length
#include <stdio.h>

{
if(keypad == NULL || n <= 0)
return 0;
if(n == 1)
return 10;
// odd[i], even[i] arrays represent count of numbers starting

// with digit i for any length j
int odd[10], even[10];
int i = 0, j = 0, useOdd = 0, totalCount = 0;
for (i=0; i<=9; i++)

odd[i] = 1; // for j = 1
for (j=2; j<=n; j++) // Bottom Up calculation from j = 2 to n

{
useOdd = 1 - useOdd;
// Here we are explicitly writing lines for each number 0

// to 9. But it can always be written as DFS on 4X3 grid
// using row, column array valid moves
if(useOdd == 1)
{
even[0] = odd[0] + odd[8];
even[1] = odd[1] + odd[2] + odd[4];
even[2] = odd[2] + odd[1] + odd[3] + odd[5];
even[3] = odd[3] + odd[2] + odd[6];
even[5] = odd[5] + odd[2] + odd[4] + odd[8] + odd[6];
even[7] = odd[7] + odd[4] + odd[8];
even[8] = odd[8] + odd[0] + odd[5] + odd[7] + odd[9];
even[9] = odd[9] + odd[6] + odd[8];
}
else
{
odd[0] = even[0] + even[8];
odd[1] = even[1] + even[2] + even[4];
odd[2] = even[2] + even[1] + even[3] + even[5];
odd[5] = even[5] + even[2] + even[4] + even[8] + even[6];
odd[8] = even[8] + even[0] + even[5] + even[7] + even[9];
}
}
// Get count of all possible numbers of length "n" starting

// with digit 0, 1, 2, ..., 9
totalCount = 0;
if(useOdd == 1)
{
for (i=0; i<=9; i++)
totalCount += even[i];
}
else
{
for (i=0; i<=9; i++)
totalCount += odd[i];
}
return totalCount;
}

int main()
{
char keypad[4][3] = {{'1','2','3'},
{'4','5','6'},
{'7','8','9'},
{'*','0','#'}
};
return 0;
}

Output:


Minimum Cost Polygon Triangulation
A triangulation of a convex polygon is formed by drawing diagonals between non-adjacent vertices (corners)
such that the diagonals never intersect. The problem is to find the cost of triangulation with the minimum
cost. The cost of a triangulation is sum of the weights of its component triangles. Weight of each triangle is
its perimeter (sum of lengths of all sides)
See following example taken from this source.
Two triangulations of the same convex pentagon. The triangulation on the left has a cost of 8 + 2√2 + 2√5
(approximately 15.30), the one on the right has a cost of 4 + 2√2 + 4√5 (approximately 15.77).
This problem has recursive substructure. The idea is to divide the polygon into three parts: a single triangle,
the sub-polygon to the left, and the sub-polygon to the right. We try all possible divisions like this and find
the one that minimizes the cost of the triangle plus the cost of the triangulation of the two sub-polygons.
Let Minimum Cost of triangulation of vertices from i to j be minCost(i, j)

If j
Following is C++ implementation of above naive recursive formula.

// Recursive implementation for minimum cost convex polygon triangulation
#include <iostream>
#include <cmath>
#define MAX 1000000.0
// Structure of a point in 2D plane

struct Point
{
int x, y;
};
// Utility function to find minimum of two double values

double min(double x, double y)
{
return (x <= y)? x : y;
}
// A utility function to find distance between two points in a plane

double dist(Point p1, Point p2)
{
return sqrt((p1.x - p2.x)*(p1.x - p2.x) +
(p1.y - p2.y)*(p1.y - p2.y));
}
// A utility function to find cost of a triangle. The cost is considered

// as perimeter (sum of lengths of all edges) of the triangle
double cost(Point points[], int i, int j, int k)
{
Point p1 = points[i], p2 = points[j], p3 = points[k];
return dist(p1, p2) + dist(p2, p3) + dist(p3, p1);
}
// A recursive function to find minimum cost of polygon triangulation

// The polygon is represented by points[i..j].
double mTC(Point points[], int i, int j)
{
// There must be at least three points between i and j
// (including i and j)
if (j < i+2)
return 0;
// Initialize result as infinite

double res = MAX;
// Find minimum triangulation by considering all

for (int k=i+1; k<j; k++)
res = min(res, (mTC(points, i, k) + mTC(points, k, j) +
cost(points, i, k, j)));
return res;
}

int main()
{
Point points[] = {{0, 0}, {1, 0}, {2, 1}, {1, 2}, {0, 2}};
cout << mTC(points, 0, n-1);
return 0;
}

Output:
15.3006
The above problem is similar to Matrix Chain Multiplication. The following is recursion t
ree for mTC(points[], 0, 4).
It can be easily seen in the above recursion tree that the problem has many overlapping
subproblems. Since the problem has both properties: Optimal Substructure and Overlapping
Subproblems, it can be efficiently solved using dynamic programming.
Following is C++ implementation of dynamic programming solution.

// A Dynamic Programming based program to find minimum cost of convex
// polygon triangulation
#include <iostream>
#include <cmath>
#define MAX 1000000.0
// Structure of a point in 2D plane

struct Point
{
int x, y;
};
// Utility function to find minimum of two double values

double min(double x, double y)
{
return (x <= y)? x : y;
}
// A utility function to find distance between two points in a plane

double dist(Point p1, Point p2)
{
return sqrt((p1.x - p2.x)*(p1.x - p2.x) +
(p1.y - p2.y)*(p1.y - p2.y));
}
// A utility function to find cost of a triangle. The cost is considered

// as perimeter (sum of lengths of all edges) of the triangle
double cost(Point points[], int i, int j, int k)
{
Point p1 = points[i], p2 = points[j], p3 = points[k];
return dist(p1, p2) + dist(p2, p3) + dist(p3, p1);
}
// A Dynamic programming based function to find minimum cost for convex

// polygon triangulation.
double mTCDP(Point points[], int n)
{
// There must be at least 3 points to form a triangle
if (n < 3)
return 0;
// table to store results of subproblems. table[i][j] stores cost of

// triangulation of points from i to j. The entry table[0][n-1] stores
// the final result.
double table[n][n];
// is filled in diagonal fashion i.e., from diagonal elements to
// table[0][n-1] which is the result.
for (int gap = 0; gap < n; gap++)
{
for (int i = 0, j = gap; j < n; i++, j++)
{
if (j < i+2)
table[i][j] = 0.0;
else
{
table[i][j] = MAX;
for (int k = i+1; k < j; k++)
{
double val = table[i][k] + table[k][j] + cost(points,i,j,k);
if (table[i][j] > val)
table[i][j] = val;
}
}
}
}
}

int main()
{
Point points[] = {{0, 0}, {1, 0}, {2, 1}, {1, 2}, {0, 2}};
cout << mTCDP(points, n);
return 0;
}

Output:
15.3006
Time complexity of the above dynamic programming solution is O(n3).
Please note that the above implementations assume that the points of covnvex polygon are
given in order (either clockwise or anticlockwise)
Exercise:
Extend the above solution to print triangulation also. For the above example, the
optimal triangulation is 0 3 4, 0 1 3, and 1 2 3.
Sources:
http://www.cs.utexas.edu/users/djimenez/utsa/cs3343/lecture12.html
http://www.cs.utoronto.ca/~heap/Courses/270F02/A4/chains/node2.html

Find n’th number in a number system with only 3 and 4
Given a number system with only 3 and 4. Find the nth number in the number system. First few numbers in
the number system are: 3, 4, 33, 34, 43, 44, 333, 334, 343, 344, 433, 434, 443, 444, 3333, 3334, 3343, 3344,
3433, 3434, 3443, 3444, …
Source: Zoho Interview
We can generate all numbers with i digits using the numbers with (i-1) digits. The idea is to first add a ‘3’ as
prefix in all numbers with (i-1) digit, then add a ‘4’. For example, the numbers with 2 digits are 33, 34, 43
and 44. The numbers with 3 digits are 333, 334, 343, 344, 433, 434, 443 and 444 which can be generated by
first adding a 3 as prefix, then 4.
Following are detailed steps.
1) Create an array 'arr[]' of strings size n+1.

2) Initialize arr[0] as empty string. (Number with 0 digits)
3) Do following while array size is smaller than or equal to n
.....a) Generate numbers by adding a 3 as prefix to the numbers generated
in previous iteration. Add these numbers to arr[]
.....a) Generate numbers by adding a 4 as prefix to the numbers generated
in previous iteration. Add these numbers to arr[]

Thanks to kaushik Lele for suggesting this idea in a comment here. Following is C++ implementation for the
same.

// C++ program to find n'th number in a number system with only 3 and 4
#include <iostream>
// Function to find n'th number in a number system with only 3 and 4

void find(int n)
{
// An array of strings to store first n numbers. arr[i] stores i'th number
string arr[n+1];
arr[0] = ""; // arr[0] stores the empty string (String with 0 digits)
// size indicates number of current elements in arr[]. m indicates

// number of elements added to arr[] in previous iteration.
int size = 1, m = 1;
// Every iteration of following loop generates and adds 2*m numbers to

// arr[] using the m numbers generated in previous iteration.
while (size <= n)
{
// Consider all numbers added in previous iteration, add a prefix
// "3" to them and add new numbers to arr[]
for (int i=0; i<m && (size+i)<=n; i++)
arr[size + i] = "3" + arr[size - m + i];
// Add prefix "4" to numbers of previous iteration and add new

// numbers to arr[]
for (int i=0; i<m && (size + m + i)<=n; i++)
arr[size + m + i] = "4" + arr[size - m + i];
// Update no. of elements added in previous iteration

m = m<<1; // Or m = m*2;
// Update size
size = size + m;
}
cout << arr[n] << endl;
}

int main()
{
for (int i = 1; i < 16; i++)
find(i);
return 0;
}

Output:

3
4
33
34
43
44
333
334
343
344
433
434
443
444
3333

This article is contributed by Raman. Please write comments if you find anything incorrect, or you want to
Find Height of Binary Tree represented by Parent array
A given array represents a tree in such a way that the array value gives the parent node of that particular
index. The value of the root node index would always be -1. Find the height of the tree.
Height of a Binary Tree is number of nodes on the path from root to the deepest leaf node, the number
includes both root and leaf.
Input: parent[] = {1 5 5 2 2 -1 3}
Output: 4
The given array represents following Binary Tree
5
/ \
1 2
/ / \
0 3 4
/
6
Input: parent[] = {-1, 0, 0, 1, 1, 3, 5};

Output: 5
The given array represents following Binary Tree
0
/ \
1 2
/ \
3 4
/
5
/
6

Source: Amazon Interview experience | Set 128 (For SDET)
We strongly recommend to minimize your browser and try this yourself first.
A simple solution is to first construct the tree and then find height of the constructed binary tree. The tree
can be constructed recursively by first searching the current root, then recurring for the found indexes and
making them left and right subtrees of root. This solution takes O(n 2) as we have to linearly search for every
node.
An efficient solution can solve the above problem in O(n) time. The idea is to first calculate depth of every
node and store in an array depth[]. Once we have depths of all nodes, we return maximum of all depths.
1) Find depth of all nodes and fill in an auxiliary array depth[].
2) Return maximum value in depth[].
Following are steps to find depth of a node at index i.

1) If it is root, depth[i] is 1.
2) If depth of parent[i] is evaluated, depth[i] is depth[parent[i]] + 1.
3) If depth of parent[i] is not evaluated, recur for parent and assign depth[i] as depth[parent[i]] + 1 (same as
above).

// C++ program to find height using parent array
#include <iostream>
// This function fills depth of i'th element in parent[]. The depth is

// filled in depth[i].
void fillDepth(int parent[], int i, int depth[])
{
// If depth[i] is already filled
if (depth[i])
return;
// If node at index i is root

{
depth[i] = 1;
return;
}
// If depth of parent is not evaluated before, then evaluate

// depth of parent first
if (depth[parent[i]] == 0)
fillDepth(parent, parent[i], depth);
// Depth of this node is depth of parent plus 1

depth[i] = depth[parent[i]] + 1;
}
// This function returns height of binary tree represented by

// parent array
int findHeight(int parent[], int n)
{
// Create an array to store depth of all nodes/ and
// initialize depth of every node as 0 (an invalid
// value). Depth of root is 1
int depth[n];
for (int i = 0; i < n; i++)
depth[i] = 0;
// fill depth of all nodes

for (int i = 0; i < n; i++)
fillDepth(parent, i, depth);
// The height of binary tree is maximum of all depths.

// Find the maximum value in depth[] and assign it to ht.
int ht = depth[0];
if (ht < depth[i])
ht = depth[i];
return ht;
}

int main()
{
// int parent[] = {1, 5, 5, 2, 2, -1, 3};
int parent[] = {-1, 0, 0, 1, 1, 3, 5};
int n = sizeof(parent)/sizeof(parent[0]);
cout << "Height is " << findHeight(parent, n);
return 0;
}

Output:

Height is 5

Note that the time complexity of this programs seems more than O(n). If we take a closer look, we can
observe that depth of every node is evaluated only once.
This article is contributed by Siddharth. Please write comments if you find anything incorrect, or you want
Snake and Ladder Problem
Given a snake and ladder board, find the minimum number of dice throws required to reach the destination
or last cell from source or 1st cell. Basically, the player has total control over outcome of dice throw and
wants to find out minimum number of throws required to reach last cell.
If the player reaches a cell which is base of a ladder, the player has to climb up that ladder and if reaches a
cell is mouth of the snake, has to go down to the tail of snake without a dice throw.
For example consider the board shown on right side (taken from here), the minimum number of dice throws
required to reach cell 30 from cell 1 is 3. Following are steps.
a) First throw two on dice to reach cell number 3 and then ladder to reach 22
b) Then throw 6 to reach 28.
c) Finally through 2 to reach 30.
There can be other solutions as well like (2, 2, 6), (2, 4, 4), (2, 3, 5).. etc.
The idea is to consider the given snake and ladder board as a directed graph with number of vertices equal to
the number of cells in the board. The problem reduces to finding the shortest path in a graph. Every vertex of
the graph has an edge to next six vertices if next 6 vertices do not have a snake or ladder. If any of the next
six vertices has a snake or ladder, then the edge from current vertex goes to the top of the ladder or tail of the
snake. Since all edges are of equal weight, we can efficiently find shortest path using Breadth First Search of
the graph.
Following is C++ implementation of the above idea. The input is represented by two things, first is ‘N’ which
is number of cells in the given board, second is an array ‘move[0…N-1]’ of size N. An entry move[i] is -1 if
there is no snake and no ladder from i, otherwise move[i] contains index of destination cell for the snake or
the ladder at i.
// C++ program to find minimum number of dice throws required to

// reach last cell from first cell of a given snake and ladder
// board
#include<iostream>
#include <queue>
// An entry in queue used in BFS

struct queueEntry
{
int v; // Vertex number
int dist; // Distance of this vertex from source
};
// This function returns minimum number of dice throws required to
// Reach last cell from 0'th cell in a snake and ladder game.
// move[] is an array of size N where N is no. of cells on board
// If there is no snake or ladder from cell i, then move[i] is -1
// Otherwise move[i] contains cell to which snake or ladder at i
// takes to.
int getMinDiceThrows(int move[], int N)
{
// The graph has N vertices. Mark all the vertices as
// not visited
bool *visited = new bool[N];
for (int i = 0; i < N; i++)
visited[i] = false;

queue<queueEntry> q;
// Mark the node 0 as visited and enqueue it.

visited[0] = true;
queueEntry s = {0, 0}; // distance of 0't vertex is also 0
q.push(s); // Enqueue 0'th vertex
// Do a BFS starting from vertex at index 0

queueEntry qe; // A queue entry (qe)
while (!q.empty())
{
qe = q.front();
int v = qe.v; // vertex no. of queue entry
// If front vertex is the destination vertex,

// we are done
if (v == N-1)
break;
// Otherwise dequeue the front vertex and enqueue

// its adjacent vertices (or cell numbers reachable
// through a dice throw)
q.pop();
for (int j=v+1; j<=(v+6) && j<N; ++j)
{
// If this cell is already visited, then ignore
if (!visited[j])
{
// Otherwise calculate its distance and mark it
// as visited
queueEntry a;
a.dist = (qe.dist + 1);
visited[j] = true;
// Check if there a snake or ladder at 'j'

// then tail of snake or top of ladder
// become the adjacent of 'i'
if (move[j] != -1)
a.v = move[j];
else
a.v = j;
q.push(a);
}
}
}
// We reach here when 'qe' has last vertex

// return the distance of vertex in 'qe'
return qe.dist;
return qe.dist;
}

int main()
{
// Let us construct the board given in above diagram
int N = 30;
int moves[N];
for (int i = 0; i<N; i++)
moves[i] = -1;
// Ladders
moves[2] = 21;
moves[4] = 7;
moves[10] = 25;
moves[19] = 28;
// Snakes
moves[26] = 0;
moves[20] = 8;
moves[16] = 3;
moves[18] = 6;
cout << "Min Dice throws required is " << getMinDiceThrows(moves, N);
return 0;
}

Output:

Min Dice throws required is 3

Time complexity of the above solution is O(N) as every cell is added and removed only once from queue. And
a typical enqueue or dequeue operation takes O(1) time.
This article is contributed by Siddharth. Please write comments if you find anything incorrect, or you want
Given two strings, find if first string is a subsequence of second
Given two strings str1 and str2, find if str1 is a subsequence of str2. A subsequence is a sequence that can be
derived from another sequence by deleting some elements without changing the order of the remaining
elements (source: wiki). Expected time complexity is linear.
Examples:
Input: str1 = "AXY", str2 = "ADXCPY"

Output: True (str1 is a subsequence of str2)
Input: str1 = "AXY", str2 = "YADXCP"

Output: False (str1 is not a subsequence of str2)
Input: str1 = "gksrek", str2 = "geeksforgeeks"

Output: True (str1 is a subsequence of str2)

The idea is simple, we traverse both strings from one side to other side (say from rightmost character to
leftmost). If we find a matching character, we move ahead in both strings. Otherwise we move ahead only in
str2.
Following is Recursive Implementation in C++ of the above idea.

// Recursive C++ program to check if a string is subsequence of another string

#include<iostream>
#include<cstring>
// Returns true if str1[] is a subsequence of str2[]. m is

// length of str1 and n is length of str2
bool isSubSequence(char str1[], char str2[], int m, int n)
{
// Base Cases
if (m == 0) return true;
if (n == 0) return false;
// If last characters of two strings are matching

if (str1[m-1] == str2[n-1])
return isSubSequence(str1, str2, m-1, n-1);
// If last characters are not matching

return isSubSequence(str1, str2, m, n-1);
}

int main()
{
char str1[] = "gksrek";
int m = strlen(str1);
int n = strlen(str2);
isSubSequence(str1, str2, m, n)? cout << "Yes ":
cout << "No";
return 0;
}

Output:

Yes

Following is Iterative Implementation in C++ for the same.

// Iterative C++ program to check if a string is subsequence of another string

#include<iostream>
#include<cstring>
// Returns true if str1[] is a subsequence of str2[]. m is

// length of str1 and n is length of str2
bool isSubSequence(char str1[], char str2[], int m, int n)
{
int j = 0; // For index of str1 (or subsequence
// Traverse str2 and str1, and compare current character

// of str2 with first unmatched char of str1, if matched
// then move ahead in str1
for (int i=0; i<n&&j<m; i++)
if (str1[j] == str2[i])
j++;
// If all characters of str1 were found in str2

return (j==m);
}

int main()
{
char str1[] = "gksrek";
int m = strlen(str1);
int n = strlen(str2);
isSubSequence(str1, str2, m, n)? cout << "Yes ":
cout << "No";
return 0;
}

Output:

Yes

Time Complexity of both implementations above is O(n) where n is the length of str2.
This article is contributed by Sachin Gupta. Please write comments if you find anything incorrect, or you
Print all increasing sequences of length k from first n natural numbers
Given two positive integers n and k, print all increasing sequences of length k such that the elements in every
sequence are from first n natural numbers.
Examples:
Input: k = 2, n = 3
Output: 1 2
1 3
2 3
Input: k = 5, n = 5
Output: 1 2 3 4 5
Input: k = 3, n = 5
Output: 1 2 3
1 2 4
1 2 5
1 3 4
1 3 5
1 4 5
2 3 4
2 3 5
2 4 5
3 4 5

It’s a good recursion question. The idea is to create an array of length k. The array stores current sequence.
For every position in array, we check the previous element and one by one put all elements greater than the
previous element. If there is no previous element (first position), we put all numbers from 1 to n.
// C++ program to print all increasing sequences of

// length 'k' such that the elements in every sequence
// are from first 'n' natural numbers.
#include<iostream>
// A utility function to print contents of arr[0..k-1]

void printArr(int arr[], int k)
{
cout << arr[i] << " ";
cout << endl;
}
// A recursive function to print all increasing sequences

// of first n natural numbers. Every sequence should be
// length k. The array arr[] is used to store current
// sequence.
void printSeqUtil(int n, int k, int &len, int arr[])
{
// If length of current increasing sequence becomes k,
// print it
// print it
if (len == k)
{
printArr(arr, k);
return;
}
// Decide the starting number to put at current position:

// If length is 0, then there are no previous elements
// in arr[]. So start putting new numbers with 1.
// If length is not 0, then start from value of
// previous element plus 1.
int i = (len == 0)? 1 : arr[len-1] + 1;
// Increase length
len++;
// Put all numbers (which are greater than the previous

// element) at new position.
while (i<=n)
{
arr[len-1] = i;
printSeqUtil(n, k, len, arr);
i++;
}
// This is important. The variable 'len' is shared among

// all function calls in recursion tree. Its value must be
// brought back before next iteration of while loop
len--;
}
// This function prints all increasing sequences of

// first n natural numbers. The length of every sequence
// must be k. This function mainly uses printSeqUtil()
void printSeq(int n, int k)
{
int arr[k]; // An array to store individual sequences
int len = 0; // Initial length of current sequence
printSeqUtil(n, k, len, arr);
}

int main()
{
int k = 3, n = 7;
printSeq(n, k);
return 0;
}

Output:

1 2 3
1 2 4
1 2 5
1 2 6
1 2 7
1 3 4
1 3 5
1 3 6
1 3 7
1 4 5
1 4 6
1 4 7
1 5 6
1 5 7
1 6 7
2 3 4
2 3 5
2 3 6
2 3 7
2 4 5
2 4 6
2 4 7
2 5 6
2 5 7
2 6 7
3 4 5
3 4 6
3 4 7
3 5 6
3 5 7
3 6 7
4 5 6
4 5 7
4 6 7
5 6 7

This article is contributed by Arjun. Please write comments if you find anything incorrect, or you want to
Length of the largest subarray with contiguous elements | Set 1
Given an array of distinct integers, find length of the longest subarray which contains numbers that can be
arranged in a continuous sequence.
Examples:
Input: arr[] = {10, 12, 11};

Output: Length of the longest contiguous subarray is 3
Input: arr[] = {14, 12, 11, 20};

Input: arr[] = {1, 56, 58, 57, 90, 92, 94, 93, 91, 45};

The important thing to note in question is, it is given that all elements are distinct. If all elements are
distinct, then a subarray has contiguous elements if and only if the difference between maximum and
minimum elements in subarray is equal to the difference between last and first indexes of subarray. So the
idea is to keep track of minimum and maximum element in every subarray.
The following is C++ implementation of above idea.

#include<iostream>
// Utility functions to find minimum and maximum of

// two elements
int min(int x, int y) { return (x < y)? x : y; }
// Returns length of the longest contiguous subarray

int findLength(int arr[], int n)
{
int max_len = 1; // Initialize result
{
// Initialize min and max for all subarrays starting with i
int mn = arr[i], mx = arr[i];
// Consider all subarrays starting with i and ending with j

for (int j=i+1; j<n; j++)
{
// Update min and max in this subarray if needed
mn = min(mn, arr[j]);
mx = max(mx, arr[j]);
// If current subarray has all contiguous elements

if ((mx - mn) == j-i)
max_len = max(max_len, mx-mn+1);
}
}
return max_len; // Return result
}

int main()
{
int arr[] = {1, 56, 58, 57, 90, 92, 94, 93, 91, 45};
cout << "Length of the longest contiguous subarray is "
<< findLength(arr, n);
return 0;
}

Output:

Length of the longest contiguous subarray is 5

Time Complexity of the above solution is O(n2).
We will soon be covering solution for the problem where duplicate elements are allowed in subarray.
This article is contributed by Arjun. Please write comments if you find anything incorrect, or you want to
Print nodes between two given level numbers of a binary tree
Given a binary tree and two level numbers ‘low’ and ‘high’, print nodes from level low to level high.
For example consider the binary tree given in below diagram.
Input: Root of below tree, low = 2, high = 4
Output:
8 22
4 12
10 14

A Simple Method is to first write a recursive function that prints nodes of a given level number. Then call
recursive function in a loop from low to high. Time complexity of this method is O(n2)
We can print nodes in O(n) time using queue based iterative level order traversal. The idea is to do simple
queue based level order traversal. While doing inorder traversal, add a marker node at the end. Whenever we
see a marker node, we increase level number. If level number is between low and high, then print nodes.
// A C++ program to print Nodes level by level berween given two levels.
#include <iostream>
#include <queue>
/* A binary tree Node has key, pointer to left and right children */
struct Node
{
int key;
};
/* Given a binary tree, print nodes from level number 'low' to level
number 'high'*/
void printLevels(Node* root, int low, int high)
{
queue <Node *> Q;
Node *marker = new Node; // Marker node to indicate end of level
int level = 1; // Initialize level number

// Enqueue the only first level node and marker node for end of level
Q.push(root);
Q.push(marker);
// Simple level order traversal loop

while (Q.empty() == false)
{
// Remove the front item from queue
Node *n = Q.front();
Q.pop();
// Check if end of level is reached

if (n == marker)
{
// print a new line and increment level number
cout << endl;
level++;
// Check if marker node was last node in queue or

// level number is beyond the given upper limit
if (Q.empty() == true || level > high) break;
// Enqueue the marker for end of next level

Q.push(marker);
// If this is marker, then we don't need print it

// and enqueue its children
continue;
}
// If level is equal to or greater than given lower level,

// print it
if (level >= low)
cout << n->key << " ";
// Enqueue children of non-marker node

if (n->left != NULL) Q.push(n->left);
if (n->right != NULL) Q.push(n->right);
}
}

given key and NULL left and right pointers. */
{
temp->key = key;
return (temp);
}

int main()
{
// Let us construct the BST shown in the above figure
cout << "Level Order traversal between given two levels is";
cout << "Level Order traversal between given two levels is";
printLevels(root, 2, 3);
return 0;
}

Level Order traversal between given two levels is

8 22
4 12

Time complexity of above method is O(n) as it does a simple level order traversal.
This article is contributed by Frank. Please write comments if you find anything incorrect, or you want to
Print all elements in sorted order from row and column wise sorted matrix
Given an n x n matrix, where every row and column is sorted in non-decreasing order. Print all elements of
matrix in sorted order.
Example:
Input: mat[][] = { {10, 20, 30, 40},

{15, 25, 35, 45},
{27, 29, 37, 48},
{32, 33, 39, 50},
};
Output:
Elements of matrix in sorted order
10 15 20 25 27 29 30 32 33 35 37 39 40 45 48 50

We can use Young Tableau to solve the above problem. The idea is to consider given 2D array as Young
Tableau and call extract minimum O(N)
// A C++ program to Print all elements in sorted order from row and
// column wise sorted matrix
#include<iostream>
#include<climits>
#define INF INT_MAX

#define N 4
// A utility function to youngify a Young Tableau. This is different

// from standard youngify. It assumes that the value at mat[0][0] is
// infinite.
void youngify(int mat[][N], int i, int j)
{
// Find the values at down and right sides of mat[i][j]
int downVal = (i+1 < N)? mat[i+1][j]: INF;
int rightVal = (j+1 < N)? mat[i][j+1]: INF;
// If mat[i][j] is the down right corner element, return

if (downVal==INF && rightVal==INF)
return;
// Move the smaller of two values (downVal and rightVal) to

// mat[i][j] and recur for smaller value
if (downVal < rightVal)
{
mat[i][j] = downVal;
mat[i+1][j] = INF;
youngify(mat, i+1, j);
}
else
{
mat[i][j] = rightVal;
mat[i][j+1] = INF;
youngify(mat, i, j+1);
youngify(mat, i, j+1);
}
}
// A utility function to extract minimum element from Young tableau

int extractMin(int mat[][N])
{
int ret = mat[0][0];
mat[0][0] = INF;
youngify(mat, 0, 0);
return ret;
}
// This function uses extractMin() to print elements in sorted order

void printSorted(int mat[][N])
{
cout << "Elements of matrix in sorted order \n";
for (int i=0; i<N*N; i++)
cout << extractMin(mat) << " ";
}

int main()
{
int mat[N][N] = { {10, 20, 30, 40},
{15, 25, 35, 45},
{27, 29, 37, 48},
{32, 33, 39, 50},
};
printSorted(mat);
return 0;
}

Output:
Elements of matrix in sorted order

10 15 20 25 27 29 30 32 33 35 37 39 40 45 48 50

2
Time complexity of extract minimum is O(N) and it is called O(N) times. Therefore the overall time
complexity is O(N3).
A better solution is to use the approach used for merging k sorted arrays. The idea is to use a Min Heap of
size N which stores elements of first column. The do extract minimum. In extract minimum, replace the
minimum element with the next element of the row from which the element is extracted. Time complexity of
this solution is O(N2LogN).

// C++ program to merge k sorted arrays of size n each.
#include<iostream>
#include<climits>
#define N 4
// A min heap node

struct MinHeapNode
struct MinHeapNode
{
int element; // The element to be stored
int i; // index of the row from which the element is taken
int j; // index of the next element to be picked from row
};
// Prototype of a utility function to swap two min heap nodes

void swap(MinHeapNode *x, MinHeapNode *y);

class MinHeap
{
MinHeapNode *harr; // pointer to array of elements in heap
public:
// Constructor: creates a min heap of given size
MinHeap(MinHeapNode a[], int size);



// to get the root

MinHeapNode getMin() { return harr[0]; }

void replaceMin(MinHeapNode x) { harr[0] = x; MinHeapify(0); }
};
// This function prints elements of a given matrix in non-decreasing

// order. It assumes that ma[][] is sorted row wise sorted.
void printSorted(int mat[][N])
{
// Create a min heap with k heap nodes. Every heap node
// has first element of an array
MinHeapNode *harr = new MinHeapNode[N];
for (int i = 0; i < N; i++)
{
harr[i].element = mat[i][0]; // Store the first element
harr[i].i = i; // index of row
harr[i].j = 1; // Index of next element to be stored from row
}
MinHeap hp(harr, N); // Create the min heap
// Now one by one get the minimum element from min

// heap and replace it with next element of its array
for (int count = 0; count < N*N; count++)
{
// Get the minimum element and store it in output
MinHeapNode root = hp.getMin();
cout << root.element << " ";
// Find the next elelement that will replace current

// root of heap. The next element belongs to same
// array as the current root.
if (root.j < N)
{
root.element = mat[root.i][root.j];
root.element = mat[root.i][root.j];
root.j += 1;
}
// If root was the last element of its array
else root.element = INT_MAX; //INT_MAX is for infinite
// Replace root with next element of array

hp.replaceMin(root);
}
}
// FOLLOWING ARE IMPLEMENTATIONS OF STANDARD MIN HEAP METHODS

// FROM CORMEN BOOK
MinHeap::MinHeap(MinHeapNode a[], int size)
{
heap_size = size;
while (i >= 0)
{
MinHeapify(i);
i--;
}
}

{
int l = left(i);
int r = right(i);
int smallest = i;
if (l < heap_size && harr[l].element < harr[i].element)
smallest = l;
if (r < heap_size && harr[r].element < harr[smallest].element)
smallest = r;
if (smallest != i)
{
}
}

void swap(MinHeapNode *x, MinHeapNode *y)
{
MinHeapNode temp = *x; *x = *y; *y = temp;
}

int main()
{
int mat[N][N] = { {10, 20, 30, 40},
{15, 25, 35, 45},
{27, 29, 37, 48},
{32, 33, 39, 50},
};
printSorted(mat);
return 0;
}

Output:

10 15 20 25 27 29 30 32 33 35 37 39 40 45 48 50

Exercise:
Above solutions work for a square matrix. Extend the above solutions to work for an M*N rectangular
matrix.
This article is contributed by Varun. Please write comments if you find anything incorrect, or you want to
Serialize and Deserialize a Binary Tree
Serialization is to store tree in a file so that it can be later restored. The structure of tree must be maintained.
Deserialization is reading tree back from file.
Following are some simpler versions of the problem:
If given Tree is Binary Search Tree?

If the given Binary Tree is Binary Search Tree, we can store it by either storing preorder or postorder
traversal. In case of Binary Search Trees, only preorder or postorder traversal is sufficient to store structure
information.
If given Binary Tree is Complete Tree?

A Binary Tree is complete if all levels are completely filled except possibly the last level and all nodes of last
level are as left as possible (Binary Heaps are complete Binary Tree). For a complete Binary Tree, level order
traversal is sufficient to store the tree. We know that the first node is root, next two nodes are nodes of next
level, next four nodes are nodes of 2nd level and so on.
If given Binary Tree is Full Tree?

A full Binary is a Binary Tree where every node has either 0 or 2 children. It is easy to serialize such trees as
every internal node has 2 children. We can simply store preorder traversal and store a bit with every node to
indicate whether the node is an internal node or a leaf node.
How to store a general Binary Tree?

A simple solution is to store both Inorder and Preorder traversals. This solution requires requires space
twice the size of Binary Tree.
We can save space by storing Preorder traversal and a marker for NULL pointers.

Let the marker for NULL pointers be '-1'

Input:
12
/
13
Output: 12 13 -1 -1
Input:
20
/ \
8 22
Output: 20 8 -1 -1 22 -1 -1
Input:
20
/
8
/ \
4 12
/ \
10 14
Output: 20 8 4 -1 -1 12 10 -1 -1 14 -1 -1 -1
Input:
20
/
8
/
10
/
5
Output: 20 8 10 5 -1 -1 -1 -1 -1
Input:
20
\
8
\
10
\
5
Output: 20 -1 8 -1 10 -1 5 -1 -1

Deserialization can be done by simply reading data from file one by one.
// A C++ program to demonstrate serialization and deserialiation of

// Binary Tree
#include <stdio.h>
#define MARKER -1
/* A binary tree Node has key, pointer to left and right children */
struct Node
{
int key;
};

given key and NULL left and right pointers. */
{
temp->key = key;
return (temp);
}
// This function stores a tree in a file pointed by fp

void serialize(Node *root, FILE *fp)
{
// If current node is NULL, store marker
if (root == NULL)
{
fprintf(fp, "%d ", MARKER);
return;
}
// Else, store current node and recur for its children

fprintf(fp, "%d ", root->key);
serialize(root->left, fp);
serialize(root->right, fp);
}
// This function constructs a tree from a file pointed by 'fp'

void deSerialize(Node *&root, FILE *fp)
{
// Read next item from file. If theere are no more items or next
// item is marker, then return
int val;
if ( !fscanf(fp, "%d ", &val) || val == MARKER)
return;
// Else create node with this item and recur for children
root = newNode(val);
deSerialize(root->left, fp);
deSerialize(root->right, fp);
}
// A simple inorder traversal used for testing the constructed tree

void inorder(Node *root)
{
if (root)
{
}
}

int main()
{
// Let us construct a tree shown in the above figure
// Let us open a file and serialize the tree into the file
FILE *fp = fopen("tree.txt", "w");
if (fp == NULL)
{
puts("Could not open file");
return 0;
}
serialize(root, fp);
fclose(fp);
// Let us deserialize the storeed tree into root1

Node *root1 = NULL;
fp = fopen("tree.txt", "r");
deSerialize(root1, fp);
printf("Inorder Traversal of the tree constructed from file:\n");

inorder(root1);
return 0;
}

Output:

Inorder Traversal of the tree constructed from file:
4 8 10 12 14 20 22

How much extra space is required in above solution?

If there are n keys, then the above solution requires n+1 markers which may be better than simple solution
(storing keys twice) in situations where keys are big or keys have big data items associated with them.
Can we optimize it further?

The above solution can be optimized in many ways. If we take a closer look at above serialized trees, we can
observer that all leaf nodes require two markers. One simple optimization is to store a separate bit with every
node to indicate that the node is internal or external. This way we don’t have to store two markers with every
leaf node as leaves can be identified by extra bit. We still need marker for internal nodes with one child. For
example in the following diagram ‘ is used to indicate an internal node set bit, and ‘/’ is used as NULL
marker. The diagram is taken from here.
Please note that there are always more leaf nodes than internal nodes in a Binary Tree (Number of leaf
nodes is number of internal nodes plus 1, so this optimization makes sense.
How to serialize n-ary tree?

In an n-ary tree, there is no designated left or right child. We can store an ‘end of children’ marker with
every node. The following diagram shows serialization where ‘)’ is used as end of children marker. We will
soon be covering implementation for n-ary tree. The diagram is taken from here.
References:
http://www.cs.usfca.edu/~brooks/S04classes/cs245/lectures/lecture11.pdf
This article is contributed by Shivam Gupta, Please write comments if you find anything incorrect, or you
Suffix Tree is very useful in numerous string processing and computational biology problems. Many books
and e-resources talk about it theoretically and in few places, code implementation is discussed. But still, I
felt something is missing and it’s not easy to implement code to construct suffix tree and it’s usage in many
applications. This is an attempt to bridge the gap between theory and complete working code
implementation. Here we will discuss Ukkonen’s Suffix Tree Construction Algorithm. We will discuss it in
step by step detailed way and in multiple parts from theory to implementation. We will start with brute force
way and try to understand different concepts, tricks involved in Ukkonen’s algorithm and in the last part,
code implementation will be discussed.
Note: You may find some portion of the algorithm difficult to understand while 1st or 2nd reading and it’s
perfectly fine. With few more attempts and thought, you should be able to understand such portions.
Book Algorithms on Strings, Trees and Sequences: Computer Science and Computational Biology by Dan
Gusfield explains the concepts very well.
A suffix tree T for a m-character string S is a rooted directed tree with exactly m leaves numbered 1 to m.
(Given that last string character is unique in string)
Root can have zero, one or more children.

Each internal node, other than the root, has at least two children.
Each edge is labelled with a nonempty substring of S.
No two edges coming out of same node can have edge-labels beginning with the same character.
Concatenation of the edge-labels on the path from the root to leaf i gives the suffix of S that starts at position
i, i.e. S[i…m].
Note: Position starts with 1 (it’s not zero indexed, but later, while code implementation, we will used zero
indexed position)
For string S = xabxac with m = 6, suffix tree will look like following:
It has one root node and two internal nodes and 6 leaf nodes.
String Depth of red path is 1 and it represents suffix c starting at position 6

String Depth of blue path is 4 and it represents suffix bxca starting at position 3
String Depth of green path is 2 and it represents suffix ac starting at position 5
String Depth of orange path is 6 and it represents suffix xabxac starting at position 1
Edges with labels a (green) and xa (orange) are non-leaf edge (which ends at an internal node). All other
edges are leaf edge (ends at a leaf)
If one suffix of S matches a prefix of another suffix of S (when last character in not unique in string), then
path for the first suffix would not end at a leaf.
For String S = xabxa, with m = 5, following is the suffix tree:
Here we will have 5 suffixes: xabxa, abxa, bxa, xa and a.

Path for suffixes ‘xa’ and ‘a’ do not end at a leaf. A tree like above (Figure 2) is called implicit suffix tree as
some suffixes (‘xa’ and ‘a’) are not seen explicitly in tree.
To avoid this problem, we add a character which is not present in string already. We normally use $, # etc as
termination characters.
Following is the suffix tree for string S = xabxa$ with m = 6 and now all 6 suffixes end at leaf.
A naive algorithm to build a suffix tree

Given a string S of length m, enter a single edge for suffix S[l ..m]$ (the entire string) into the tree, then
successively enter suffix S[i..m]$ into the growing tree, for i increasing from 2 to m. Let Ni denote the
intermediate tree that encodes all the suffixes from 1 to i.
So N i+1 is constructed from Ni as follows:
Start at the root of Ni

Find the longest path from the root which matches a prefix of S[i+1..m]$
Match ends either at the node (say w) or in the middle of an edge [say (u, v)].
If it is in the middle of an edge (u, v), break the edge (u, v) into two edges by inserting a new node w
just after the last character on the edge that matched a character in S[i+l..m] and just before the first
character on the edge that mismatched. The new edge (u, w) is labelled with the part of the (u, v) label
that matched with S[i+1..m], and the new edge (w, v) is labelled with the remaining part of the (u, v)
label.
Create a new edge (w, i+1) from w to a new leaf labelled i+1 and it labels the new edge with the
unmatched part of suffix S[i+1..m]
This takes O(m2) to build the suffix tree for the string S of length m.
Following are few steps to build suffix tree based for string “xabxa$” based on above algorithm:
Implicit suffix tree

While generating suffix tree using Ukkonen’s algorithm, we will see implicit suffix tree in intermediate steps
few times depending on characters in string S. In implicit suffix trees, there will be no edge with $ (or # or
any other termination character) label and no internal node with only one edge going out of it.
To get implicit suffix tree from a suffix tree S$,
Remove all terminal symbol $ from the edge labels of the tree,
Remove any edge that has no label
Remove any node that has only one edge going out of it and merge the edges.
High Level Description of Ukkonen’s algorithm

Ukkonen’s algorithm constructs an implicit suffix tree Ti for each prefix S[l ..i] of S (of length m).
It first builds T1 using 1st character, then T2 using 2nd character, then T3 using 3rd character, …, Tm using mth
character.
Implicit suffix tree Ti+1 is built on top of implicit suffix tree T.i
The true suffix tree for S is built from Tm by adding $.
At any time, Ukkonen’s algorithm builds the suffix tree for the characters seen so far and so it has on-line
property that may be useful in some situations.
Time taken is O(m).
Ukkonen’s algorithm is divided into m phases (one phase for each character in the string with length m)
In phase i+1, tree Ti+1 is built from tree T.i
Each phase i+1 is further divided into i+1 extensions, one for each of the i+1 suffixes of S[1..i+1]
In extension j of phase i+1, the algorithm first finds the end of the path from the root labelled with substring
S[j..i].
It then extends the substring by adding the character S(i+1) to its end (if it is not there already).
In extension 1 of phase i+1, we put string S[1..i+1] in the tree. Here S[1..i] will already be present in tree due
to previous phase i. We just need to add S[i+1]th character in tree (if not there already).
to previous phase i. We just need to add S[i+1]th character in tree (if not there already)
to previous phase i. We just need to add S[i+1]th character in tree (if not there already)
.
.
In extension i+1 of phase i+1, we put string S[i+1..i+1] in the tree. This is just one character which may not be
in tree (if character is seen first time so far). If so, we just add a new leaf edge with label S[i+1].
High Level Ukkonen’s algorithm

Construct tree T1
For i from 1 to m-1 do
begin {phase i+1}
For j from 1 to i+1
begin {extension j}
Find the end of the path from the root labelled S[j..i] in the current tree.
Extend that path by adding character S[i+l] if it is not there already
end;
end;
Suffix extension is all about adding the next character into the suffix tree built so far.
In extension j of phase i+1, algorithm finds the end of S[j..i] (which is already in the tree due to previous
phase i) and then it extends S[j..i] to be sure the suffix S[j..i+1] is in the tree.
There are 3 extension rules:

Rule 1: If the path from the root labelled S[j..i] ends at leaf edge (i.e. S[i] is last character on leaf edge) then
character S[i+1] is just added to the end of the label on that leaf edge.
Rule 2: If the path from the root labelled S[j..i] ends at non-leaf edge (i.e. there are more characters after
S[i] on path) and next character is not s[i+1], then a new leaf edge with label s{i+1] and number j is created
starting from character S[i+1].
A new internal node will also be created if s[1..i] ends inside (in-between) a non-leaf edge.
Rule 3: If the path from the root labelled S[j..i] ends at non-leaf edge (i.e. there are more characters after
S[i] on path) and next character is s[i+1] (already in tree), do nothing.
One important point to note here is that from a given node (root or internal), there will be one and only one
edge starting from one character. There will not be more than one edges going out of any node, starting with
same character.
Following is a step by step suffix tree construction of string xabxac using Ukkonen’s algorithm:

In next parts (Part 2, Part 3, Part 4 and Part 5), we will discuss suffix links, active points, few tricks and
finally code implementations (Part 6).
References:
http://web.stanford.edu/~mjkay/gusfield.pdf
Serialize and Deserialize an N-ary Tree
Given an N-ary tree where every node has at-most N children. How to serialize and deserialze it?
Serialization is to store tree in a file so that it can be later restored. The structure of tree must be maintained.
Deserialization is reading tree back from file.
This post is mainly an extension of below post.

Serialize and Deserialize a Binary Tree
In an N-ary tree, there are no designated left and right children. An N-ary tree is represented by storing an
array or list of child pointers with every node.
The idea is to store an ‘end of children’ marker with every node. The following diagram shows serialization
where ‘)’ is used as end of children marker. The diagram is taken from here.
// A C++ Program serialize and deserialize an N-ary tree

#include<cstdio>
#define MARKER ')'
#define N 5
// A node of N-ary tree

struct Node {
char key;
Node *child[N]; // An array of pointers for N children
};
// A utility function to create a new N-ary tree node

Node *newNode(char key)
{
temp->key = key;
for (int i = 0; i < N; i++)
temp->child[i] = NULL;
return temp;
}
// This function stores the given N-ary tree in a file pointed by fp

void serialize(Node *root, FILE *fp)
{
// Base case
// Else, store current node and recur for its children

fprintf(fp, "%c ", root->key);
for (int i = 0; i < N && root->child[i]; i++)
serialize(root->child[i], fp);
// Store marker at the end of children
fprintf(fp, "%c ", MARKER);
}
// This function constructs N-ary tree from a file pointed by 'fp'.

// This functionr returns 0 to indicate that the next item is a valid
// tree key. Else returns 0
int deSerialize(Node *&root, FILE *fp)
{
// Read next item from file. If theere are no more items or next
// item is marker, then return 1 to indicate same
char val;
if ( !fscanf(fp, "%c ", &val) || val == MARKER )
return 1;
// Else create node with this item and recur for children
root = newNode(val);
for (int i = 0; i < N; i++)
if (deSerialize(root->child[i], fp))
break;
// Finally return 0 for successful finish

return 0;
}
// A utility function to create a dummy tree shown in above diagram

Node *createDummyTree()
{
Node *root = newNode('A');
root->child[0] = newNode('B');
root->child[1] = newNode('C');
root->child[2] = newNode('D');
root->child[0]->child[0] = newNode('E');
root->child[0]->child[1] = newNode('F');
root->child[2]->child[0] = newNode('G');
root->child[2]->child[1] = newNode('H');
root->child[2]->child[2] = newNode('I');
root->child[2]->child[3] = newNode('J');
root->child[0]->child[1]->child[0] = newNode('K');
return root;
}
// A utlity function to traverse the constructed N-ary tree

void traverse(Node *root)
{
if (root)
{
printf("%c ", root->key);
for (int i = 0; i < N; i++)
traverse(root->child[i]);
}
}

int main()
{
// Let us create an N-ary tree shown in above diagram
Node *root = createDummyTree();
// Let us open a file and serialize the tree into the file
FILE *fp = fopen("tree.txt", "w");
if (fp == NULL)
{
puts("Could not open file");
return 0;
}
serialize(root, fp);
fclose(fp);
// Let us deserialize the storeed tree into root1

Node *root1 = NULL;
fp = fopen("tree.txt", "r");
deSerialize(root1, fp);
printf("Constructed N-Ary Tree from file is \n");

traverse(root1);
return 0;
}

Output:

Constructed N-Ary Tree from file is
A B E F K C D G H I J

The above implementation can be optimized in many ways for example by using a vector in place of array of
pointers. We have kept it this way to keep it simple to read and understand.
This article is contributed by varun. Please write comments if you find anything incorrect, or you want to
In Ukkonen’s Suffix Tree Construction – Part 1, we have seen high level Ukkonen’s Algorithm. This 2nd part
is continuation of Part 1.
Please go through Part 1, before looking at current article.
In Suffix Tree Construction of string S of length m, there are m phases and for a phase j (1 <= j <= m), we add
jth character in tree built so far and this is done through j extensions. All extensions follow one of the three
extension rules (discussed in Part 1).
To do jth extension of phase i+1 (adding character S[i+1]), we first need to find end of the path from the root
labelled S[j..i] in the current tree. One way is start from root and traverse the edges matching S[j..i] string.
This will take O(m 3) time to build the suffix tree. Using few observations and implementation tricks, it can
be done in O(m) which we will see now.
Suffix links
For an internal node v with path-label xA, where x denotes a single character and A denotes a (possibly
empty) substring, if there is another node s(v) with path-label A, then a pointer from v to s(v) is called a
suffix link.
If A is empty string, suffix link from internal node will go to root node.
There will not be any suffix link from root node (As it’s not considered as internal node).
In extension j of some phase i, if a new internal node v with path-label xA is added, then in extension j+1 in
the same phase i:
Either the path labelled A already ends at an internal node (or root node if A is empty)
OR a new internal node at the end of string A will be created
th extension to
In extension j+1 of same phase i, we will create a suffix link from the internal node created in j
the node with path labelled A.
So in a given phase, any newly created internal node (with path-label xA) will have a suffix link from it
(pointing to another node with path-label A) by the end of the next extension.
In any implicit suffix tree Ti after phase i, if internal node v has path-label xA, then there is a node s(v) in Ti
with path-label A and node v will point to node s(v) using suffix link.
At any time, all internal nodes in the changing tree will have suffix links from them to another internal node
(or root) except for the most recently added internal node, which will receive its suffix link by the end of the
next extension.
How suffix links are used to speed up the implementation?

In extension j of phase i+1, we need to find the end of the path from the root labelled S[j..i] in the current
tree. One way is start from root and traverse the edges matching S[j..i] string. Suffix links provide a short cut
to find end of the path.
So we can see that, to find end of path S[j..i], we need not traverse from root. We can start from the end of
path S[j-1..i], walk up one edge to node v (i.e. go to parent node), follow the suffix link to s(v), then walk
down the path y (which is abcd here in Figure 17).
This shows the use of suffix link is an improvement over the process.
Note: In the next part 3, we will introduce activePoint which will help to avoid “walk up”. We can directly go
to node s(v) from node v.
When there is a suffix link from node v to node s(v), then if there is a path labelled with string y from node v
to a leaf, then there must be a path labelled with string y from node s(v) to a leaf. In Figure 17, there is a path
label “abcd” from node v to a leaf, then there is a path will same label “abcd” from node s(v) to a leaf.
This fact can be used to improve the walk from s(v) to leaf along the path y. This is called “skip/count” trick.
Skip/Count Trick
When walking down from node s(v) to leaf, instead of matching path character by character as we travel, we
can directly skip to the next node if number of characters on the edge is less than the number of characters
we need to travel. If number of characters on the edge is more than the number of characters we need to
travel, we directly skip to the last character on that edge.
If implementation is such a way that number of characters on any edge, character at a given position in
string S should be obtained in constant time, then skip/count trick will do the walk down in proportional to
the number of nodes on it rather than the number of characters on it.
2
Using suffix link along with skip/count trick, suffix tree can be built in O(m) as there are m phases and each
phase takes O(m).
Edge-label compression
So far, path labels are represented as characters in string. Such a suffix tree will take O(m2) space to store the
path labels. To avoid this, we can use two pair of indices (start, end) on each edge for path labels, instead of
substring itself. The indices start and end tells the path label start and end position in string S. With this,
suffix tree needs O(m) space.
There are two observations about the way extension rules interact in successive extensions and phases.
These two observations lead to two more implementation tricks (first trick “skip/count” is seen already
while walk down).
Observation 1: Rule 3 is show stopper

In a phase i, there are i extensions (1 to i) to be done.
When rule 3 applies in any extension j of phase i+1 (i.e. path labelled S[j..i] continues with character S[i+1]),
then it will also apply in all further extensions of same phase (i.e. extensions j+1 to i+1 in phase i+1). That’s
because if path labelled S[j..i] continues with character S[i+1], then path labelled S[j+1..i], S[j+2..i], S[j+3..i],
…, S[i..i] will also continue with character S[i+1].
Consider Figure 11, Figure12 and Figure 13 in Part 1 where Rule 3 is applied.
In Figure 11, “xab” is added in tree and in Figure 12 (Phase 4), we add next character “x”. In this, 3
extensions are done (which adds 3 suffixes). Last suffix “x” is already present in tree.
In Figure 13, we add character “a” in tree (Phase 5). First 3 suffixes are added in tree and last two suffixes
“xa” and “a” are already present in tree. This shows that if suffix S[j..i] present in tree, then ALL the
remaining suffixes S[j+1..i], S[j+2..i], S[j+3..i],…, S[i..i] will also be there in tree and no work needed to add
those remaining suffixes.
So no more work needed to be done in any phase as soon as rule 3 applies in any extension in that phase. If a
new internal node v gets created in extension j and rule 3 applies in next extension j+1, then we need to add
suffix link from node v to current node (if we are on internal node) or root node. ActiveNode, which will be
discussed in part 3, will help while setting suffix links.
Trick 2
Stop the processing of any phase as soon as rule 3 applies. All further extensions are already present in tree
implicitly.
Observation 2: Once a leaf, always a leaf

Once a leaf is created and labelled j (for suffix starting at position j in string S), then this leaf will always be a
leaf in successive phases and extensions. Once a leaf is labelled as j, extension rule 1 will always apply to
extension j in all successive phases.
Consider Figure 9 to Figure 14 in Part 1.
In Figure 10 (Phase 2), Rule 1 is applied on leaf labelled 1. After this, in all successive phases, rule 1 is always
applied on this leaf.
In any phase i, there is an initial sequence of consecutive extensions where rule 1 or rule 2 are applied and
then as soon as rule 3 is applied, phase i ends.
Also rule 2 creates a new leaf always (and internal node sometimes).
If J i represents the last extension in phase i when rule 1 or 2 was applied (i.e after ith phase, there will be Ji
leaves labelled 1, 2, 3, …, Ji) , then Ji <= Ji+1
Ji will be equal to Ji+1 when there are no new leaf created in phase i+1 (i.e rule 3 is applied in Ji+1 extension)
In Figure 11 (Phase 3), Rule 1 is applied in 1st two extensions and Rule 2 is applied in 3rd extension, so here
J3 = 3
In Figure 12 (Phase 4), no new leaf created (Rule 1 is applied in 1st 3 extensions and then rule 3 is applied in
4th extension which ends the phase). Here J4 = 3 = J3
In Figure 13 (Phase 5), no new leaf created (Rule 1 is applied in 1st 3 extensions and then rule 3 is applied in
4th extension which ends the phase). Here J5 = 3 = J4
Ji will be less than Ji+1 when few new leaves are created in phase i+1.
In Figure 14 (Phase 6), new leaf created (Rule 1 is applied in 1st 3 extensions and then rule 2 is applied in last
3 extension which ends the phase). Here J6 = 6 > J5
So we can see that in phase i+1, only rule 1 will apply in extensions 1 to Ji (which really doesn’t need much
work, can be done in constant time and that’s the trick 3), extension Ji+1 onwards, rule 2 may apply to zero
or more extensions and then finally rule 3, which ends the phase.
Now edge labels are represented using two indices (start, end), for any leaf edge, end will always be equal to
phase number i.e. for phase i, end = i for leaf edges, for phase i+1, end = i+1 for leaf edges.
Trick 3
In any phase i, leaf edges may look like (p, i), (q, i), (r, i), …. where p, q, r are starting position of different
edges and i is end position of all. Then in phase i+1, these leaf edges will look like (p, i+1), (q, i+1), (r, i+1),….
This way, in each phase, end position has to be incremented in all leaf edges. For this, we need to traverse
through all leaf edges and increment end position for them. To do same thing in constant time, maintain a
global index e and e will be equal to phase number. So now leaf edges will look like (p, e), (q, e), (r, e).. In
any phase, just increment e and extension on all leaf edges will be done. Figure 19 shows this.
So using suffix links and tricks 1, 2 and 3, a suffix tree can be built in linear time.
Tree Tm could be implicit tree if a suffix is prefix of another. So we can add a $ terminal symbol first and
then run algorithm to get a true suffix tree (A true suffix tree contains all suffixes explicitly). To label each
leaf with corresponding suffix starting position (all leaves are labelled as global index e), a linear time
traversal can be done on tree.
At this point, we have gone through most of the things we needed to know to create suffix tree using
Ukkonen’s algorithm. In next Part 3, we will take string S = “abcabxabcd” as an example and go through all
the things step by step and create the tree. While building the tree, we will discuss few more implementation
issues which will be addressed by ActivePoints.
We will continue to discuss the algorithm in Part 4 and Part 5. Code implementation will be discussed in
Part 6.
References:
Convert a Binary Tree to Threaded binary tree
We have discussed Threaded Binary Tree. The idea of threaded binary trees is to make inorder traversal
faster and do it without stack and without recursion. In a simple threaded binary tree, the NULL right
pointers are used to store inorder successor. Where-ever a right pointer is NULL, it is used to store inorder
successor.
Following diagram shows an example Single Threaded Binary Tree. The dotted lines represent threads.
Following is structure of single threaded binary tree.
struct Node
{
int key;
Node *left, *right;
// Used to indicate whether the right pointer is a normal right

// pointer or a pointer to inorder successor.
bool isThreaded;
};

How to convert a Given Binary Tree to Threaded Binary Tree?

We basically need to set NULL right pointers to inorder successor. We first do an inorder traversal of the
tree and store it in a queue (we can use a simple array also) so that the inorder successor becomes the next
node. We again do an inorder traversal and whenever we find a node whose right is NULL, we take the front
item from queuue and make it the right of current node. We also set isThreaded to true to indicate that the
right pointer is a threaded link.
/* C++ program to convert a Binary Tree to Threaded Tree */

#include <iostream>
#include <queue>
/* Structure of a node in threaded binary tree */

struct Node
{
int key;
Node *left, *right;
// Used to indicate whether the right pointer is a normal

// right pointer or a pointer to inorder successor.
bool isThreaded;
};
};
// Helper function to put the Nodes in inorder into queue

void populateQueue(Node *root, std::queue <Node *> *q)
{
if (root->left)
populateQueue(root->left, q);
q->push(root);
if (root->right)
populateQueue(root->right, q);
}
// Function to traverse queue, and make tree threaded

void createThreadedUtil(Node *root, std::queue <Node *> *q)
{
if (root->left)
createThreadedUtil(root->left, q);
q->pop();
if (root->right)
createThreadedUtil(root->right, q);
// If right pointer is NULL, link it to the

// inorder successor and set 'isThreaded' bit.
else
{
root->right = q->front();
root->isThreaded = true;
}
}
// This function uses populateQueue() and

// createThreadedUtil() to convert a given binary tree
// to threaded tree.
void createThreaded(Node *root)
{
// Create a queue to store inorder traversal
std::queue <Node *> q;
// Store inorder traversal in queue

populateQueue(root, &q);
// Link NULL right pointers to inorder successor

createThreadedUtil(root, &q);
}
// A utility function to find leftmost node in a binary

// tree rooted with 'root'. This function is used in inOrder()
Node *leftMost(Node *root)
{
while (root != NULL && root->left != NULL)
root = root->left;
return root;
}
// Function to do inorder traversal of a threadded binary tree

void inOrder(Node *root)
{
// Find the leftmost node in Binary Tree

Node *cur = leftMost(root);
Node *cur = leftMost(root);
while (cur != NULL)

{
cout << cur->key << " ";
// If this Node is a thread Node, then go to

// inorder successor
if (cur->isThreaded)
cur = cur->right;
else // Else go to the leftmost child in right subtree

cur = leftMost(cur->right);
}
}

Node *newNode(int key)
{
temp->key = key;
return temp;
}

int main()
{
/* 1
/ \
2 3
/ \ / \
4 5 6 7 */
createThreaded(root);
cout << "Inorder traversal of creeated threaded tree is\n";

inOrder(root);
return 0;
}

Output:

Inorder traversal of creeated threaded tree is
4 2 5 1 6 3 7

This article is contributed by Minhaz. Please write comments if you find anything incorrect, or you want to
This article is continuation of following two articles:
Please go through Part 1 and Part 2, before looking at current article, where we have seen few basics on suffix
tree, high level ukkonen’s algorithm, suffix link and three implementation tricks.
Here we will take string S = “abcabxabcd” as an example and go through all the things step by step and
create the tree.
We will add $ (discussed in Part 1 why we do this) so string S would be “abcabxabcd$”.
While building suffix tree for string S of length m:
There will be m phases 1 to m (one phase for each character)

In our current example, m is 11, so there will be 11 phases.
First phase will add first character ‘a’ in the tree, second phase will add second character ‘b’ in tree,
third phase will add third character ‘c’ in tree, ……, mth phase will add mth character in tree (This
makes Ukkonen’s algorithm an online algorithm)
Each phase i will go through at-most i extensions (from 1 to i). If current character being added in tree
is not seen so far, all i extensions will be completed (Extension Rule 3 will not apply in this phase). If
current character being added in tree is seen before, then phase i will complete early (as soon as
Extension Rule 3 applies) without going through all i extensions
There are three extension rules (1, 2 and 3) and each extension j (from 1 to i) of any phase i will adhere
to one of these three rules.
Rule 1 adds a new character on existing leaf edge
Rule 2 creates a new leaf edge (And may also create new internal node, if the path label ends in
between an edge)
Rule 3 ends the current phase (when current character is found in current edge being traversed)
Phase 1 will read first character from the string, will go through 1 extension.
(In figures, we are showing characters on edge labels just for explanation, while writing
code, we will only use start and end indices – The Edge-label compression discussed in
Part 2)
Extension 1 will add suffix “a” in tree. We start from root and traverse path with label ‘a’. There is no
path from root, going out with label ‘a’, so create a leaf edge (Rule 2).

Phase 1 completes with the completion of extension 1 (As a phase i has at most i extensions)
For any string, Phase 1 will have only one extension and it will always follow Rule 2.
Phase 2 will read second character, will go through at least 1 and at most 2 extensions.
In our example, phase 2 will read second character ‘b’. Suffixes to be added are “ab” and “b”.
Extension 1 adds suffix “ab” in tree.
Path for label ‘a’ ends at leaf edge, so add ‘b’ at the end of this edge.
Extension 1 just increments the end index by 1 (from 1 to 2) on first edge (Rule 1).

Extension 2 adds suffix “b” in tree. There is no path from root, going out with label ‘b’, so creates a
leaf edge (Rule 2).
Phase 2 completes with the completion of extension 2.

Phase 2 went through two extensions here. Rule 1 applied in 1st Extension and Rule 2 applied in 2nd
Extension.
Phase 3 will read third character, will go through at least 1 and at most 3 extensions.
In our example, phase 3 will read third character ‘c’. Suffixes to be added are “abc”, “bc” and “c”.
Extension 1 adds suffix “abc” in tree.
Path for label ‘ab’ ends at leaf edge, so add ‘c’ at the end of this edge.
Extension 1 just increments the end index by 1 (from 2 to 3) on this edge (Rule 1).

Extension 2 adds suffix “bc” in tree.

Path for label ‘b’ ends at leaf edge, so add ‘c’ at the end of this edge.

Extension 3 adds suffix “c” in tree. There is no path from root, going out with label ‘c’, so creates a leaf
edge (Rule 2).
Phase 3 completes with the completion of extension 3.

Phase 3 went through three extensions here. Rule 1 applied in first two Extensions and Rule 2 applied
in 3rd Extension.
Phase 4 will read fourth character, will go to at least 1 and at most 4 extensions.
In our example, phase 4 will read fourth character ‘a’. Suffixes to be added are “abca”, “bca”, “ca” and
“a”.
Extension 1 adds suffix “abca” in tree.
Path for label ‘abc’ ends at leaf edge, so add ‘a’ at the end of this edge.

Extension 2 adds suffix “bca” in tree.

Path for label ‘bc’ ends at leaf edge, so add ‘a’ at the end of this edge.

Extension 3 adds suffix “ca” in tree.

Path for label ‘c’ ends at leaf edge, so add ‘a’ at the end of this edge.
Extension 4 adds suffix “a” in tree.

Path for label ‘a’ exists in the tree. No more work needed and Phase 4 ends here (Rule 3 and Trick 2).
This is an example of implicit suffix tree. Here suffix “a” is not seen explicitly (because it doesn’t end at
a leaf edge) but it is in the tree implicitly. So there is no change in tree structure after extension 4. It
will remain as above in Figure 28.
Phase 4 completes as soon as Rule 3 is applied while Extension 4.
Phase 4 went through four extensions here. Rule 1 applied in first three Extensions and Rule 3 applied
in 4th Extension.
Now we will see few observations and how to implement those.
1. At the end of any phase i, there are at most i leaf edges (if ith character is not seen so far, there will be i
leaf edges, else there will be less than i leaf edges).
e.g. After phases 1, 2 and 3 in our example, there are 1, 2 and 3 leaf edges respectively, but after phase
4, there are 3 leaf edges only (not 4).
2. After completing phase i, “end” indices of all leaf edges are i. How do we implement this in code? Do
we need to iterate through all those extensions, find leaf edges by traversing from root to leaf and
increment the “end” index? Answer is “NO”.
For this, we will maintain a global variable (say “END”) and we will just increment this global variable
“END” and all leaf edge end indices will point to this global variable. So this way, if we have j leaf
edges after phase i, then in phase i+1, first j extensions (1 to j) will be done by just incrementing
variable “END” by 1 (END will be i+1 at the point).
Here we just implemented the trick 3 – Once a leaf, always a leaf . This trick processes all the j leaf
edges (i.e. extension 1 to j) using rule 1 in a constant time in any phase. Rule 1 will not apply to
subsequent extensions in the same phase. This can be verified in the four phases we discussed above.
If at all Rule 1 applies in any phase, it only applies in initial few phases continuously (say 1 to j). Rule 1
never applies later in a given phase once Rule 2 or Rule 3 is applied in that phase.
3. In the example explained so far, in each extension (where trick 3 is not applied) of any phase to add a
suffix in tree, we are traversing from root by matching path labels against the suffix being added. If
there are j leaf edges after phase i, then in phase i+1, first j extensions will follow Rule 1 and will be
done in constant time using trick 3. There are i+1-j extensions yet to be performed. For these
extensions, which node (root or some other internal node) to start from and which path to go? Answer
to this depends on how previous phase i is completed.
If previous phase i went through all the i extensions (when ith character is unique so far), then in next
phase i+1, trick 3 will take care of first i suffixes (the i leaf edges) and then extension i+1 will start
from root node and it will insert just one character [(i+1)th] suffix in tree by creating a leaf edge using
Rule 2.
If previous phase i completes early (and this will happen if and only if rule 3 applies – when ith
character is already seen before), say at jth extension (i.e. rule 3 is applied at jth extension), then there
are j-1 leaf edges so far.
We will state few more facts (which may be a repeat, but we want to make sure it’s clear to you at this
point) here based on discussion so far:
Phase 1 starts with Rule 2, all other phases start with Rule 1
Any phase ends with either Rule 2 or Rule 3
Any phase i may go through a series of j extensions (1 <= j <= i). In these j extensions, first p (0
<= p < i) extensions will follow Rule 1, next q (0 <= q <= i-p) extensions will follow Rule 2 and
next r (0<= r <= 1) extensions will follow Rule 3. The order in which Rule 1, Rule 2 and Rule 3
apply, is never intermixed in a phase. They apply in order of their number (if at all applied),
i.e. in a phase, Rule 1 applies 1st, then Rule 2 and then Rule 3
In a phase i, p + q + r <= i
At the end of any phase i, there will be p+q leaf edges and next phase i+1 will go through Rule
1 for first p+q extensions
In the next phase i+1, trick 3 (Rule 1) will take care of first j-1 suffixes (the j-1 leaf edges), then
extension j will start where we will add jth suffix in tree. For this, we need to find the best possible
matching edge and then add new character at the end of that edge. How to find the end of best
matching edge? Do we need to traverse from root node and match tree edges against the jth suffix
being added character by character? This will take time and overall algorithm will not be linear.
activePoint comes to the rescue here.
In previous phase i, while jth extension, path traversal ended at a point (which could be an internal
node or some point in the middle of an edge) where ith character being added was found in tree
already and Rule 3 applied, jth extension of phase i+1 will start exactly from the same point and we
start matching path against (i+1)th character. activePoint helps to avoid unnecessary path traversal
from root in any extension based on the knowledge gained in traversals done in previous extension.
There is no traversal needed in 1st p extensions where Rule 1 is applied. Traversal is done where Rule
2 or Rule 3 gets applied and that’s where activePoint tells the starting point for traversal where we
match the path against the current character being added in tree. Implementation is done in such a
way that, in any extension where we need a traversal, activePoint is set to right location already (with
one exception case APCFALZ discussed below) and at the end of current extension, we reset
activePoint as apprppriate so that next extension (of same phase or next phase) where a traversal is
required, activePoint points to the right place already.
activePoint: This could be root node, any internal node or any point in the middle of an edge. This is
the point where traversal starts in any extension. For the 1st extension of phase 1, activePoint is set to
root. Other extension will get activePoint set correctly by previous extension (with one exception case
APCFALZ discussed below) and it is the responsibility of current extension to reset activePoint
appropriately at the end, to be used in next extension where Rule 2 or Rule 3 is applied (of same or
next phase).
To accomplish this, we need a way to store activePoint. We will store this using three variables:
activeNode, activeEdge, activeLength.
activeNode: This could be root node or an internal node.
activeEdge: When we are on root node or internal node and we need to walk down, we need to know
which edge to choose. activeEdge will store that information. In case, activeNode itself is the point
from where traversal starts, then activeEdge will be set to next character being processed in next
phase.
activeLength: This tells how many characters we need to walk down (on the path represented by
activeEdge) from activeNode to reach the activePoint where traversal starts. In case, activeNode itself
is the point from where traversal starts, then activeLength will be ZERO.
(click on below image to see it clearly)
After phase i, if there are j leaf edges then in phase i+1, first j extensions will be done by trick 3.
activePoint will be needed for the extensions from j+1 to i+1 and activePoint may or may not change
between two extensions depending on the point where previous extension ends.
activePoint change for extension rule 3 (APCFER3) : When rule 3 applies in any phase i, then
before we move on to next phase i+1, we increment activeLength by 1. There is no change in
activeNode and activeEdge. Why? Because in case of rule 3, the current character from string S is
matched on the same path represented by current activePoint, so for next activePoint, activeNode and
activeEdge remain the same, only activeLenth is increased by 1 (because of matched character in
current phase). This new activePoint (same node, same edge and incremented length) will be used in
phase i+1.
activePoint change for walk down (APCFWD) : activePoint may change at the end of an
extension based on extension rule applied. activePoint may also change during the extension when we
do walk down. Let’s consider an activePoint is (A, s, 11) in the above activePoint example figure. If this
is the activePoint at the start of some extension, then while walk down from activeNode A, other
internal nodes will be seen. Anytime if we encounter an internal node while walk down, that node will
become activeNode (it will change activeEdge and activeLenght as appropriate so that new activePoint
represents the same point as earlier). In this walk down, below is the sequence of changes in
activePoint:
(A, s, 11) — >>> (B, w, 7) —- >>> (C, a, 3)
All above three activePoints refer to same point ‘c’
Let’s take another example.
If activePoint is (D, a, 11) at the start of an extension, then while walk down, below is the sequence of
changes in activePoint:
(D, a, 10) — >>> (E, d, 7) — >>> (F, f, 5) — >> (G, j, 1)
All above activePoints refer to same point ‘k’.
If activePoints are (A, s, 3), (A, t, 5), (B, w, 1), (D, a, 2) etc when no internal node comes in the way
while walk down, then there will be no change in activePoint for APCFWD.
The idea is that, at any time, the closest internal node from the point, where we want to reach, should
be the activePoint. Why? This will minimize the length of traversal in the next extension.
activePoint change for Active Length ZERO (APCFALZ) : Let’s consider an activePoint (A, s,
0) in the above activePoint example figure. And let’s say current character being processed from string
S is ‘x’ (or any other character). At the start of extension, when activeLength is ZERO, activeEdge is
set to the current character being processed, i.e. ‘x’, because there is no walk down needed here (as
activeLength is ZERO) and so next character we look for is current character being processed.
4. While code implementation, we will loop through all the characters of string S one by one. Each loop
for ith character will do processing for phase i. Loop will run one or more time depending on how
many extensions are left to be performed (Please note that in a phase i+1, we don’t really have to
perform all i+1 extensions explicitly, as trick 3 will take care of j extensions for all j leaf edges coming
from previous phase i). We will use a variable remainingSuffixCount, to track how many
extensions are yet to be performed explicitly in any phase (after trick 3 is performed). Also, at the end
of any phase, if remainingSuffixCount is ZERO, this tells that all suffixes supposed to be added in tree,
are added explicitly and present in tree. If remainingSuffixCount is non-zero at the end of any phase,
that tells that suffixes of that many count are not added in tree explicitly (because of rule 3, we stopped
early), but they are in tree implicitly though (Such trees are called implicit suffix tree). These implicit
suffixes will be added explicitly in subsequent phases when a unique character comes in the way.
We will continue our discussion in Part 4 and Part 5. Code implementation will be discussed in Part 6.
References:
Ukkonen’s suffix tree algorithm in plain English
K Dimensional Tree
A K-D Tree(also called as K-Dimensional Tree) is a binary search tree where data in each node is a K-
Dimensional point in space. In short, it is a space partitioning(details below) data structure for organizing
points in a K-Dimensional space.
A non-leaf node in K-D tree divides the space into two parts, called as half-spaces.
Points to the left of this space are represented by the left subtree of that node and points to the right of the
space are represented by the right subtree. We will soon be explaining the concept on how the space is
divided and tree is formed.
For the sake of simplicity, let us understand a 2-D Tree with an example.
The root would have an x-aligned plane, the root’s children would both have y-aligned planes, the root’s
grandchildren would all have x-aligned planes, and the root’s great-grandchildren would all have y-aligned
planes and so on.
Generalization:
Let us number the planes as 0, 1, 2, …(K – 1). From the above example, it is quite clear that a point (node) at
depth D will have A aligned plane where A is calculated as:
A = D mod K
How to determine if a point will lie in the left subtree or in right subtree?
If the root node is aligned in planeA, then the left subtree will contain all points whose coordinates in that
plane are smaller than that of root node. Similarly, the right subtree will contain all points whose coordinates
in that plane are greater-equal to that of root node.
Creation of a 2-D Tree:

Consider following points in a 2-D plane:
(3, 6), (17, 15), (13, 15), (6, 12), (9, 1), (2, 7), (10, 19)
1. Insert (3, 6): Since tree is empty, make it the root node.
2. Insert (17, 15): Compare it with root node point. Since root node is X-aligned, the X-coordinate value
will be compared to determine if it lies in the rightsubtree or in the right subtree. This point will be Y-
aligned.
3. Insert (13, 15): X-value of this point is greater than X-value of point in root node. So, this will lie in the
right subtree of (3, 6). Again Compare Y-value of this point with the Y-value of point (17, 15) (Why?).
Since, they are equal, this point will lie in the right subtree of (17, 15). This point will be X-aligned.
4. Insert (6, 12): X-value of this point is greater than X-value of point in root node. So, this will lie in the
right subtree of (3, 6). Again Compare Y-value of this point with the Y-value of point (17, 15) (Why?).
Since, 12 < 15, this point will lie in the left subtree of (17, 15). This point will be X-aligned.
5. Insert (9, 1):Similarly, this point will lie in the right of (6, 12).
6. Insert (2, 7):Similarly, this point will lie in the left of (3, 6).
7. Insert (10, 19): Similarly, this point will lie in the left of (13, 15).
How is space partitioned?
All 7 points will be plotted in the X-Y plane as follows:
1. Point (3, 6) will divide the space into two parts: Draw line X = 3.
2. Point (2, 7) will divide the space to the left of line X = 3 into two parts horizontally.
Draw line Y = 7 to the left of line X = 3.
3. Point (17, 15) will divide the space to the right of line X = 3 into two parts horizontally.
Draw line Y = 15 to the right of line X = 3.
Point (6, 12) will divide the space below line Y = 15 and to the right of line X = 3 into two parts.
Draw line X = 6 to the right of line X = 3 and below line Y = 15.

Point (13, 15) will divide the space below line Y = 15 and to the right of line X = 6 into two parts.
Draw line X = 13 to the right of line X = 6 and below line Y = 15.
Point (9, 1) will divide the space between lines X = 3, X = 6 and Y = 15 into two parts.
Draw line Y = 1 between lines X = 3 and X = 6.
Point (10, 19) will divide the space to the right of line X = 3 and above line Y = 15 into two parts.
Draw line Y = 19 to the right of line X = 3 and above line Y = 15.
Following is C++ implementation of KD Tree basic operations like search, insert and delete.
// A C++ program to demonstrate operations of KD tree

#include <iostream>
#include <cstdio>
#include <cassert>
#include <cstdlib>
// A structure to represent a point in K dimensional space

// k: K dimensional space
// coord: An array to represent position of point
struct Point
{
unsigned k;
int* coord; // Coordinate (A pointer to array of size k)
};
// A structure to represent the Input

// n: Number of points in space
// pointArray: An array to keep information of each point
struct Input
{
// n --> NUMBER OF POINTS
unsigned n;
Point* *pointArray;
};
// A structure to represent node of 2 dimensional tree

struct Node
{
Point point;
Node *left, *right;
};
// Creates and return a Point structure

Point* CreatePoint(unsigned k)
{
Point* point = new Point;
// Memory allocation failure

assert(NULL != point);
point->k = k;
point->coord = new int[k];
point->coord = new int[k];

assert(NULL != point->coord);
return point;
}
// Creates and returns an Input structure

struct Input* CreateInput(unsigned k, unsigned n)
{
struct Input* input = new Input;

assert(NULL != input);
input->n = n;
input->pointArray = new Point*[n];

assert(NULL != input->pointArray);
return input;
}
// A method to create a node of K D tree

struct Node* CreateNode(struct Point* point)
{
struct Node* tempNode = new Node;

assert(NULL != tempNode);
// Avoid shallow copy [We could have directly use

// the below assignment, But didn't, why?]
/*tempNode->point = point;*/
(tempNode->point).k = point->k;
(tempNode->point).coord = new int[point->k];
// Copy coordinate values

for (int i=0; i<(tempNode->point).k; ++i)
(tempNode->point).coord[i] = point->coord[i];
tempNode->left = tempNode->right = NULL;

return tempNode;
}
// Root is passed as pointer to pointer so that

// The parameter depth is used to decide axis of comparison
void InsertKDTreeUtil(Node * * root, Node* newNode, unsigned depth)
{
// Tree is empty?
if (!*root)
{
*root = newNode;
return;
}
// Calculate axis of comparison to determine left/right

unsigned axisOfComparison = depth % (newNode->point).k;
// Compare the new point with root and decide the left or
// right subtree
if ((newNode->point).coord[axisOfComparison] <
((*root)->point).coord[axisOfComparison])
((*root)->point).coord[axisOfComparison])
InsertKDTreeUtil(&((*root)->left), newNode, depth + 1);
else
InsertKDTreeUtil(&((*root)->right), newNode, depth + 1);
}
// Function to insert a new point in KD Tree. It mainly uses

// above recursive function "InsertKDTreeUtil()"
void InsertKDTree(Node* *root, Point* point)
{
Node* newNode = CreateNode(point);
unsigned zeroDepth = 0;
InsertKDTreeUtil(root, newNode, zeroDepth);
}
// A utility method to determine if two Points are same

// in K Dimensional space
int ArePointsSame(Point firstPoint, Point secondPoint)
{
if (firstPoint.k != secondPoint.k)
return 0;
// Compare individual coordinate values

for (int i = 0; i < firstPoint.k; ++i)
if (firstPoint.coord[i] != secondPoint.coord[i])
return 0;
return 1;
}
// Searches a Point in the K D tree. The parameter depth is used

// to determine current axis.
int SearchKDTreeUtil(Node* root, Point point, unsigned depth)
{
if (!root)
return 0;
if (ArePointsSame(root->point, point))
return 1;
unsigned axisOfComparison = depth % point.k;
if (point.coord[axisOfComparison] <
(root->point).coord[axisOfComparison])
return SearchKDTreeUtil(root->left, point, depth + 1);
return SearchKDTreeUtil(root->right, point, depth + 1);

}
// Searches a Point in the K D tree. It mainly uses

// SearchKDTreeUtil()
int SearchKDTree(Node* root, Point point)
{
unsigned zeroDepth = 0;
return SearchKDTreeUtil(root, point, zeroDepth);
}
// Creates a KD tree from given input points. It mainly

// uses InsertKDTree
Node* CreateKDTree(Input* input)
{
Node* root = NULL;
for (int i = 0; i < input->n; ++i)
InsertKDTree(&root, input->pointArray[i]);
return root;
return root;
}

void PrintArray(int* array, unsigned size)
{
for (unsigned i = 0; i < size; ++i)
cout << array[i];
cout << endl;
}
// A utility function to do inorder tree traversal

void inorderKD(Node* root)
{
if (root)
{
inorderKD(root->left);
PrintArray((root->point).coord, (root->point).k);
inorderKD(root->right);
}
}

int main()
{
// 2 Dimensional tree [For the sake of simplicity]
unsigned k = 2;
// Total number of Points is 7

unsigned n = 7;
Input* input = CreateInput(k, n);
// itc --> ITERATOR for coord

// itp --> ITERATOR for POINTS
for (int itp = 0; itp < n; ++itp)
{
input->pointArray[itp] = CreatePoint(k);
for (int itc = 0; itc < k; ++itc)

input->pointArray[itp]->coord[itc] = rand() % 20;
PrintArray(input->pointArray[itp]->coord, k);
}
Node* root = CreateKDTree(input);
cout << "Inorder traversal of K-D Tree created is:\n";

inorderKD(root);
return 0;
}

Output:

17
140
94
1818
24
55
17
Inorder traversal of K-D Tree created is:
17
140
24
17
55
94
1818

This article is continuation of following three articles:
Please go through Part 1, Part 2 and Part 3, before looking at current article, where we have seen few basics
on suffix tree, high level ukkonen’s algorithm, suffix link and three implementation tricks and some details
on activePoint along with an example string “abcabxabcd” where we went through four phases of building
suffix tree.
Let’s revisit those four phases we have seen already in Part 3, in terms of trick 2, trick 3 and activePoint.
activePoint is initialized to (root, NULL, 0), i.e. activeNode is root, activeEdge is NULL (for easy
understanding, we are giving character value to activeEdge, but in code implemntation, it will be
index of the character) and activeLength is ZERO.
The global variable END and remainingSuffixCount are initialized to ZERO
*********************Phase 1*********************************
In Phase 1, we read 1 st character (a) from string S
Set END to 1
Increment remainingSuffixCount by 1 (remainingSuffixCount will be 1 here, i.e. there is 1 extension
left to be performed)
Run a loop remainingSuffixCount times (i.e. one time) as below:
If activeLength is ZERO, set activeEdge to the current character (here activeEdge will be ‘a’).
This is APCFALZ.
Check if there is an edge going out from activeNode (which is root in this phase 1) for the
activeEdge. If not, create a leaf edge. If present, walk down. In our example, leaf edge gets
created (Rule 2).
Once extension is performed, decrement the remainingSuffixCount by 1
At this point, activePoint is (root, a, 0)
At the end of phase 1, remainingSuffixCount is ZERO (All suffixes are added explicitly).
Figure 20 in Part 3 is the resulting tree after phase 1.
*********************Phase 2*********************************
In Phase 2, we read 2nd character (b) from string S
Set END to 2 (This will do extension 1)

If activeLength is ZERO, set activeEdge to the current character (here activeEdge will be ‘b’).
This is APCFALZ.
created.
At this point, activePoint is (root, b, 0)
*********************Phase 3*********************************
rd
In Phase 3, we read 3rd character (c) from string S
Set END to 3 (This will do extensions 1 and 2)

If activeLength is ZERO, set activeEdge to the current character (here activeEdge will be ‘c’).
This is APCFALZ.
created.
At this point, activePoint is (root, c, 0)
*********************Phase 4*********************************
In Phase 4, we read 4th character (a) from string S
Set END to 4 (This will do extensions 1, 2 and 3)

If activeLength is ZERO, set activeEdge to the current character (here activeEdge will be ‘a’).
This is APCFALZ.
activeEdge. If not, create a leaf edge. If present, walk down (The trick 1 – skip/count). In our
example, edge ‘a’ is present going out of activeNode (i.e. root). No walk down needed as
activeLength < edgeLength. We increment activeLength from zero to 1 (APCFER3) and stop
any further processing (Rule 3).
At this point, activePoint is (root, a, 1) and remainingSuffixCount remains set to 1 (no change
there)
At the end of phase 4, remainingSuffixCount is 1 (One suffix ‘a’, the last one, is not added explicitly in tree,
but it is there in tree implicitly).
Revisiting completed for 1 st four phases, we will continue building the tree and see how it goes.
*********************Phase 5*********************************
In phase 5, we read 5th character (b) from string S
Set END to 5 (This will do extensions 1, 2 and 3). See Figure 29 shown below.
Increment remainingSuffixCount by 1 (remainingSuffixCount will be 2 here, i.e. there are 2 extension
left to be performed, which are extensions 4 and 5. Extension 4 is supposed to add suffix “ab” and
extension 5 is supposed to add suffix “b” in tree)
Run a loop remainingSuffixCount times (i.e. two times) as below:
activeEdge. If not, create a leaf edge. If present, walk down. In our example, edge ‘a’ is present
going out of activeNode (i.e. root).
Do a walk down (The trick 1 – skip/count) if necessary. In current phase 5, no walk down
needed as activeLength < edgeLength. Here activePoint is (root, a, 1) for extension 4
(remainingSuffixCount = 2)
Check if current character of string S (which is ‘b’) is already present after the activePoint. If
yes, no more processing (rule 3). Same is the case in our example, so we increment
activeLength from 1 to 2 (APCFER3) and we stop here (Rule 3).
in remainingSuffixCount)
At the end of phase 5, remainingSuffixCount is 2 (Two suffixes, ‘ab’ and ‘b’, the last two, are not added
explicitly in tree, but they are in tree implicitly).
*********************Phase 6*********************************
In phase 6, we read 6th character (x) from string S
Set END to 6 (This will do extensions 1, 2 and 3)

Increment remainingSuffixCount by 1 (remainingSuffixCount will be 3 here, i.e. there are 3 extension

left to be performed, which are extensions 4, 5 and 6 for suffixes “abx”, “bx” and “x” respectively)
Run a loop remainingSuffixCount times (i.e. three times) as below:
While extension 4, the activePoint is (root, a, 2) which points to ‘b’ on edge starting with ‘a’.
In extension 4, current character ‘x’ from string S doesn’t match with the next character on the
edge after activePoint, so this is the case of extension rule 2. So a leaf edge is created here with
edge label x. Also here traversal ends in middle of an edge, so a new internal node also gets
created at the end of activePoint.
Decrement the remainingSuffixCount by 1 (from 3 to 2) as suffix “abx” added in tree.

Now activePoint will change after applying rule 2. Three other cases, (APCFER3, APCFWD and
APCFALZ) where activePoint changes, are already discussed in Part 3.
activePoint change for extension rule 2 (APCFER2):

Case 1 (APCFER2C1): If activeNode is root and activeLength is greater than ZERO, then decrement the
activeLength by 1 and activeEdge will be set “S[i – remainingSuffixCount + 1]” where i is current phase
number. Can you see why this change in activePoint? Look at current extension we just discussed above for
phase 6 (i=6) again where we added suffix “abx”. There activeLength is 2 and activeEdge is ‘a’. Now in next
extension, we need to add suffix “bx” in the tree, i.e. path label in next extension should start with ‘b’. So ‘b’
(the 5th character in string S) should be active edge for next extension and index of b will be “i –
remainingSuffixCount + 1” (6 – 2 + 1 = 5). activeLength is decremented by 1 because activePoint gets closer
to root by length 1 after every extension.
What will happen If activeNode is root and activeLength is ZERO? This case is already taken care by
APCFALZ.
Case 2 (APCFER2C2): If activeNode is not root, then follow the suffix link from current activeNode. The
new node (which can be root node or another internal node) pointed by suffix link will be the activeNode for
next extension. No change in activeLength and activeEdge. Can you see why this change in activePoint? This
is because: If two nodes are connected by a suffix link, then labels on all paths going down from those two
nodes, starting with same character, will be exactly same and so for two corresponding similar point on
those paths, activeEdge and activeLength will be same and the two nodes will be the activeNode. Look at
Figure 18 in Part 2. Let’s say in phase i and extension j, suffix ‘xAabcdedg’ was added in tree. At that point,
let’s say activePoint was (Node-V, a, 7), i.e. point ‘g’. So for next extension j+1, we would add suffix
‘Aabcdefg’ and for that we need to traverse 2nd path shown in Figure 18. This can be done by following suffix
link from current activeNode v. Suffix link takes us to the path to be traversed somewhere in between [Node
s(v)] below which the path is exactly same as how it was below the previous activeNode v. As said earlier,
“activePoint gets closer to root by length 1 after every extension”, this reduction in length will happen above
the node s(v) but below s(v), no change at all. So when activeNode is not root in current extension, then for
next extension, only activeNode changes (No change in activeEdge and activeLength).
At this point in extension 4, current activePoint is (root, a, 2) and based on APCFER2C1, new
activePoint for next extension 5 will be (root, b, 1)
Next suffix to be added is ‘bx’ (with remainingSuffixCount 2).
Current character ‘x’ from string S doesn’t match with the next character on the edge after
activePoint, so this is the case of extension rule 2. So a leaf edge is created here with edge label
x. Also here traversal ends in middle of an edge, so a new internal node also gets created at the
end of activePoint.
Suffix link is also created from previous internal node (of extension 4) to the new internal node
created in current extension 5.
Decrement the remainingSuffixCount by 1 (from 2 to 1) as suffix “bx” added in tree.
At this point in extension 5, current activePoint is (root, b, 1) and based on APCFER2C1 new
activePoint for next extension 6 will be (root, x, 0)
Next suffix to be added is ‘x’ (with remainingSuffixCount 1).
In the next extension 6, character x will not match to any existing edge from root, so a new edge
with label x will be created from root node. Also suffix link from previous extension’s internal
node goes to root (as no new internal node created in current extension 6).
Decrement the remainingSuffixCount by 1 (from 1 to 0) as suffix “x” added in tree
This completes the phase 6.

Note that phase 6 has completed all its 6 extensions (Why? Because the current character c was not seen in
string so far, so rule 3, which stops further extensions never got chance to get applied in phase 6) and so the
tree generated after phase 6 is a true suffix tree (i.e. not an implicit tree) for the characters ‘abcabx’ read so
far and it has all suffixes explicitly in the tree.
While building the tree above, following facts were noticed:
A newly created internal node in extension i, points to another internal node or root (if activeNode is
root in extension i+1) by the end of extension i+1 via suffix link (Every internal node MUST have a
suffix link pointing to another internal node or root)
Suffix link provides short cut while searching path label end of next suffix
With proper tracking of activePoints between extensions/phases, unnecessary walkdown from root
can be avoided.
We will go through rest of the phases (7 to 11) in Part 5 and build the tree completely and after that, we will
see the code for the algorithm in Part 6.
References:
Binomial Heap
The main application of Binary Heap is as implement priority queue. Binomial Heap is an extension of
Binary Heap that provides faster union or merge operation together with other operations provided by
Binary Heap.
A Binomial Heap is a collection of Binomial Trees
What is a Binomial Tree?

A Binomial Tree of order 0 has 1 node. A Binomial Tree of order k can be constructed by taking two binomial
trees of order k-1, and making one as leftmost child of other.
A Binomial Tree of order k has following properties.
a) It has exactly 2k nodes.
b) It has depth as k.
c) There are exactly kCi nodes at depth i for i = 0, 1, . . . , k.
d) The root has degree k and children of root are themselves Binomial Trees with order k-1, k-2,.. 0 from left
to right.
The following diagram is taken from 2nd Edition of CLRS book.
Binomial Heap:
A Binomial Heap is a set of Binomial Trees where each Binomial Tree follows Min Heap property. And there
can be at-most one Binomial Tree of any degree.
Examples Binomial Heap:

12------------10--------------------20
/ \ / | \
15 50 70 50 40
| / | |
30 80 85 65
|
100
A Binomial Heap with 13 nodes. It is a collection of 3
Binomial Trees of orders 0, 2 and 3 from left to right.
10--------------------20
/ \ / | \
15 50 70 50 40
| / | |
30 80 85 65
|
100

A Binomial Heap with 12 nodes. It is a collection of 2

Binomial Trees of orders 2 and 3 from left to right.
Binary Representation of a number and Binomial Heaps

A Binomial Heap with n nodes has number of Binomial Trees equal to the number of set bits in Binary
representation of n. For example let n be 13, there 3 set bits in binary representation of n (00001101), hence
3 Binomial Trees. We can also relate degree of these Binomial Trees with positions of set bits. With this
relation we can conclude that there are O(Logn) Binomial Trees in a Binomial Heap with ‘n’ nodes.
Operations of Binomial Heap:

The main operation in Binomial Heap is union(), all other operations mainly use this operation. The union()
operation is to combine two Binomial Heaps into one. Let us first discuss other operations, we will discuss
union later.
1) insert(H, k): Inserts a key ‘k’ to Binomial Heap ‘H’. This operation first creates a Binomial Heap with
single key ‘k’, then calls union on H and the new Binomial heap.
2) getMin(H): A simple way to getMin() is to traverse the list of root of Binomial Trees and return the
minimum key. This implementation requires O(Logn) time. It can be optimized to O(1) by maintaining a
pointer to minimum key root.
3) extractMin(H): This operation also uses union(). We first call getMin() to find the minimum key
Binomial Tree, then we remove the node and create a new Binomial Heap by connecting all subtrees of the
removed minimum node. Finally we call union() on H and the newly created Binomial Heap. This operation
requires O(Logn) time.
4) delete(H): Like Binary Heap, delete operation first reduces the key to minus infinite, then calls
extractMin().
5) decreaseKey(H): decreaseKey() is also similar to Binary Heap. We compare the decreases key with it
parent and if parent’s key is less, we swap keys and recur for parent. We stop when we either reach a node
whose parent has smaller key or we hit the root node. Time complexity of decreaseKey() is O(Logn).
Union operation in Binomial Heap:

Given two Binomial Heaps H1 and H2, union(H1, H2) creates a single Binomial Heap.
1) The first step is to simply merge the two Heaps in non-decreasing order of degrees. In the following
diagram, figure(b) shows the result after merging.
2) After the simple merge, we need to make sure that there is at-most one Binomial Tree of any order. To do
this, we need to combine Binomial Trees of same order. We traverse the list of merged roots, we keep track of
three pointers, prev, x and next-x. There can be following 4 cases when we traverse the list of roots.
—–Case 1: Orders of x and next-x are not same, we simply move ahead.
In following 3 cases orders of x and next-x are same.
—–Case 2: If order of next-next-x is also same, move ahead.
—–Case 3: If key of x is smaller than or equal to key of next-x, then make next-x as a child of x by linking it
with x.
—–Case 4: If key of x is greater, then make x as child of next.
The following diagram is taken from 2nd Edition of CLRS book.
How to represent Binomial Heap?

A Binomial Heap is a set of Binomial Trees. A Binomial Tree must be represented in a way that allows
sequential access to all siblings, starting from the leftmost sibling (We need this in and extractMin() and
delete()). The idea is to represent Binomial Trees as leftmost child and right-sibling representation, i.e.,
every node stores two pointers, one to the leftmost child and other to the right sibling.
We will soon be discussing implementation of Binomial Heap.
Sources:
This article is contributed by Shivam. Please write comments if you find anything incorrect, or you want to
This article is continuation of following four articles:
Please go through Part 1, Part 2, Part 3 and Part 4, before looking at current article, where we have seen few
basics on suffix tree, high level ukkonen’s algorithm, suffix link and three implementation tricks and some
details on activePoint along with an example string “abcabxabcd” where we went through six phases of
building suffix tree.
Here, we will go through rest of the phases (7 to 11) and build the tree completely.
*********************Phase 7*********************************
In phase 7, we read 7th character (a) from string S
Set END to 7 (This will do extensions 1, 2, 3, 4, 5 and 6) – because we have 6 leaf edges so far by the
end of previous phase 6.
Increment remainingSuffixCount by 1 (remainingSuffixCount will be 1 here, i.e. there is only 1

extension left to be performed, which is extensions 7 for suffix ‘a’)
If activeLength is ZERO [activePoint in previous phase was (root, x, 0)], set activeEdge to the
current character (here activeEdge will be ‘a’). This is APCFALZ. Now activePoint becomes
(root, ‘a’, 0).
going out of activeNode (i.e. root), here we increment activeLength from zero to 1 (APCFER3)
and stop any further processing.
there)
At the end of phase 7, remainingSuffixCount is 1 (One suffix ‘a’, the last one, is not added explicitly in tree,
but it is there in tree implicitly).
Above Figure 33 is the resulting tree after phase 7.
*********************Phase 8*********************************
In phase 8, we read 8th character (b) from string S
end of previous phase 7 (Figure 34).
Increment remainingSuffixCount by 1 (remainingSuffixCount will be 2 here, i.e. there are two

extensions left to be performed, which are extensions 7 and 8 for suffixes ‘ab’ and ‘b’ respectively)
Run a loop remainingSuffixCount times (i.e. two times) as below:
Do a walk down (The trick 1 – skip/count) if necessary. In current phase 8, no walk down
needed as activeLength < edgeLength. Here activePoint is (root, a, 1) for extension 7
(remainingSuffixCount = 2)
Check if current character of string S (which is ‘b’) is already present after the activePoint. If
yes, no more processing (rule 3). Same is the case in our example, so we increment
activeLength from 1 to 2 (APCFER3) and we stop here (Rule 3).
in remainingSuffixCount)
At the end of phase 8, remainingSuffixCount is 2 (Two suffixes, ‘ab’ and ‘b’, the last two, are not added
explicitly in tree explicitly, but they are in tree implicitly).
*********************Phase 9*********************************
In phase 9, we read 9th character (c) from string S

Increment remainingSuffixCount by 1 (remainingSuffixCount will be 3 here, i.e. there are three

extensions left to be performed, which are extensions 7, 8 and 9 for suffixes ‘abc’, ‘bc’ and ‘c’
respectively)
Run a loop remainingSuffixCount times (i.e. three times) as below:
Do a walk down (The trick 1 – skip/count) if necessary. In current phase 9,walk down needed as
activeLength(2) >= edgeLength(2). While walk down, activePoint changes to (Node A, c, 0)
based on APCFWD (This is first time APCFWD is being applied in our example).
Check if current character of string S (which is ‘c’) is already present after the activePoint. If yes,
no more processing (rule 3). Same is the case in our example, so we increment activeLength
from 0 to 1 (APCFER3) and we stop here (Rule 3).
At this point, activePoint is (Node A, c, 1) and remainingSuffixCount remains set to 3 (no
change in remainingSuffixCount)
At the end of phase 9, remainingSuffixCount is 3 (Three suffixes, ‘abc’, ‘bc’ and ‘c’, the last three, are not
added explicitly in tree explicitly, but they are in tree implicitly).
*********************Phase 10*********************************
In phase 10, we read 10th character (d) from string S

Increment remainingSuffixCount by 1 (remainingSuffixCount will be 4 here, i.e. there are four

extensions left to be performed, which are extensions 7, 8, 9 and 10 for suffixes ‘abcd’, ‘bcd’, ‘cd’ and
‘d’ respectively)
Run a loop remainingSuffixCount times (i.e. four times) as below:
*********************Extension 7*********************************
Check if there is an edge going out from activeNode (Node A) for the activeEdge(c). If not,
create a leaf edge. If present, walk down. In our example, edge ‘c’ is present going out of
activeNode (Node A).
Do a walk down (The trick 1 – skip/count) if necessary. In current Extension 7, no walk down
needed as activeLength < edgeLength.
Check if current character of string S (which is ‘d’) is already present after the activePoint. If
not, rule 2 will apply. In our example, there is no path starting with ‘d’ going out of activePoint,
so we create a leaf edge with label ‘d’. Since activePoint ends in the middle of an edge, we will
create a new internal node just after the activePoint (Rule 2)
The newly created internal node c (in above Figure) in current extension 7, will get it’s suffix
link set in next extension 8 (see Figure 38 below).
Decrement the remainingSuffixCount by 1 (from 4 to 3) as suffix “abcd” added in tree.
Now activePoint will change for next extension 8. Current activeNode is an internal node (Node
A), so there must be a suffix link from there and we will follow that to get new activeNode and
that’s going to be ‘Node B’. There is no change in activeEdge and activeLength (This is
APCFER2C2). So new activePoint is (Node B, c, 1).
*********************Extension 8*********************************
Now in extension 8 (here we will add suffix ‘bcd’), while adding character ‘d’ after the current
activePoint, exactly same logic will apply as previous extension 7. In previous extension 7, we
added character ‘d’ at activePoint (Node A, c, 1) and in current extension 8, we are going to add
same character ‘d’ at activePoint (Node B c, 1). So logic will be same and here we a new leaf
edge with label ‘d’ and a new internal node will be created. And the new internal node (C) of
previous extension will point to the new node (D) of current extension via suffix link.
Please note the node C from previous extension (see Figure 37 above) got it’s suffix link set
here and node D created in current extension will get it’s suffix link set in next extension. What
happens if no new node created in next extensions? We have seen this before in Phase 6 (Part
4) and will see again in last extension of this Phase 10. Stay Tuned.
Decrement the remainingSuffixCount by 1 (from 3 to 2) as suffix “bcd” added in tree.
Now activePoint will change for next extension 9. Current activeNode is an internal node (Node
B), so there must be a suffix link from there and we will follow that to get new activeNode and
that is ‘Root Node’. There is no change in activeEdge and activeLength (This is APCFER2C2).
So new activePoint is (root, c, 1).
*********************Extension 9*********************************
Now in extension 9 (here we will add suffix ‘cd’), while adding character ‘d’ after the current
activePoint, exactly same logic will apply as previous extensions 7 and 8. Note that internal
node D created in previous extension 8, now points to internal node E (created in current
extension) via suffix link.

Decrement the remainingSuffixCount by 1 (from 2 to 1) as suffix “cd” added in tree.
Now activePoint will change for next extension 10. Current activeNode is root and activeLength
is 1, based on APCFER2C1, activeNode will remain ‘root’, activeLength will be decremented by
1 (from 1 to ZERO) and activeEdge will be ‘d’. So new activePoint is (root, d, 0).
*********************Extension 10*********************************
Now in extension 10 (here we will add suffix ‘d’), while adding character ‘d’ after the current
activePoint, there is no edge starting with d going out of activeNode root, so a new leaf edge
with label d is created (Rule 2). Note that internal node E created in previous extension 9, now
points to root node via suffix link (as no new internal node created in this extension).
Internal Node created in previous extension, waiting for suffix link to be set in next extension,
points to root if no internal node created in next extension. In code implementation, as soon as
a new internal node (Say A) gets created in an extension j, we will set it’s suffix link to root
node and in next extension j+1, if Rule 2 applies on an existing or newly created node (Say B)
or Rule 3 applies with some active node (Say B), then suffix link of node A will change to the
new node B , else node A will keep pointing to root
Decrement the remainingSuffixCount by 1 (from 1 to 0) as suffix “d” added in tree. That means
no more suffix is there to add and so the phase 10 ends here. Note that this tree is an explicit
tree as all suffixes are added in tree explicitly (Why ?? because character d was not seen before
in string S so far)
activePoint for next phase 11 is (root, d, 0).
We see following facts in Phase 10:
Internal Nodes connected via suffix links have exactly same tree below them, e.g. In above Figure 40,
A and B have same tree below them, similarly C, D and E have same tree below them.
Due to above fact, in any extension, when current activeNode is derived via suffix link from previous
extension’s activeNode, then exactly same extension logic apply in current extension as previous
extension. (In Phase 10, same extension logic is applied in extensions 7, 8 and 9)
If a new internal node gets created in extension j of any phase i, then this newly created internal node
will get it’s suffix link set by the end of next extension j+1 of same phase i. e.g. node C got created in
extension 7 of phase 10 (Figure 37) and it got it’s suffix link set to node D in extension 8 of same phase
10 (Figure 38). Similarly node D got created in extension 8 of phase 10 (Figure 38) and it got its suffix
link set to node E in extension 9 of same phase 10 (Figure 39). Similarly node E got created in
extension 9 of phase 10 (Figure 39) and it got its suffix link set to root in extension 10 of same phase
10 (Figure 40).
Based on above fact, every internal node will have a suffix link to some other internal node or root.
Root is not an internal node and it will not have suffix link.
*********************Phase 11*********************************
In phase 11, we read 11th character ($) from string S
Set END to 11 (This will do extensions 1 to 10) – because we have 10 leaf edges so far by the end of
previous phase 10.
Increment remainingSuffixCount by 1 (from 0 to 1), i.e. there is only one suffix ‘$’ to be added in tree.
Since activeLength is ZERO, activeEdge will change to current character ‘$’ of string S being processed
(APCFALZ).
There is no edge going out from activeNode root, so a leaf edge with label ‘$’ will be created (Rule 2).
Decrement the remainingSuffixCount by 1 (from 1 to 0) as suffix “$” added in tree. That means no
more suffix is there to add and so the phase 11 ends here. Note that this tree is an explicit tree as all
suffixes are added in tree explicitly (Why ?? because character $ was not seen before in string S so far)
Now we have added all suffixes of string ‘abcabxabcd$’ in suffix tree. There are 11 leaf ends in this tree and
labels on the path from root to leaf end represents one suffix. Now the only one thing left is to assign a
number (suffix index) to each leaf end and that number would be the suffix starting position in the string S.
This can be done by a DFS traversal on tree. While DFS traversal, keep track of label length and when a leaf
end is found, set the suffix index as “stringSize – labelSize + 1”. Indexed suffix tree will look like below:

In above Figure, suffix indices are shown as character position starting with 1 (It’s not zero indexed). In
code implementation, suffix index will be set as zero indexed, i.e. where we see suffix index j (1 to m for
string of length m) in above figure, in code implementation, it will be j-1 (0 to m-1)
And we are done !!!!
Data Structure to represent suffix tree

How to represent the suffix tree?? There are nodes, edges, labels and suffix links and indices.
Below are some of the operations/query we will be doing while building suffix tree and later on while using
the suffix tree in different applications/usages:
What length of path label on some edge?

What is the path label on some edge?
Check if there is an outgoing edge for a given character from a node.
What is the character value on an edge at some given distance from a node?
Where an internal node is pointing via suffix link?
What is the suffix index on a path from root to leaf?
Check if a given string present in suffix tree (as substring, suffix or prefix)?
We may think of different data structures which can fulfil these requirements.
In the next Part 6, we will discuss the data structure we will use in our code implementation and the code as
well.
References:
This article is continuation of following five articles:
Please go through Part 1, Part 2, Part 3, Part 4 and Part 5, before looking at current article, where we have
seen few basics on suffix tree, high level ukkonen’s algorithm, suffix link and three implementation tricks
and activePoints along with an example string “abcabxabcd” where we went through all phases of building
suffix tree.
Here, we will see the data structure used to represent suffix tree and the code implementation.
At that end of Part 5 article, we have discussed some of the operations we will be doing while building suffix
tree and later when we use suffix tree in different applications.
There could be different possible data structures we may think of to fulfill the requirements where some data
structure may be slow on some operations and some fast. Here we will use following in our implementation:
We will have SuffixTreeNode structure to represent each node in tree. SuffixTreeNode structure will have
following members:
children – This will be an array of alphabet size. This will store all the children nodes of current node
on different edges starting with different characters.
suffixLink – This will point to other node where current node should point via suffix link.
start, end – These two will store the edge label details from parent node to current node. (start, end)
interval specifies the edge, by which the node is connected to its parent node. Each edge will connect
two nodes, one parent and one child, and (start, end) interval of a given edge will be stored in the
child node. Lets say there are two nods A (parent) and B (Child) connected by an edge with indices (5,
8) then this indices (5, 8) will be stored in node B.
suffixIndex – This will be non-negative for leaves and will give index of suffix for the path from root
to this leaf. For non-leaf node, it will be -1 .
This data structure will answer to the required queries quickly as below:
How to check if a node is root ? — Root is a special node, with no parent and so it’s start and end will
be -1, for all other nodes, start and end indices will be non-negative.
How to check if a node is internal or leaf node ? — suffixIndex will help here. It will be -1 for internal
node and non-negative for leaf nodes.
What is the length of path label on some edge? — Each edge will have start and end indices and length
of path label will be end-start+1
What is the path label on some edge ? — If string is S, then path label will be substring of S from start
index to end index inclusive, [start, end].
How to check if there is an outgoing edge for a given character c from a node A ? — If A->children[c]
is not NULL, there is a path, if NULL, no path.
What is the character value on an edge at some given distance d from a node A ? — Character at
distance d from node A will be S[A->start + d], where S is the string.
Where an internal node is pointing via suffix link ? — Node A will point to A->suffixLink
What is the suffix index on a path from root to leaf ? — If leaf node is A on the path, then suffix index
on that path will be A->suffixIndex
Following is C implementation of Ukkonen’s Suffix Tree Construction. The code may look a bit lengthy,
probably because of a good amount of comments.

// A C program to implement Ukkonen's Suffix Tree Construction

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
struct SuffixTreeNode {
struct SuffixTreeNode *children[MAX_CHAR];
//pointer to other node via suffix link

struct SuffixTreeNode *suffixLink;
/*(start, end) interval specifies the edge, by which the

node is connected to its parent node. Each edge will
connect two nodes, one parent and one child, and
(start, end) interval of a given edge will be stored
in the child node. Lets say there are two nods A and B
connected by an edge with indices (5, 8) then this
indices (5, 8) will be stored in node B. */
int start;
int *end;
/*for leaf nodes, it stores the index of suffix for

the path from root to leaf*/
int suffixIndex;
};
typedef struct SuffixTreeNode Node;
char text[100]; //Input string

Node *root = NULL; //Pointer to root node
/*lastNewNode will point to newly created internal node,

waiting for it's suffix link to be set, which might get
a new suffix link (other than root) in next extension of
same phase. lastNewNode will be set to NULL when last
newly created internal node (if there is any) got it's
suffix link reset to new internal node created in next
extension of same phase. */
Node *lastNewNode = NULL;
Node *activeNode = NULL;
/*activeEdge is represeted as input string character

index (not the character itself)*/
int activeEdge = -1;
int activeLength = 0;
// remainingSuffixCount tells how many suffixes yet to

// be added in tree
int remainingSuffixCount = 0;
int leafEnd = -1;
int *rootEnd = NULL;
int *splitEnd = NULL;
int size = -1; //Length of input string
Node *newNode(int start, int *end)

{
Node *node =(Node*) malloc(sizeof(Node));
int i;
for (i = 0; i < MAX_CHAR; i++)
node->children[i] = NULL;
/*For root node, suffixLink will be set to NULL
For internal nodes, suffixLink will be set to root
by default in current extension and may change in
next extension*/
node->suffixLink = root;
node->start = start;
node->end = end;
/*suffixIndex will be set to -1 by default and

actual suffix index will be set later for leaves
at the end of all phases*/
node->suffixIndex = -1;
return node;
}
int edgeLength(Node *n) {

return *(n->end) - (n->start) + 1;
}
int walkDown(Node *currNode)

{
/*activePoint change for walk down (APCFWD) using
Skip/Count Trick (Trick 1). If activeLength is greater
than current edge length, set next internal node as
activeNode and adjust activeEdge and activeLength
accordingly to represent same activePoint*/
if (activeLength >= edgeLength(currNode))
{
activeEdge += edgeLength(currNode);
activeLength -= edgeLength(currNode);
activeNode = currNode;
return 1;
}
return 0;
}
void extendSuffixTree(int pos)

{
/*Extension Rule 1, this takes care of extending all
leaves created so far in tree*/
leafEnd = pos;
/*Increment remainingSuffixCount indicating that a

new suffix added to the list of suffixes yet to be
added in tree*/
remainingSuffixCount++;
/*set lastNewNode to NULL while starting a new phase,

indicating there is no internal node waiting for
it's suffix link reset in current phase*/
lastNewNode = NULL;
//Add all suffixes (yet to be added) one by one in tree

while(remainingSuffixCount > 0) {
if (activeLength == 0)
activeEdge = pos; //APCFALZ
// There is no outgoing edge starting with

// activeEdge from activeNode
if (activeNode->children[text[activeEdge]] == NULL)
{
//Extension Rule 2 (A new leaf edge gets created)
activeNode->children[text[activeEdge]] =
newNode(pos, &leafEnd);
/*A new leaf edge is created in above line starting

from an existng node (the current activeNode), and
if there is any internal node waiting for it's suffix
link get reset, point the suffix link from that last
internal node to current activeNode. Then set lastNewNode
to NULL indicating no more node waiting for suffix link
reset.*/
if (lastNewNode != NULL)
{
lastNewNode->suffixLink = activeNode;
lastNewNode = NULL;
}
}
// There is an outgoing edge starting with activeEdge
// from activeNode
else
{
// Get the next node at the end of edge starting
// with activeEdge
Node *next = activeNode->children[text[activeEdge]];
if (walkDown(next))//Do walkdown
{
//Start from next node (the new activeNode)
continue;
}
/*Extension Rule 3 (current character being processed
is already on the edge)*/
if (text[next->start + activeLength] == text[pos])
{
//If a newly created node waiting for it's
//suffix link to be set, then set suffix link
//of that waiting node to curent active node
if(lastNewNode != NULL && activeNode != root)
{
lastNewNode = NULL;
}
//APCFER3
activeLength++;
/*STOP all further processing in this phase
and move on to next phase*/
break;
}
/*We will be here when activePoint is in middle of

the edge being traversed and current character
being processed is not on the edge (we fall off
the tree). In this case, we add a new internal node
and a new leaf edge going out of that new node. This
is Extension Rule 2, where a new leaf edge and a new
internal node get created*/
splitEnd = (int*) malloc(sizeof(int));
*splitEnd = next->start + activeLength - 1;
//New internal node

Node *split = newNode(next->start, splitEnd);
activeNode->children[text[activeEdge]] = split;
//New leaf coming out of new internal node

split->children[text[pos]] = newNode(pos, &leafEnd);
next->start += activeLength;
split->children[text[next->start]] = next;
/*We got a new internal node here. If there is any

internal node created in last extensions of same
phase which is still waiting for it's suffix link
reset, do it now.*/
{
/*suffixLink of lastNewNode points to current newly
created internal node*/
lastNewNode->suffixLink = split;
}
/*Make the current newly created internal node waiting

for it's suffix link reset (which is pointing to root
at present). If we come across any other internal node
(existing or newly created) in next extension of same
phase, when a new leaf edge gets added (i.e. when
Extension Rule 2 applies is any of the next extension
of same phase) at that point, suffixLink of this node
will point to that internal node.*/
lastNewNode = split;
}
/* One suffix got added in tree, decrement the count of

suffixes yet to be added.*/
remainingSuffixCount--;
if (activeNode == root && activeLength > 0) //APCFER2C1
{
activeLength--;
activeEdge = pos - remainingSuffixCount + 1;
}
else if (activeNode != root) //APCFER2C2
{
activeNode = activeNode->suffixLink;
}
}
}
void print(int i, int j)

{
int k;
for (k=i; k<=j; k++)
printf("%c", text[k]);
}
//Print the suffix tree as well along with setting suffix index
//So tree will be printed in DFS manner
//Each edge along with it's suffix index will be printed
void setSuffixIndexByDFS(Node *n, int labelHeight)
{
if (n == NULL) return;
if (n->start != -1) //A non-root node

{
//Print the label on edge from parent to current node
print(n->start, *(n->end));
}
int leaf = 1;
int i;
{
if (n->children[i] != NULL)
{
{
if (leaf == 1 && n->start != -1)
printf(" [%d]\n", n->suffixIndex);
//Current node is not a leaf as it has outgoing

//edges from it.
leaf = 0;
setSuffixIndexByDFS(n->children[i], labelHeight +
edgeLength(n->children[i]));
}
}
if (leaf == 1)
{
n->suffixIndex = size - labelHeight;
}
}
void freeSuffixTreeByPostOrder(Node *n)

{
if (n == NULL)
return;
int i;
{
{
freeSuffixTreeByPostOrder(n->children[i]);
}
}
if (n->suffixIndex == -1)
free(n->end);
free(n);
}
/*Build the suffix tree and print the edge labels along with
suffixIndex. suffixIndex for leaf edges will be >= 0 and
for non-leaf edges will be -1*/
void buildSuffixTree()
{
size = strlen(text);
int i;
rootEnd = (int*) malloc(sizeof(int));
*rootEnd = - 1;
/*Root is a special node with start and end indices as -1,

as it has no parent from where an edge comes to root*/
root = newNode(-1, rootEnd);
activeNode = root; //First activeNode will be root

extendSuffixTree(i);
int labelHeight = 0;
setSuffixIndexByDFS(root, labelHeight);
//Free the dynamically allocated memory

freeSuffixTreeByPostOrder(root);
}

{
// strcpy(text, "abc"); buildSuffixTree();
// strcpy(text, "xabxac#"); buildSuffixTree();
// strcpy(text, "xabxa"); buildSuffixTree();
// strcpy(text, "xabxa$"); buildSuffixTree();
strcpy(text, "abcabxabcd$"); buildSuffixTree();
// strcpy(text, "geeksforgeeks$"); buildSuffixTree();
// strcpy(text, "THIS IS A TEST TEXT$"); buildSuffixTree();
// strcpy(text, "AABAACAADAABAAABAA$"); buildSuffixTree();
return 0;
}

Output (Each edge of Tree, along with suffix index of child node on edge, is printed in DFS order. To
understand the output better, match it with the last figure no 43 in previous Part 5 article):
$ [10]
ab [-1]
c [-1]
abxabcd$ [0]
d$ [6]
xabcd$ [3]
b [-1]
c [-1]
abxabcd$ [1]
d$ [7]
xabcd$ [4]
c [-1]
abxabcd$ [2]
d$ [8]
d$ [9]
xabcd$ [5]

Now we are able to build suffix tree in linear time, we can solve many string problem in efficient way:
Check if a given pattern P is substring of text T (Useful when text is fixed and pattern changes,
KMP
otherwise
Find all occurrences of a given pattern P present in text T
Find longest repeated substring
Linear Time Suffix Array Creation
The above basic problems can be solved by DFS traversal on suffix tree.
We will soon post articles on above problems and others like below:
And More.
Test you understanding?
1. Draw suffix tree (with proper suffix link, suffix indices) for string “AABAACAADAABAAABAA$” on
paper and see if that matches with code output.
2. Every extension must follow one of the three rules: Rule 1, Rule 2 and Rule 3.
Following are the rules applied on five consecutive extensions in some Phase i (i > 5), which ones are
valid:
A) Rule 1, Rule 2, Rule 2, Rule 3, Rule 3
B) Rule 1, Rule 2, Rule 2, Rule 3, Rule 2
C) Rule 2, Rule 1, Rule 1, Rule 3, Rule 3
D) Rule 1, Rule 1, Rule 1, Rule 1, Rule 1
E) Rule 2, Rule 2, Rule 2, Rule 2, Rule 2
F) Rule 3, Rule 3, Rule 3, Rule 3, Rule 3
3. What are the valid sequences in above for Phase 5
4. Every internal node MUST have it’s suffix link set to another node (internal or root). Can a newly
created node point to already existing internal node or not ? Can it happen that a new node created in
extension j, may not get it’s right suffix link in next extension j+1 and get the right one in later
extensions like j+2, j+3 etc ?
5. Try solving the basic problems discussed above.
We have published following articles on suffix tree applications:
References:
Count Distinct Non-Negative Integer Pairs (x, y) that Satisfy the Inequality
x*x + y*y
Given a positive number n, count all distinct Non-Negative Integer pairs (x, y) that satisfy the inequality x*x
+ y*y
Examples:
Input: n = 5
Output: 6
The pairs are (0, 0), (0, 1), (1, 0), (1, 1), (2, 0), (0, 2)
Input: n = 6
Output: 8
The pairs are (0, 0), (0, 1), (1, 0), (1, 1), (2, 0), (0, 2),
(1, 2), (2, 1)

A Simple Solution is to run two loops. The outer loop goes for all possible values of x (from 0 to √n). The
inner loops picks all possible values of y for current value of x (picked by outer loop). Following is C++
implementation of simple solution.
#include <iostream>
// This function counts number of pairs (x, y) that satisfy

// the inequality x*x + y*y < n.
int countSolutions(int n)
{
int res = 0;
for (int x = 0; x*x < n; x++)
for (int y = 0; x*x + y*y < n; y++)
res++;
return res;
}

int main()
{
cout << "Total Number of distinct Non-Negative pairs is "
<< countSolutions(6) << endl;
return 0;
}

Output:

Total Number of distinct Non-Negative pairs is 8

An upper bound for time complexity of the above solution is O(n). The outer loop runs √n times. The inner
loop runs at most √n times.
Using an Efficient Solution, we can find the count in O(√n) time. The idea is to first find the count of all y
values corresponding the 0 value of x. Let count of distinct y values be yCount. We can find yCount by
running a loop and comparing yCount*yCount with n.
After we have initial yCount, we can one by one increase value of x and find the next value of yCount by
reducing yCount.
// An efficient C program to find different (x, y) pairs that

// satisfy x*x + y*y < n.
#include <iostream>
// This function counts number of pairs (x, y) that satisfy

// the inequality x*x + y*y < n.
int countSolutions(int n)
{
int x = 0, yCount, res = 0;
// Find the count of different y values for x = 0.

for (yCount = 0; yCount*yCount < n; yCount++) ;
// One by one increase value of x, and find yCount for

// current x. If yCount becomes 0, then we have reached
// maximum possible value of x.
while (yCount != 0)
{
// Add yCount (count of different possible values of y
// for current x) to result
res += yCount;
// Increment x
x++;
// Update yCount for current x. Keep reducing yCount while

// the inequality is not satisfied.
while (yCount != 0 && (x*x + (yCount-1)*(yCount-1) >= n))
yCount--;
}
return res;
}

int main()
{
cout << "Total Number of distinct Non-Negative pairs is "
<< countSolutions(6) << endl;
return 0;
}

Output:

Total Number of distinct Non-Negative pairs is 8

Time Complexity of the above solution seems more but if we take a closer look, we can see that it is O(√n).
In every step inside the inner loop, value of yCount is decremented by 1. The value yCount can decrement at
most O(√n) times as yCount is count y values for x = 0. In the outer loop, the value of x is incremented. The
value of x can also increment at most O(√n) times as the last x is for yCount equals to 1.
This article is contributed by Sachin Gupta. Please write comments if you find anything incorrect, or you
Print Nodes in Top View of Binary Tree
Top view of a binary tree is the set of nodes visible when the tree is viewed from the top. Given a binary tree,
print the top view of it. The output nodes can be printed in any order. Expected time complexity is O(n)
A node x is there in output if x is the topmost node at its horizontal distance. Horizontal distance of left child
of a node x is equal to horizontal distance of x minus 1, and that of right child is horizontal distance of x plus
1.
1
/ \
2 3
/ \ / \
4 5 6 7
Top view of the above binary tree is
4 2 1 3 7
1
/ \
2 3
\
4
\
5
\
6
Top view of the above binary tree is
2 1 3 6

The idea is to do something similar to vertical Order Traversal. Like vertical Order Traversal, we need to
nodes of same horizontal distance together. We do a level order traversal so that the topmost node at a
horizontal node is visited before any other node of same horizontal distance below it. Hashing is used to
check if a node at given horizontal distance is seen or not.
// Java program to print top view of Binary tree

import java.util.*;
// Class for a tree node

class TreeNode
{
// Members
int key;
TreeNode left, right;
// Constructor
public TreeNode(int key)
{
this.key = key;
left = right = null;
}
}
// A class to represent a queue item. The queue is used to do Level

// order traversal. Every Queue item contains node and horizontal
// order traversal. Every Queue item contains node and horizontal
// distance of node from root
class QItem
{
TreeNode node;
int hd;
public QItem(TreeNode n, int h)
{
node = n;
hd = h;
}
}
// Class for a Binary Tree

class Tree
{
TreeNode root;
// Constructors
public Tree() { root = null; }
public Tree(TreeNode n) { root = n; }
// This method prints nodes in top view of binary tree

public void printTopView()
{
// base case

// Create a queue and add root to it

Queue<QItem> Q = new LinkedList<QItem>();
Q.add(new QItem(root, 0)); // Horizontal distance of root is 0
// Standard BFS or level order traversal loop

while (!Q.isEmpty())
{
// Remove the front item and get its details
QItem qi = Q.remove();
int hd = qi.hd;
TreeNode n = qi.node;
// If this is the first node at its horizontal distance,

// then this node is in top view
if (!set.contains(hd))
{
set.add(hd);
System.out.print(n.key + " ");
}
// Enqueue left and right children of current node

if (n.left != null)
Q.add(new QItem(n.left, hd-1));
if (n.right != null)
Q.add(new QItem(n.right, hd+1));
}
}
}
// Driver class to test above methods

public class Main
{
{
{
/* Create following Binary Tree
1
/ \
2 3
\
4
\
5
\
6*/
root.left = new TreeNode(2);
root.right = new TreeNode(3);
root.left.right = new TreeNode(4);
root.left.right.right = new TreeNode(5);
root.left.right.right.right = new TreeNode(6);
Tree t = new Tree(root);
System.out.println("Following are nodes in top view of Binary Tree");
t.printTopView();
}
}

Output:

Following are nodes in top view of Binary Tree
1 2 3 6

Time Complexity of the above implementation is O(n) where n is number of nodes in given binary tree. The
assumption here is that add() and contains() methods of HashSet work in O(1) time.
This article is contributed by Rohan. Please write comments if you find anything incorrect, or you want to
Algorithm Practice Question for Beginners | Set 1
Consider the following C function.
unsigned fun(unsigned n)
{
return fun(n-1) + fun(n-1);

}

Consider the following questions for above code ignoring compiler optimization.
a) What does the above code do?
b) What is the time complexity of above code?
c) Can the time complexity of above function be reduced?
What does fun(n) do?

In the above code, fun(n) is equal to 2*fun(n-1). So the above function returns 2n. For example, for n = 3, it
returns 8, for n = 4, it returns 16.
What is the time complexity of fun(n)?

Time complexity of the above function is exponential. Let the Time complexity be T(n). T(n) can be written
as following recurrence. Here C is a machine dependent constant.
T(n) = T(n-1) + T(n-1) + C

= 2T(n-1) + C

The above recurrence has solution as Θ(2n). We can solve it by recurrence tree method. The recurrence tree
would be a binary tree with height n and every level would be completely full except possibly the last level.
C
/ \
C C
/ \ / \
C C C C
/ \ / \ / \ / \
. . . . . . . .
. . . . . . . .
Height of Tree is Θ(n)

Can the time complexity of fun(n) be reduced?

A simple way to reduce the time complexity is to make one call instead of 2 calls.

{

return 2*fun(n-1);
}

Time complexity of the above solution is Θ(n). T Let the Time complexity be T(n). T(n) can be written as
following recurrence. Here C is a machine dependent constant.
T(n) = T(n-1) + C

We can solve it by recurrence tree method. The recurrence tree would be a skewed binary tree (every internal
node has only one child) with height n.
C
/
C
/
C
/
.
.
Height of Tree is Θ(n)

The above function can be further optimized using divide and conquer technique to calculate powers.
{
unsigned x = fun(n/2);
return (n%2)? 2*x*x: x*x;
}

Time complexity of the above solution is Θ(Logn). Let the Time complexity be T(n). T(n) can be
approximately written as following recurrence. Here C is a machine dependent constant.
T(n) = T(n/2) + C

We can solve it by recurrence tree method. The recurrence tree would be a skewed binary tree (every internal
node has only one child) with height Log(n).
C
/
C
/
C
/
.
.
Height of Tree is Θ(Logn)

We can also directly compute fun(n) using bitwise left shift operator ‘ unsigned fun(unsigned n) { return 1 <<
n; }
Suffix Tree Application 1 – Substring Check
Given a text string and a pattern string, check if pattern exists in text or not.
Few pattern searching algorithms (KMP, Rabin-Karp, Naive Algorithm, Finite Automata) are already
discussed, which can be used for this check.
Here we will discuss suffix tree based algorithm.
As a prerequisite, we must know how to build a suffix tree in one or the other way.
Once we have a suffix tree built for given text, we need to traverse the tree from root to leaf against the
characters in pattern. If we do not fall off the tree (i.e. there is a path from root to leaf or somewhere in
middle) while traversal, then pattern exists in text as a substring.
Here we will build suffix tree using Ukkonen’s Algorithm, discussed already as below:
The core traversal implementation for substring check, can be modified accordingly for suffix trees built by
other algorithms.
// A C program for substring check using Ukkonen's Suffix Tree Construction

#include <stdio.h>
#include <string.h>
#include <stdlib.h>



int start;
int *end;

int suffixIndex;
};





// be added in tree
int leafEnd = -1;

{
int i;

next extension*/
node->end = end;

return node;
}

if(n == root)
return 0;
}

{
{
return 1;
}
return 0;
}

{
leafEnd = pos;

added in tree*/

lastNewNode = NULL;



{

reset.*/
{
lastNewNode = NULL;
}
}
// from activeNode
else
{
// with activeEdge
{
continue;
}
{
{
lastNewNode = NULL;
}
//APCFER3
activeLength++;
break;
}


//New internal node


reset, do it now.*/
{
}

}

{
activeLength--;
}
{
}
}
}

{
int k;
}

{

{
//Uncomment below line to print suffix tree
// print(n->start, *(n->end));
}
int leaf = 1;
int i;
{
{
//Uncomment below two lines to print suffix index
// if (leaf == 1 && n->start != -1)
// printf(" [%d]\n", n->suffixIndex);

//edges from it.
leaf = 0;
}
}
if (leaf == 1)
{
//Uncomment below line to print suffix index
//printf(" [%d]\n", n->suffixIndex);
}
}

{
if (n == NULL)
return;
int i;
{
{
}
}
free(n->end);
free(n);
}

{
int i;
*rootEnd = - 1;


}
int traverseEdge(char *str, int idx, int start, int end)

{
int k = 0;
//Traverse the edge with character by character matching
for(k=start; k<=end && str[idx] != '\0'; k++, idx++)
{
if(text[k] != str[idx])
return -1; // mo match
}
if(str[idx] == '\0')
return 1; // match
return 0; // more characters yet to match
}
int doTraversal(Node *n, char* str, int idx)

{
if(n == NULL)
{
return -1; // no match
}
int res = -1;
//If node n is not root node, then traverse edge
//from node n's parent to node n.
if(n->start != -1)
{
res = traverseEdge(str, idx, n->start, *(n->end));
if(res != 0)
return res; // match (res = 1) or no match (res = -1)
}
//Get the character index to search
idx = idx + edgeLength(n);
//If there is an edge from node n going out
//with current character str[idx], travrse that edge
if(n->children[str[idx]] != NULL)
return doTraversal(n->children[str[idx]], str, idx);
else
}
void checkForSubString(char* str)

{
int res = doTraversal(root, str, 0);
if(res == 1)
printf("Pattern <%s> is a Substring\n", str);
else
printf("Pattern <%s> is NOT a Substring\n", str);
}

{
strcpy(text, "THIS IS A TEST TEXT$");
buildSuffixTree();
checkForSubString("TEST");
checkForSubString("A");
checkForSubString(" ");
checkForSubString("IS A");
checkForSubString(" IS A ");
checkForSubString("TEST1");
checkForSubString("THIS IS GOOD");
checkForSubString("TES");
checkForSubString("TESA");
checkForSubString("ISB");

return 0;
}

Output:

Pattern <TEST> is a Substring

Pattern <A> is a Substring
Pattern < > is a Substring
Pattern <IS A> is a Substring
Pattern < IS A > is a Substring
Pattern <TEST1> is NOT a Substring
Pattern <THIS IS GOOD> is NOT a Substring
Pattern <TES> is a Substring
Pattern <TESA> is NOT a Substring
Pattern <ISB> is NOT a Substring

Ukkonen’s Suffix Tree Construction takes O(N) time and space to build suffix tree for a string of length N
and after that, traversal for substring check takes O(M) for a pattern of length M.
With slight modification in traversal algorithm discussed here, we can answer following:
1. Find all occurrences of a given pattern P present in text T.

2. How to check if a pattern is prefix of a text?
3. How to check if a pattern is suffix of a text?
We have published following more articles on suffix tree applications:
Find the closest pair from two sorted arrays
Given two sorted arrays and a number x, find the pair whose sum is closest to x and the pair has an
element from each array.
We are given two arrays ar1[0…m-1] and ar2[0..n-1] and a number x, we need to find the pair ar1[i] + ar2[j]
such that absolute value of (ar1[i] + ar2[j] – x) is minimum.
Example:
Input: ar1[] = {1, 4, 5, 7};

ar2[] = {10, 20, 30, 40};
x = 32
Output: 1 and 30
Input: ar1[] = {1, 4, 5, 7};

ar2[] = {10, 20, 30, 40};
x = 50
Output: 7 and 40

A Simple Solution is to run two loops. The outer loop considers every element of first array and inner loop
checks for the pair in second array. We keep track of minimum difference between ar1[i] + ar2[j] and x.
We can do it in O(n) time using following steps.

1) Merge given two arrays into an auxiliary array of size m+n using merge process of merge sort. While
merging keep another boolean array of size m+n to indicate whether the current element in merged array is
from ar1[] or ar2[].
2) Consider the merged array and use the linear time algorithm to find the pair with sum closest to x. One
extra thing we need to consider only those pairs which have one element from ar1[] and other from ar2[], we
use the boolean array for this purpose.
Can we do it in a single pass and O(1) extra space?

The idea is to start from left side of one array and right side of another array, and use the algorithm same as
step 2 of above approach. Following is detailed algorithm.
1) Initialize a variable diff as infinite (Diff is used to store the

difference between pair and x). We need to find the minimum diff.
2) Initialize two index variables l and r in the given sorted array.
(a) Initialize first to the leftmost index in ar1: l = 0
(b) Initialize second the rightmost index in ar2: r = n-1
3) Loop while l = 0
(a) If abs(ar1[l] + ar2[r] - sum)

// C++ program to find the pair from two sorted arays such
// that the sum of pair is closest to a given number x
#include <iostream>
#include <climits>
#include <cstdlib>
// ar1[0..m-1] and ar2[0..n-1] are two given sorted arrays

// and x is given number. This function prints the pair from
// both arrays such that the sum of the pair is closest to x.
void printClosest(int ar1[], int ar2[], int m, int n, int x)
{
// Initialize the diff between pair sum and x.
int diff = INT_MAX;
// res_l and res_r are result indexes from ar1[] and ar2[]
// respectively
int res_l, res_r;
// Start from left side of ar1[] and right side of ar2[]

int l = 0, r = n-1;
while (l<m && r>=0)
{
// If this pair is closer to x than the previously
// found closest, then update res_l, res_r and diff
if (abs(ar1[l] + ar2[r] - x) < diff)
{
res_l = l;
res_r = r;
diff = abs(ar1[l] + ar2[r] - x);
}
// If sum of this pair is more than x, move to smaller

// side
if (ar1[l] + ar2[r] > x)
r--;
else // move to the greater side
l++;
}
// Print the result

cout << "The closest pair is [" << ar1[res_l] << ", "
<< ar2[res_r] << "] \n";
}

int main()
{
int ar1[] = {1, 4, 5, 7};
int ar2[] = {10, 20, 30, 40};
int m = sizeof(ar1)/sizeof(ar1[0]);
int n = sizeof(ar2)/sizeof(ar2[0]);
int x = 38;
printClosest(ar1, ar2, m, n, x);
return 0;
}

Output:
The closest pair is [7, 30]
This article is contributed by Harsh. Please write comments if you find anything incorre
ct, or you want to share more information about the topic discussed above

Multiply two polynomials
Given two polynomials represented by two arrays, write a function that multiplies given two polynomials.
Example:
Input: A[] = {5, 0, 10, 6}

B[] = {1, 2, 4}
Output: prod[] = {5, 10, 30, 26, 52, 24}
The first input array represents "5 + 0x^1 + 10x^2 + 6x^3"

The second array represents "1 + 2x^1 + 4x^2"
And Output is "5 + 10x^1 + 30x^2 + 26x^3 + 52x^4 + 24x^5"

A simple solution is to one by one consider every term of first polynomial and multiply it with every term of
second polynomial. Following is algorithm of this simple method.
multiply(A[0..m-1], B[0..n01])
1) Create a product array prod[] of size m+n-1.
2) Initialize all entries in prod[] as 0.
3) Travers array A[] and do following for every element A[i]
...(3.a) Traverse array B[] and do following for every element B[j]
prod[i+j] = prod[i+j] + A[i] * B[j]
4) Return prod[].

The following is C++ implementation of above algorithm.
// Simple C++ program to multiply two polynomials

#include <iostream>
// A[] represents coefficients of first polynomial

// B[] represents coefficients of second polynomial
// m and n are sizes of A[] and B[] respectively
int *multiply(int A[], int B[], int m, int n)
{
int *prod = new int[m+n-1];
// Initialize the porduct polynomial

for (int i = 0; i<m+n-1; i++)
prod[i] = 0;
// Multiply two polynomials term by term
// Take ever term of first polynomial

{
// Multiply the current term of first polynomial
// with every term of second polynomial.
prod[i+j] += A[i]*B[j];
prod[i+j] += A[i]*B[j];
}
return prod;
}
// A utility function to print a polynomial

void printPoly(int poly[], int n)
{
{
cout << poly[i];
if (i != 0)
cout << "x^" << i ;
if (i != n-1)
cout << " + ";
}
}

int main()
{
// The following array represents polynomial 5 + 10x^2 + 6x^3
int A[] = {5, 0, 10, 6};
// The following array represents polynomial 1 + 2x + 4x^2

int B[] = {1, 2, 4};
int m = sizeof(A)/sizeof(A[0]);
int n = sizeof(B)/sizeof(B[0]);
cout << "First polynomial is \n";

printPoly(A, m);
cout << "\nSecond polynomial is \n";
printPoly(B, n);
int *prod = multiply(A, B, m, n);
cout << "\nProduct polynomial is \n";

printPoly(prod, m+n-1);
return 0;
}

Output
First polynomial is
5 + 0x^1 + 10x^2 + 6x^3
Second polynomial is
1 + 2x^1 + 4x^2
Product polynomial is
5 + 10x^1 + 30x^2 + 26x^3 + 52x^4 + 24x^5

Time complexity of the above solution is O(mn). If size of two polynomials same, then time complexity is
O(n2).
Can we do better?
There are methods to do multiplication faster than O(n2) time. These methods are mainly based on divide
and conquer. Following is one simple method that divides the given polynomial (of degree n) into two
polynomials one containing lower degree terms(lower than n/2) and other containing higher degree terns
(higher than or equal to n/2)
Let the two given polynomials be A and B.

For simplicity, Let us assume that the given two polynomials are of
same degree and have degree in powers of 2, i.e., n = 2i
The polynomial 'A' can be written as A0 + A1*xn/2

The polynomial 'B' can be written as B0 + B1*xn/2
For example 1 + 10x + 6x2 - 4x3 + 5x4 can be

written as (1 + 10x) + (6 - 4x + 5x2)*x 2
A * B = (A0 + A1*xn/2) * (B0 + B1*xn/2)

= A0*B0 + A0*B1*xn/2 + A1*B0*xn/2 + A1*B1*xn
= A0*B0 + (A0*B1 + A1*B0)xn/2 + A1*B1*xn

So the above divide and conquer approach requires 4 multiplications and O(n) time to add all 4 results.
Therefore the time complexity is T(n) = 4T(n/2) + O(n). The solution of the recurrence is O(n2) which is
same as the above simple solution.
The idea is to reduce number of multiplications to 3 and make the recurrence as T(n) = 3T(n/2) + O(n)
How to reduce number of multiplications?

This requires a little trick similar to Strassen’s Matrix Multiplication. We do following 3 multiplications.
X = (A0 + A1)*(B0 + B1) // First Multiplication

Y = A0B0 // Second
Z = A1B1 // Third
The missing middle term in above multiplication equation A0*B0 + (A0*B1 +

A1*B0)x n/2 + A1*B1*xn can obtained using below.
A0B1 + A1B0 = X - Y - Z

So the time taken by this algorithm is T(n) = 3T(n/2) + O(n)

The solution of above recurrence is O(nLg3) which is better than O(n2).
We will soon be discussing implementation of above approach.
There is a O(nLogn) algorithm also that uses Fast Fourier Transform to multiply two polynomials (Refer this
and this for details)
Sources:
http://www.cse.ust.hk/~dekai/271/notes/L03/L03.pdf
This article is contributed by Harsh. Please write comments if you find anything incorrect, or you want to
Perfect Binary Tree Specific Level Order Traversal
Given a Perfect Binary Tree like below:
(click on image to get a clear view)
Print the level order of nodes in following specific manner:

1 2 3 4 7 5 6 8 15 9 14 10 13 11 12 16 31 17 30 18 29 19 28 20 27 21 26 22 25 23 24

i.e. print nodes in level order but nodes should be from left and right side alternatively. Here 1st and 2nd
levels are trivial.
While 3rd level: 4(left), 7(right), 5(left), 6(right) are printed.
While 4th level: 8(left), 15(right), 9(left), 14(right), .. are printed.
While 5th level: 16(left), 31(right), 17(left), 30(right), .. are printed.
In standard Level Order Traversal, we enqueue root into a queue 1st , then we dequeue ONE node from
queue, process (print) it, enqueue its children into queue. We keep doing this until queue is empty.
Approach 1:
We can do standard level order traversal here too but instead of printing nodes directly, we have to store
nodes in current level in a temporary array or list 1st and then take nodes from alternate ends (left and right)
and print nodes. Keep repeating this for all levels.
This approach takes more memory than standard traversal.
Approach 2:
The standard level order traversal idea will slightly change here. Instead of processing ONE node at a time,
we will process TWO nodes at a time. And while pushing children into queue, the enqueue order will be: 1 st
node’s left child, 2nd node’s right child, 1st node’s right child and 2nd node’s left child.
/* C++ program for special order traversal */

#include <iostream>
#include <queue>

struct Node
struct Node
{
int data;
Node *left;
Node *right;
};

{
node->data = data;
node->right = node->left = NULL;
return node;
}
/* Given a perfect binary tree, print its nodes in specific

level order */
void printSpecificLevelOrder(Node *root)
{
if (root == NULL)
return;
// Let us print root and next level first

cout << root->data;
// / Since it is perfect Binary Tree, right is not checked

cout << " " << root->left->data << " " << root->right->data;
// Do anything more if there are nodes at next level in

// given perfect Binary Tree
if (root->left->left == NULL)
return;
// Create a queue and enqueue left and right children of root

queue <Node *> q;
q.push(root->left);
q.push(root->right);
// We process two nodes at a time, so we need two variables

// to store two front items of queue
Node *first = NULL, *second = NULL;
// traversal loop
while (!q.empty())
{
// Pop two items from queue
first = q.front();
q.pop();
second = q.front();
q.pop();
// Print children of first and second in reverse order

cout << " " << first->left->data << " " << second->right->data;
cout << " " << first->right->data << " " << second->left->data;
// If first and second have grandchildren, enqueue them

// in reverse order
if (first->left->left != NULL)
{
q.push(first->left);
q.push(second->right);
q.push(first->right);
q.push(first->right);
q.push(second->left);
}
}
}

int main()
{
//Perfect Binary Tree of Height 4
root->left->left->left->right = newNode(17);
root->left->right->left->left = newNode(20);
root->left->right->left->right = newNode(21);
root->left->right->right->left = newNode(22);
root->left->right->right->right = newNode(23);
root->right->left->left->left = newNode(24);
root->right->left->left->right = newNode(25);
root->right->left->right->right = newNode(27);
root->right->right->left->left = newNode(28);
root->right->right->right->left = newNode(30);
cout << "Specific Level Order traversal of binary tree is \n";

printSpecificLevelOrder(root);
return 0;
}

Output:

Specific Level Order traversal of binary tree is
1 2 3 4 7 5 6 8 15 9 14 10 13 11 12 16 31 17 30 18 29 19 28 20 27 21 26 22 25 23 24
Followup Questions:
1. The above code prints specific level order from TOP to BOTTOM. How will you do specific level order
traversal from BOTTOM to TOP (Amazon Interview | Set 120 – Round 1 Last Problem)
2. What if tree is not perfect, but complete.
3. What if tree is neither perfect, nor complete. It can be any general binary tree.
Suffix Tree Application 2 – Searching All Patterns
Given a text string and a pattern string, find all occurrences of the pattern in string.
Few pattern searching algorithms (KMP, Rabin-Karp, Naive Algorithm, Finite Automata) are already
discussed, which can be used for this check.
Here we will discuss suffix tree based algorithm.
In the 1st Suffix Tree Application (Substring Check), we saw how to check whether a given pattern is
substring of a text or not. It is advised to go through Substring Check 1st .
In this article, we will go a bit further on same problem. If a pattern is substring of a text, then we will find all
the positions on pattern in the text.
Lets look at following figure:
This is suffix tree for String “abcabxabcd$”, showing suffix indices and edge label indices (start, end). The
(sub)string value on edges are shown only for explanatory purpose. We never store path label string in the
tree.
Suffix Index of a path tells the index of a substring (starting from root) on that path.
Consider a path “bcd$” in above tree with suffix index 7. It tells that substrings b, bc, bcd, bcd$ are at index 7
in string.
Similarly path “bxabcd$” with suffix index 4 tells that substrings b, bx, bxa, bxab, bxabc, bxabcd, bxabcd$
are at index 4.
Similarly path “bcabxabcd$” with suffix index 1 tells that substrings b, bc, bca, bcab, bcabx, bcabxa, bcabxab,
bcabxabc, bcabxabcd, bcabxabcd$ are at index 1.
If we see all the above three paths together, we can see that:
Substring “b” is at indices 1, 4 and 7
Substring “bc” is at indices 1 and 7
With above explanation, we should be able to see following:
Substring “ab” is at indices 0, 3 and 6

Substring “abc” is at indices 0 and 6
Substring “c” is at indices 2 and 8
Substring “xab” is at index 5
Substring “d” is at index 9
Substring “cd” is at index 8
…..
…..
Can you see how to find all the occurrences of a pattern in a string ?
1. 1st of all, check if the given pattern really exists in string or not (As we did in
Substring Check). For
this, traverse the suffix tree against the pattern.
2. If you find pattern in suffix tree (don’t fall off the tree), then traverse the subtree below that point and
find all suffix indices on leaf nodes. All those suffix indices will be pattern indices in string

// And find all locations of a pattern in string
#include <stdio.h>
#include <string.h>
#include <stdlib.h>



int start;
int *end;

int suffixIndex;
};





// be added in tree
int leafEnd = -1;

{
int i;

next extension*/
node->end = end;

return node;
}

if(n == root)
return 0;
}

{
{
return 1;
}
return 0;
}

{
leafEnd = pos;

added in tree*/

lastNewNode = NULL;



{

reset.*/
{
lastNewNode = NULL;
lastNewNode = NULL;
}
}
// from activeNode
else
{
// with activeEdge
{
continue;
}
{
{
lastNewNode = NULL;
}
//APCFER3
activeLength++;
break;
}


//New internal node


reset, do it now.*/
{
}

}

{
activeLength--;
}
{
}
}
}

{
int k;
}

{

{
}
int leaf = 1;
int i;
{
{
// if (leaf == 1 && n->start != -1)

//edges from it.
leaf = 0;
}
}
if (leaf == 1)
if (leaf == 1)
{
}
}

{
if (n == NULL)
return;
int i;
{
{
}
}
free(n->end);
free(n);
}

{
int i;
*rootEnd = - 1;


}
int traverseEdge(char *str, int idx, int start, int end)

{
int k = 0;
//Traverse the edge with character by character matching
for(k=start; k<=end && str[idx] != '\0'; k++, idx++)
{
if(text[k] != str[idx])
return -1; // mo match
}
if(str[idx] == '\0')
return 1; // match
return 0; // more characters yet to match
}
int doTraversalToCountLeaf(Node *n)

{
if(n == NULL)
return 0;
if(n->suffixIndex > -1)
{
printf("\nFound at position: %d", n->suffixIndex);
return 1;
}
int count = 0;
int i = 0;
{
if(n->children[i] != NULL)
{
count += doTraversalToCountLeaf(n->children[i]);
}
}
return count;
}
int countLeaf(Node *n)

{
if(n == NULL)
return 0;
return doTraversalToCountLeaf(n);
}
int doTraversal(Node *n, char* str, int idx)

{
if(n == NULL)
{
}
int res = -1;
//If node n is not root node, then traverse edge
//from node n's parent to node n.
if(n->start != -1)
{
if(res == -1) //no match
return -1;
if(res == 1) //match
{
printf("\nsubstring count: 1 and position: %d",
n->suffixIndex);
else
printf("\nsubstring count: %d", countLeaf(n));
return 1;
}
}
//Get the character index to search
idx = idx + edgeLength(n);
//If there is an edge from node n going out
//with current character str[idx], travrse that edge
if(n->children[str[idx]] != NULL)
return doTraversal(n->children[str[idx]], str, idx);
else
}
void checkForSubString(char* str)

{
int res = doTraversal(root, str, 0);
if(res == 1)
printf("\nPattern <%s> is a Substring\n", str);
else
printf("\nPattern <%s> is NOT a Substring\n", str);
printf("\nPattern <%s> is NOT a Substring\n", str);
}

{
strcpy(text, "GEEKSFORGEEKS$");
buildSuffixTree();
printf("Text: GEEKSFORGEEKS, Pattern to search: GEEKS");
checkForSubString("GEEKS");
printf("\n\nText: GEEKSFORGEEKS, Pattern to search: GEEK1");
checkForSubString("GEEK1");
printf("\n\nText: GEEKSFORGEEKS, Pattern to search: FOR");
checkForSubString("FOR");
strcpy(text, "AABAACAADAABAAABAA$");
buildSuffixTree();
printf("\n\nText: AABAACAADAABAAABAA, Pattern to search: AABA");
checkForSubString("AABA");
printf("\n\nText: AABAACAADAABAAABAA, Pattern to search: AA");
checkForSubString("AA");
printf("\n\nText: AABAACAADAABAAABAA, Pattern to search: AAE");
checkForSubString("AAE");
strcpy(text, "AAAAAAAAA$");
buildSuffixTree();
printf("\n\nText: AAAAAAAAA, Pattern to search: AAAA");
checkForSubString("AAAA");
printf("\n\nText: AAAAAAAAA, Pattern to search: AA");
checkForSubString("AA");
printf("\n\nText: AAAAAAAAA, Pattern to search: A");
checkForSubString("A");
printf("\n\nText: AAAAAAAAA, Pattern to search: AB");
checkForSubString("AB");
return 0;
}

Output:
Text: GEEKSFORGEEKS, Pattern to search: GEEKS

Found at position: 8
substring count: 2
Pattern <GEEKS> is a Substring
Text: GEEKSFORGEEKS, Pattern to search: GEEK1

Pattern <GEEK1> is NOT a Substring
Text: GEEKSFORGEEKS, Pattern to search: FOR

substring count: 1 and position: 5
Pattern <FOR> is a Substring
Pattern <FOR> is a Substring
Text: AABAACAADAABAAABAA, Pattern to search: AABA

substring count: 3
Pattern <AABA> is a Substring
Text: AABAACAADAABAAABAA, Pattern to search: AA

substring count: 7
Pattern <AA> is a Substring
Text: AABAACAADAABAAABAA, Pattern to search: AAE

Pattern <AAE> is NOT a Substring
Text: AAAAAAAAA, Pattern to search: AAAA

substring count: 6
Pattern <AAAA> is a Substring
Text: AAAAAAAAA, Pattern to search: AA

substring count: 8
Pattern <AA> is a Substring
Text: AAAAAAAAA, Pattern to search: A

substring count: 9
Pattern <A> is a Substring
Text: AAAAAAAAA, Pattern to search: AB
Pattern <AB> is NOT a Substring

and after that, traversal for substring check takes O(M) for a pattern of length M and then if there are Z
occurrences of the pattern, it will take O(Z) to find indices of all those Z occurrences.
Overall pattern complexity is linear: O(M + Z).
A bit more detailed analysis

How many internal nodes will there in a suffix tree of string of length N ??
Answer: N-1 (Why ??)
There will be N suffixes in a string of length N.
Each suffix will have one leaf.
So a suffix tree of string of length N will have N leaves.
As each internal node has at least 2 children, an N-leaf suffix tree has at most N-1 internal nodes.
If a pattern occurs Z times in string, means it will be part of Z suffixes, so there will be Z leaves below in
point (internal node and in between edge) where pattern match ends in tree and so subtree with Z leaves
below that point will have Z-1 internal nodes. A tree with Z leaves can be traversed in O(Z) time.
Overall pattern complexity is linear: O(M + Z).
For a given pattern, Z (the number of occurrences) can be atmost N.
So worst case complexity can be: O(M + N) if Z is close/equal to N (A tree traversal with N nodes take O(N)
time).
Followup questions:
1. Check if a pattern is prefix of a text?

2. Check if a pattern is suffix of a text?
Suffix Tree Application 3 – Longest Repeated Substring
Given a text string, find Longest Repeated Substring in the text. If there are more than one Longest Repeated
Substrings, get any one of them.
Longest Repeated Substring in GEEKSFORGEEKS is: GEEKS

Longest Repeated Substring in AAAAAAAAAA is: AAAAAAAAA
Longest Repeated Substring in ABCDEFG is: No repeated substring
Longest Repeated Substring in ABABABA is: ABABA
Longest Repeated Substring in ATCGATCGA is: ATCGA
Longest Repeated Substring in banana is: ana
Longest Repeated Substring in abcpqrabpqpq is: ab (pq is another LRS here)

This problem can be solved by different approaches with varying time and space complexities. Here we will
discuss Suffix Tree approach (3rd Suffix Tree Application). Other approaches will be discussed soon.
This is suffix tree for string “ABABABA$”.

In this string, following substrings are repeated:
A, B, AB, BA, ABA, BAB, ABAB, BABA, ABABA
And Longest Repeated Substring is ABABA.
In a suffix tree, one node can’t have more than one outgoing edge starting with same character, and so if
there are repeated substring in the text, they will share on same path and that path in suffix tree will go
through one or more internal node(s) down the tree (below the point where substring ends on that path).
In above figure, we can see that
Path with Substring “A” has three internal nodes down the tree
Path with Substring “AB” has two internal nodes down the tree
Path with Substring “ABA” has two internal nodes down the tree
Path with Substring “ABAB” has one internal node down the tree
Path with Substring “ABABA” has one internal node down the tree
Path with Substring “B” has two internal nodes down the tree
Path with Substring “BA” has two internal nodes down the tree
Path with Substring “BAB” has one internal node down the tree
Path with Substring “BABA” has one internal node down the tree
All above substrings are repeated.
Substrings ABABAB, ABABABA, BABAB, BABABA have no internal node down the tree (after the point
where substring end on the path), and so these are not repeated.
Can you see how to find longest repeated substring ??

We can see in figure that, longest repeated substring will end at the internal node which is farthest from the
root (i.e. deepest node in the tree), because length of substring is the path label length from root to that
internal node.
So finding longest repeated substring boils down to finding the deepest node in suffix tree and then get the
path label from root to that deepest internal node.

// And then find Longest Repeated Substring
#include <stdio.h>
#include <string.h>
#include <stdlib.h>



int start;
int *end;

int suffixIndex;
};





// be added in tree
int leafEnd = -1;

{
int i;

next extension*/
node->end = end;

return node;
}

if(n == root)
return 0;
}

{
{
return 1;
}
return 0;
}

{
leafEnd = pos;

added in tree*/

lastNewNode = NULL;



{

reset.*/
{
lastNewNode = NULL;
}
}
// from activeNode
else
{
// with activeEdge
{
continue;
}
{
{
lastNewNode = NULL;
}
//APCFER3
activeLength++;
break;
}


//New internal node


reset, do it now.*/
{
}

}

{
activeLength--;
activeLength--;
}
{
}
}
}

{
int k;
}

{

{
}
int leaf = 1;
int i;
{
{
// if (leaf == 1 && n->start != -1)

//edges from it.
leaf = 0;
}
}
if (leaf == 1)
{
}
}

{
if (n == NULL)
return;
int i;
{
{
}
}
free(n->end);
free(n);
}

{
int i;
*rootEnd = - 1;


}
void doTraversal(Node *n, int labelHeight, int* maxHeight,

int* substringStartIndex)
{
if(n == NULL)
{
return;
}
int i=0;
if(n->suffixIndex == -1) //If it is internal node
{
{
{
doTraversal(n->children[i], labelHeight +
edgeLength(n->children[i]), maxHeight,
substringStartIndex);
}
}
}
else if(n->suffixIndex > -1 &&
(*maxHeight < labelHeight - edgeLength(n)))
{
*maxHeight = labelHeight - edgeLength(n);
*substringStartIndex = n->suffixIndex;
}
}
void getLongestRepeatedSubstring()
{
int maxHeight = 0;
int substringStartIndex = 0;
doTraversal(root, 0, &maxHeight, &substringStartIndex);
// printf("maxHeight %d, substringStartIndex %d\n", maxHeight,
// substringStartIndex);
printf("Longest Repeated Substring in %s is: ", text);
printf("Longest Repeated Substring in %s is: ", text);
int k;
for (k=0; k<maxHeight; k++)
printf("%c", text[k + substringStartIndex]);
if(k == 0)
printf("No repeated substring");
printf("\n");
}

{
buildSuffixTree();
getLongestRepeatedSubstring();
strcpy(text, "AAAAAAAAAA$");
buildSuffixTree();
strcpy(text, "ABCDEFG$");
buildSuffixTree();
strcpy(text, "ABABABA$");
buildSuffixTree();
strcpy(text, "ATCGATCGA$");
buildSuffixTree();
strcpy(text, "banana$");
buildSuffixTree();
strcpy(text, "abcpqrabpqpq$");
buildSuffixTree();
strcpy(text, "pqrpqpqabab$");
buildSuffixTree();
return 0;
}

Output:
Longest Repeated Substring in GEEKSFORGEEKS$ is: GEEKS

Longest Repeated Substring in AAAAAAAAAA$ is: AAAAAAAAA
Longest Repeated Substring in ABCDEFG$ is: No repeated substring
Longest Repeated Substring in ABABABA$ is: ABABA
Longest Repeated Substring in ATCGATCGA$ is: ATCGA
Longest Repeated Substring in banana$ is: ana
Longest Repeated Substring in abcpqrabpqpq$ is: ab
Longest Repeated Substring in pqrpqpqabab$ is: ab

st
In case of multiple LRS (As we see in last two test cases), this implementation prints the LRS which comes 1
lexicographically.
and after that finding deepest node will take O(N).
So it is linear in time and space.
Followup questions:
1. Find all repeated substrings in given text

2. Find all unique substrings in given text
3. Find all repeated substrings of a given length
4. Find all unique substrings of a given length
5. In case of multiple LRS in text, find the one which occurs most number of times
All these problems can be solved in linear time with few changes in above implementation.
Suffix Tree Application 4 – Build Linear Time Suffix Array
Given a string, build it’s Suffix Array
We have already discussed following two ways of building suffix array:
Please go through these to have the basic understanding.

Here we will see how to build suffix array in linear time using suffix tree.
Lets consider string abcabxabcd.

It’s suffix array would be:

0 6 3 1 7 4 2 8 9 5

This is suffix tree for String “abcabxabcd$”

If we do a DFS traversal, visiting edges in lexicographic order (we have been doing the same traversal in
other Suffix Tree Application articles as well) and print suffix indices on leaves, we will get following:

10 0 6 3 1 7 4 2 8 9 5

“$” is lexicographically lesser than [a-zA-Z].

The suffix index 10 corresponds to edge with “$” label.
Except this 1st suffix index, the sequence of all other numbers gives the suffix array of the string.
So if we have a suffix tree of the string, then to get it’s suffix array, we just need to do a lexicographic order
DFS traversal and store all the suffix indices in resultant suffix array, except the very 1st suffix index.

// And and then create suffix array in linear time
#include <stdio.h>
#include <string.h>
#include <stdlib.h>



int start;
int *end;

int suffixIndex;
};





// be added in tree
int leafEnd = -1;

{
int i;

next extension*/
node->end = end;

return node;
}

if(n == root)
return 0;
}

{
{
return 1;
}
return 0;
}

{
leafEnd = pos;

added in tree*/

lastNewNode = NULL;



{

reset.*/
{
lastNewNode = NULL;
}
}
// from activeNode
else
{
// with activeEdge
{
continue;
}
{
{
lastNewNode = NULL;
}
//APCFER3
activeLength++;
break;
}


//New internal node


reset, do it now.*/
{
}

}

{
activeLength--;
}
{
}
}
}

{
int k;
}

{

{
}
int leaf = 1;
int i;
{
{
// if (leaf == 1 && n->start != -1)

//edges from it.
leaf = 0;
}
}
if (leaf == 1)
{
}
}

{
if (n == NULL)
return;
int i;
{
{
}
}
free(n->end);
free(n);
}

{
int i;
*rootEnd = - 1;


}
void doTraversal(Node *n, int suffixArray[], int *idx)

{
if(n == NULL)
{
return;
}
int i=0;
if(n->suffixIndex == -1) //If it is internal node
{
{
{
doTraversal(n->children[i], suffixArray, idx);
}
}
}
//If it is Leaf node other than "$" label
else if(n->suffixIndex > -1 && n->suffixIndex < size)
{
suffixArray[(*idx)++] = n->suffixIndex;
}
}
void buildSuffixArray(int suffixArray[])

{
int i = 0;
for(i=0; i< size; i++)
suffixArray[i] = -1;
int idx = 0;
doTraversal(root, suffixArray, &idx);
printf("Suffix Array for String ");
printf("%c", text[i]);
printf(" is: ");
printf("%d ", suffixArray[i]);
printf("\n");
}

{
strcpy(text, "banana$");
buildSuffixTree();
size--;
int *suffixArray =(int*) malloc(sizeof(int) * size);
buildSuffixArray(suffixArray);
free(suffixArray);
buildSuffixTree();
size--;
suffixArray =(int*) malloc(sizeof(int) * size);
free(suffixArray);
free(suffixArray);
strcpy(text, "AAAAAAAAAA$");
buildSuffixTree();
size--;
free(suffixArray);
strcpy(text, "ABCDEFG$");
buildSuffixTree();
size--;
free(suffixArray);
strcpy(text, "ABABABA$");
buildSuffixTree();
size--;
free(suffixArray);
strcpy(text, "abcabxabcd$");
buildSuffixTree();
size--;
free(suffixArray);
strcpy(text, "CCAAACCCGATTA$");
buildSuffixTree();
size--;
free(suffixArray);
return 0;
}

Output:

Suffix Array for String banana is: 5 3 1 0 4 2

Suffix Array for String GEEKSFORGEEKS is: 9 1 10 2 5 8 0 11 3 6 7 12 4
Suffix Array for String AAAAAAAAAA is: 9 8 7 6 5 4 3 2 1 0
Suffix Array for String ABCDEFG is: 0 1 2 3 4 5 6
Suffix Array for String ABABABA is: 6 4 2 0 5 3 1
Suffix Array for String abcabxabcd is: 0 6 3 1 7 4 2 8 9 5
Suffix Array for String CCAAACCCGATTA is: 12 2 3 4 9 1 0 5 6 7 8 11 10

and after that, traversal of tree take O(N) to build suffix array.
So overall, it’s linear in time and space.
Can you see why traversal is O(N) ?? Because a suffix tree of string of length N will have at most N-1 internal
nodes and N leaves. Traversal of these nodes can be done in O(N).
Minimum Number of Platforms Required for a Railway/Bus Station
Given arrival and departure times of all trains that reach a railway station, find the minimum number of
platforms required for the railway station so that no train waits.
We are given two arrays which represent arrival and departure times of trains that stop
Examples:
Input: arr[] = {9:00, 9:40, 9:50, 11:00, 15:00, 18:00}

dep[] = {9:10, 12:00, 11:20, 11:30, 19:00, 20:00}
Output: 3
There are at-most three trains at a time (time between 11:00 to 11:20)

We need to find the maximum number of trains that are there on the given railway station at a time. A
Simple Solution is to take every interval one by one and find the number of intervals that overlap with it.
Keep track of maximum number of intervals that overlap with an interval. Finally return the maximum
value. Time Complexity of this solution is O(n2).
We can solve the above problem in O(nLogn) time . The idea is to consider all evens in sorted order. Once
we have all events in sorted order, we can trace the number of trains at any time keeping track of trains that
have arrived, but not departed.
For example consider the above example.
arr[] = {9:00, 9:40, 9:50, 11:00, 15:00, 18:00}

dep[] = {9:10, 12:00, 11:20, 11:30, 19:00, 20:00}
All events sorted by time.

Total platforms at any time can be obtained by subtracting total
departures from total arrivals by that time.
Time Event Type Total Platforms Needed at this Time
9:00 Arrival 1
9:10 Departure 0
9:40 Arrival 1
9:50 Arrival 2
11:00 Arrival 3
11:20 Departure 2
11:30 Departure 1
12:00 Departure 0
15:00 Arrival 1
18:00 Arrival 2
19:00 Departure 1
20:00 Departure 0
Minimum Platforms needed on railway station = Maximum platforms

needed at any time
= 3

Following is C++ implementation of above approach. Note that the implementation doesn’t create a single
sorted list of all events, rather it individually sorts arr[] and dep[] arrays, and then uses merge process of
merge sort to process them together as a single sorted array.
// Program to find minimum number of platforms required on a railway station

#include<iostream>
#include<algorithm>
// Returns minimum number of platforms reqquired

int findPlatform(int arr[], int dep[], int n)
{
// Sort arrival and departure arrays
sort(arr, arr+n);
sort(dep, dep+n);
// plat_needed indicates number of platforms needed at a time

int plat_needed = 1, result = 1;
int i = 1, j = 0;
// Similar to merge in merge sort to process all events in sorted order

while (i < n && j < n)
{
// If next event in sorted order is arrival, increment count of
// platforms needed
if (arr[i] < dep[j])
{
plat_needed++;
i++;
if (plat_needed > result) // Update result if needed
result = plat_needed;
}
else // Else decrement count of platforms needed
{
plat_needed--;
j++;
}
}
return result;
}

int main()
{
int arr[] = {900, 940, 950, 1100, 1500, 1800};
int dep[] = {910, 1200, 1120, 1130, 1900, 2000};
cout << "Minimum Number of Platforms Required = "
<< findPlatform(arr, dep, n);
return 0;
}

Output:

Minimum Number of Platforms Required = 3


Time Complexity: O(nLogn), assuming that a O(nLogn) sorting algorithm for sorting arr[] and dep[].
Vertex Cover Problem | Set 1 (Introduction and Approximate Algorithm)
A vertex cover of an undirected graph is a subset of its vertices such that for every edge (u, v) of the graph,
either ‘u’ or ‘v’ is in vertex cover. Although the name is Vertex Cover, the set covers all edges of the given
graph. Given an undirected graph, the vertex cover problem is to find minimum size vertex
cover.
Following are some examples.
Vertex Cover Problem is a known NP Complete problem, i.e., there is no polynomial time solution for this
unless P = NP. There are approximate polynomial time algorithms to solve the problem though. Following is
a simple approximate algorithm adapted from CLRS book.
Approximate Algorithm for Vertex Cover:
1) Initialize the result as {}

2) Consider a set of all edges in given graph. Let the set be E.
3) Do following while E is not empty
...a) Pick an arbitrary edge (u, v) from set E and add 'u' and 'v' to result
...b) Remove all edges from E which are either incident on u or v.
4) Return result

Following diagram taken from CLRS book shows execution of above approximate algorithm.
How well the above algorithm perform?
It can be proved that the above approximate algorithm never finds a vertex cover whose size is more than
twice the size of minimum possible vertex cover (Refer this for proof)
Implementation:
Following is C++ implementation of above approximate algorithm.
// Program to print Vertex Cover of a given undirected graph

#include<iostream>
#include <list>
// This class represents a undirected graph using adjacency list

class Graph
{
public:
void printVertexCover(); // prints vertex cover
};
Graph::Graph(int V)
{
this->V = V;
}

{
adj[w].push_back(v); // Since the graph is undirected
}
// The function to print vertex cover

void Graph::printVertexCover()
{
{
// Initialize all vertices as not visited.
bool visited[V];
for (int i=0; i<V; i++)
visited[i] = false;
// Consider all edges one by one

for (int u=0; u<V; u++)
{
// An edge is only picked when both visited[u] and visited[v]
// are false
if (visited[u] == false)
{
// Go through all adjacents of u and pick the first not
// yet visited vertex (We are basically picking an edge
// (u, v) from remaining edges.
for (i= adj[u].begin(); i != adj[u].end(); ++i)
{
int v = *i;
if (visited[v] == false)
{
// Add the vertices (u, v) to the result set.
// We make the vertex u and v visited so that
// all edges from/to them would be ignored
visited[v] = true;
visited[u] = true;
break;
}
}
}
}
// Print the vertex cover

if (visited[i])
cout << i << " ";
}

int main()
{
Graph g(7);
g.addEdge(0, 1);
g.addEdge(0, 2);
g.addEdge(1, 3);
g.addEdge(3, 4);
g.addEdge(4, 5);
g.addEdge(5, 6);
g.printVertexCover();
return 0;
}

Output:

0 1 3 4 5 6

Time Complexity of above algorithm is O(V + E).
Exact Algorithms:
Although the problem is NP complete, it can be solved in polynomial time for following types of graphs.
1) Bipartite Graph
2) Tree Graph
The problem to check whether there is a vertex cover of size smaller than or equal to a given number k can
also be solved in polynomial time if k is bounded by O(LogV) (Refer this)
We will soon be discussing exact algorithms for vertex cover.
This article is contributed by Shubham. Please write comments if you find anything incorrect, or you want
Generalized Suffix Tree 1
In earlier suffix tree articles, we created suffix tree for one string and then we queried that tree for
substring
check, searching all patterns, longest repeated substring and built suffix array (All linear time operations).
There are lots of other problems where multiple strings are involved.
e.g. pattern searching in a text file or dictionary, spell checker, phone book, Autocomplete, Longest common
substring problem, Longest palindromic substring and More.
For such operations, all the involved strings need to be indexed for faster search and retrieval. One way to do
this is using suffix trie or suffix tree. We will discuss suffix tree here.
A suffix tree made of a set of strings is known as Generalized Suffix Tree.
We will discuss a simple way to build Generalized Suffix Tree here for two strings only.
Later, we will discuss another approach to build Generalized Suffix Tree for two or more strings .
Here we will use the suffix tree implementation for one string discussed already and modify that a bit to
build generalized suffix tree.
Lets consider two strings X and Y for which we want to build generalized suffix tree. For this we will make a
new string X#Y$ where # and $ both are terminal symbols (must be unique). Then we will build suffix tree
for X#Y$ which will be the generalized suffix tree for X and Y. Same logic will apply for more than two
strings (i.e. concatenate all strings using unique terminal symbols and then build suffix tree for concatenated
string).
Lets say X = xabxa, and Y = babxba, then

X#Y$ = xabxa#babxba$
If we run the code implemented at Ukkonen’s Suffix Tree Construction – Part 6 for string xabxa#babxba$,
we get following output:

(Click to see it clearly)

We can use this tree to solve some of the problems, but we can refine it a bit by removing unwanted
substrings on a path label. A path label should have substring from only one input string, so if there are path
labels having substrings from multiple input strings, we can keep only the initial portion corresponding to
one string and remove all the later portion. For example, for path labels #babxba$, a#babxba$ and
bxa#babxba$, we can remove babxba$ (belongs to 2 nd input string) and then new path labels will be #, a#
and bxa# respectively. With this change, above diagram will look like below:


Below implementation is built on top of original implementation. Here we are removing unwanted
characters on path labels. If a path label has “#” character in it, then we are trimming all characters after the
“#” in that path label.
Note: This implementation builds generalized suffix tree for only two strings X and Y which
are concatenated as X#Y$

// And then build generalized suffix tree
#include <stdio.h>
#include <string.h>
#include <stdlib.h>



int start;
int *end;

int suffixIndex;
};





// be added in tree
int leafEnd = -1;

{
int i;

next extension*/
node->end = end;

return node;
}

if(n == root)
return 0;
}

{
{
return 1;
}
return 0;
}

{
leafEnd = pos;

added in tree*/

lastNewNode = NULL;



{

reset.*/
{
lastNewNode = NULL;
}
}
// from activeNode
else
{
// with activeEdge
{
continue;
}
{
{
lastNewNode = NULL;
}
}
//APCFER3
activeLength++;
break;
}


//New internal node


reset, do it now.*/
{
}

}

{
activeLength--;
}
{
}
}
}

{
int k;
for (k=i; k<=j && text[k] != '#'; k++)
if(k<=j)
printf("#");
}

{

{
print(n->start, *(n->end));
}
int leaf = 1;
int i;
{
{
if (leaf == 1 && n->start != -1)

//edges from it.
leaf = 0;
}
}
if (leaf == 1)
{
for(i= n->start; i<= *(n->end); i++)
{
if(text[i] == '#') //Trim unwanted characters
{
n->end = (int*) malloc(sizeof(int));
*(n->end) = i;
}
}
}
}

{
if (n == NULL)
return;
int i;
{
{
}
}
}
free(n->end);
free(n);
}

{
int i;
*rootEnd = - 1;



}

{
// strcpy(text, "xabxac#abcabxabcd$"); buildSuffixTree();
strcpy(text, "xabxa#babxba$"); buildSuffixTree();
return 0;
}

Output: (You can see that below output corresponds to the 2nd Figure shown above)

# [5]
$ [12]
a [-1]
# [4]
$ [11]
bx [-1]
a# [1]
ba$ [7]
b [-1]
a [-1]
$ [10]
bxba$ [6]
x [-1]
a# [2]
ba$ [8]
x [-1]
a [-1]
# [3]
bxa# [0]
ba$ [9]

If two strings are of size M and N, this implementation will take O(M+N) time and space.
If input strings are not concatenated already, then it will take 2(M+N) space in total, M+N space to store the
generalized suffix tree and another M+N space to store concatenated string.
Followup:
Extend above implementation for more than two strings (i.e. concatenate all strings using unique terminal
symbols and then build suffix tree for concatenated string)
One problem with this approach is the need of unique terminal symbol for each input string. This will work
for few strings but if there is too many input strings, we may not be able to find that many unique terminal
symbols.
We will discuss another approach to build generalized suffix tree soon where we will need only one unique
terminal symbol and that will resolve the above problem and can be used to build generalized suffix tree for
any number of input strings.
Job Sequencing Problem | Set 1 (Greedy Algorithm)
Given an array of jobs where every job has a deadline and associated profit if the job is finished before the
deadline. It is also given that every job takes single unit of time, so the minimum possible deadline for any
job is 1. How to maximize total profit if only one job can be scheduled at a time.
Examples:
Input: Four Jobs with following deadlines and profits

JobID Deadline Profit
a 4 20
b 1 10
c 1 40
d 1 30
Output: Following is maximum profit sequence of jobs
c, a
Input: Five Jobs with following deadlines and profits

JobID Deadline Profit
a 2 100
b 1 19
c 2 27
d 1 25
e 3 15
Output: Following is maximum profit sequence of jobs
c, a, e

A Simple Solution is to generate all subsets of given set of jobs and check individual subset for feasibility
of jobs in that subset. Keep track of maximum profit among all feasible subsets. The time complexity of this
solution is exponential.
This is a standard Greedy Algorithm problem. Following is algorithm.
1) Sort all jobs in decreasing order of profit.

2) Initialize the result sequence as first job in sorted jobs.
3) Do following for remaining n-1 jobs
.......a) If the current job can fit in the current result sequence
without missing the deadline, add current job to the result.
Else ignore the current job.

The Following is C++ implementation of above algorithm.
// Program to find the maximum profit job sequence from a given array
// of jobs with deadlines and profits
#include<iostream>
#include<algorithm>
// A structure to represent a job

// A structure to represent a job
struct Job
{
char id; // Job Id
int dead; // Deadline of job
int profit; // Profit if job is over before or on deadline
};
// This function is used for sorting all jobs according to profit

bool comparison(Job a, Job b)
{
return (a.profit > b.profit);
}
// Returns minimum number of platforms reqquired

void printJobScheduling(Job arr[], int n)
{
// Sort all jobs according to decreasing order of prfit
sort(arr, arr+n, comparison);
int result[n]; // To store result (Sequence of jobs)

bool slot[n]; // To keep track of free time slots
// Initialize all slots to be free

slot[i] = false;
// Iterate through all given jobs

{
// Find a free slot for this job (Note that we start
// from the last possible slot)
for (int j=min(n, arr[i].dead)-1; j>=0; j--)
{
// Free slot found
if (slot[j]==false)
{
result[j] = i; // Add this job to result
slot[j] = true; // Make this slot occupied
break;
}
}
}
// Print the result

if (slot[i])
cout << arr[result[i]].id << " ";
}
// Driver program to test methods

int main()
{
Job arr[5] = { {'a', 2, 100}, {'b', 1, 19}, {'c', 2, 27},
{'d', 1, 25}, {'e', 3, 15}};
cout << "Following is maximum profit sequence of jobs\n";
printJobScheduling(arr, n);
return 0;
}

Output:

Following is maximum profit sequence of jobs
c a e

Time Complexity of the above solution is O(n2). It can be optimized to almost O(n) by using union-find
data structure. We will son be discussing the optimized solution.
Sources:
http://ocw.mit.edu/courses/civil-and-environmental-engineering/1-204-computer-algorithms-in-systems-
engineering-spring-2010/lecture-notes/MIT1_204S10_lec10.pdf
Suffix Tree Application 5 – Longest Common Substring
Given two strings X and Y, find the Longest Common Substring of X and Y.
Naive [O(N*M2)] and Dynamic Programming [O(N*M)] approaches are already discussed here.
In this article, we will discuss a linear time approach to find LCS using suffix tree (The 5 th Suffix Tree
Application).
Here we will build generalized suffix tree for two strings X and Y as discussed already at:
Generalized Suffix Tree 1
Lets take same example (X = xabxa, and Y = babxba) we saw in Generalized Suffix Tree 1.
We built following suffix tree for X and Y there:


This is generalized suffix tree for xabxa#babxba$

In above, leaves with suffix indices in [0,4] are suffixes of string xabxa and leaves with suffix indices in [6,11]
are suffixes of string babxa. Why ??
Because in concatenated string xabxa#babxba$, index of string xabxa is 0 and it’s length is 5, so indices of
it’s suffixes would be 0, 1, 2, 3 and 4. Similarly index of string babxba is 6 and it’s length is 6, so indices of
it’s suffixes would be 6, 7, 8, 9, 10 and 11.
With this, we can see that in the generalized suffix tree figure above, there are some internal nodes having
leaves below it from
both strings X and Y (i.e. there is at least one leaf with suffix index in [0,4] and one leaf with suffix
index in [6, 11]
string X only (i.e. all leaf nodes have suffix indices in [0,4])
string Y only (i.e. all leaf nodes have suffix indices in [6,11])
Following figure shows the internal nodes marked as “XY”, “X” or “Y” depending on which string the leaves
belong to, that they have below themselves.


What these “XY”, “X” or “Y” marking mean ?
Path label from root to an internal node gives a substring of X or Y or both.
For node marked as XY, substring from root to that node belongs to both strings X and Y.
For node marked as X, substring from root to that node belongs to string X only.
For node marked as Y, substring from root to that node belongs to string Y only.
By looking at above figure, can you see how to get LCS of X and Y ?
By now, it should be clear that how to get common substring of X and Y at least.
If we traverse the path from root to nodes marked as XY, we will get common substring of X and Y.
Now we need to find the longest one among all those common substrings.
Can you think how to get LCS now ? Recall how did we get Longest Repeated Substring in a given string
using suffix tree already.
The path label from root to the deepest node marked as XY will give the LCS of X and Y. The deepest node is
highlighted in above figure and path label “abx” from root to that node is the LCS of X and Y.

// Here we build generalized suffix tree for two strings
// And then we find longest common substring of the two input strings
#include <stdio.h>
#include <string.h>
#include <stdlib.h>



int start;
int *end;

int suffixIndex;
};





// be added in tree
int leafEnd = -1;
int size1 = 0; //Size of 1st string

{
int i;

next extension*/
node->end = end;

return node;
}

if(n == root)
return 0;
}

{
{
return 1;
}
return 0;
}

{
leafEnd = pos;

added in tree*/

lastNewNode = NULL;



{

reset.*/
{
lastNewNode = NULL;
}
}
// from activeNode
else
{
// with activeEdge
{
continue;
}
{
{
lastNewNode = NULL;
}
//APCFER3
activeLength++;
break;
}


//New internal node


reset, do it now.*/
{
}

}

{
activeLength--;
}
{
}
}
}

{
int k;
for (k=i; k<=j && text[k] != '#'; k++)
if(k<=j)
printf("#");
}

{

{
//print(n->start, *(n->end));
}
int leaf = 1;
int i;
{
{
// if (leaf == 1 && n->start != -1)

//edges from it.
leaf = 0;
}
}
if (leaf == 1)
{
{
if(text[i] == '#')
{
*(n->end) = i;
}
}
}
}

{
if (n == NULL)
return;
int i;
{
{
}
}
free(n->end);
free(n);
}

{
int i;
*rootEnd = - 1;


}
int doTraversal(Node *n, int labelHeight, int* maxHeight,

{
if(n == NULL)
{
return;
}
int i=0;
int ret = -1;
if(n->suffixIndex < 0) //If it is internal node
{
{
{
ret = doTraversal(n->children[i], labelHeight +
edgeLength(n->children[i]),
maxHeight, substringStartIndex);

if(n->suffixIndex == -1)
n->suffixIndex = ret;
else if((n->suffixIndex == -2 && ret == -3) ||
(n->suffixIndex == -3 && ret == -2) ||
n->suffixIndex == -4)
{
n->suffixIndex = -4;//Mark node as XY
//Keep track of deepest node
if(*maxHeight < labelHeight)
{
*maxHeight = labelHeight;
*substringStartIndex = *(n->end) -
labelHeight + 1;
}
}
}
}
}
}
else if(n->suffixIndex > -1 && n->suffixIndex < size1)//suffix of X
return -2;//Mark node as X
else if(n->suffixIndex >= size1)//suffix of Y
return -3;//Mark node as Y
return n->suffixIndex;
}
void getLongestCommonSubstring()
{
int maxHeight = 0;

int k;
if(k == 0)
printf("No common substring");
else
printf(", of length: %d",maxHeight);
printf("\n");
}

{
size1 = 7;
printf("Longest Common Substring in xabxac and abcabxabcd is: ");
strcpy(text, "xabxac#abcabxabcd$"); buildSuffixTree();
getLongestCommonSubstring();
size1 = 10;
printf("Longest Common Substring in xabxaabxa and babxba is: ");
strcpy(text, "xabxaabxa#babxba$"); buildSuffixTree();
size1 = 14;
printf("Longest Common Substring in GeeksforGeeks and GeeksQuiz is: ");
strcpy(text, "GeeksforGeeks#GeeksQuiz$"); buildSuffixTree();
size1 = 26;
printf("Longest Common Substring in OldSite:GeeksforGeeks.org");
printf(" and NewSite:GeeksQuiz.com is: ");
strcpy(text, "OldSite:GeeksforGeeks.org#NewSite:GeeksQuiz.com$");
buildSuffixTree();
size1 = 6;
printf("Longest Common Substring in abcde and fghie is: ");
strcpy(text, "abcde#fghie$"); buildSuffixTree();
size1 = 6;
printf("Longest Common Substring in pqrst and uvwxyz is: ");
strcpy(text, "pqrst#uvwxyz$"); buildSuffixTree();
return 0;
}

Output:
Longest Common Substring in xabxac and abcabxabcd is: abxa, of length: 4

Longest Common Substring in xabxaabxa and babxba is: abx, of length: 3
Longest Common Substring in GeeksforGeeks and GeeksQuiz is: Geeks, of length: 5
Longest Common Substring in OldSite:GeeksforGeeks.org and
NewSite:GeeksQuiz.com is: Site:Geeks, of length: 10
Longest Common Substring in abcde and fghie is: e, of length: 1
Longest Common Substring in pqrst and uvwxyz is: No common substring

If two strings are of size M and N, then Generalized Suffix Tree construction takes O(M+N) and LCS finding
is a DFS on tree which is again O(M+N).
So overall complexity is linear in time and space.
Followup:
1. Given a pattern, check if it is substring of X or Y or both. If it is a substring, find all it’s occurrences
along with which string (X or Y or both) it belongs to.
2. Extend the implementation to find LCS of more than two strings
3. Solve problem 1 for more than two strings
4. Given a string, find it’s Longest Palindromic Substring
How to check if two given sets are disjoint?
Given two sets represented by two arrays, how to check if the given two sets are disjoint or not? It may be
assumed that the given arrays have no duplicates.
Input: set1[] = {12, 34, 11, 9, 3}

set2[] = {2, 1, 3, 5}
Output: Not Disjoint
3 is common in two sets.
Input: set1[] = {12, 34, 11, 9, 3}

set2[] = {7, 2, 1, 5}
Output: Yes, Disjoint
There is no common element in two sets.

There are plenty of methods to solve this problem, it’s a good test to check how many solutions you can
guess.
Method 1 (Simple)
Iterate through every element of first set and search it in other set, if any element is found, return false. If no
element is found, return tree. Time complexity of this method is O(mn).

// A Simple C++ program to check if two sets are disjoint

#include<iostream>
// Returns true if set1[] and set2[] are disjoint, else false

bool areDisjoint(int set1[], int set2[], int m, int n)
{
// Take every element of set1[] and search it in set2
if (set1[i] == set2[j])
return false;
// If no element of set1 is present in set2

return true;
}

int main()
{
int set1[] = {12, 34, 11, 9, 3};
int set2[] = {7, 2, 1, 5};
int m = sizeof(set1)/sizeof(set1[0]);
int n = sizeof(set2)/sizeof(set2[0]);
areDisjoint(set1, set2, m, n)? cout << "Yes" : cout << " No";
return 0;
}

Output:

Yes

Method 2 (Use Sorting and Merging)

1) Sort first and second sets.
2) Use merge like process to compare elements.

// A Simple C++ program to check if two sets are disjoint

#include<iostream>
#include<algorithm>
// Returns true if set1[] and set2[] are disjoint, else false

bool areDisjoint(int set1[], int set2[], int m, int n)
{
// Sort the given two sets
sort(set1, set1+m);
sort(set2, set2+n);
// Check for same elements using merge like process

int i = 0, j = 0;
{
if (set1[i] < set2[j])
i++;
else if (set2[j] < set1[i])
j++;
else /* if set1[i] == set2[j] */
return false;
}
return true;
}

int main()
{
int set1[] = {12, 34, 11, 9, 3};
int set2[] = {7, 2, 1, 5};
int m = sizeof(set1)/sizeof(set1[0]);
int n = sizeof(set2)/sizeof(set2[0]);
areDisjoint(set1, set2, m, n)? cout << "Yes" : cout << " No";
return 0;
}

Output:

Yes

Time complexity of above solution is O(mLogm + nLogn).
The above solution first sorts both sets, then takes O(m+n) time to find intersection. If we are given that the
input sets are sorted, then this method is best among all.
Method 3 (Use Sorting and Binary Search)

This is similar to method 1. Instead of linear search, we use Binary Search.
1) Sort first set.
2) Iterate through every element of second set, and use binary search to search every element in first set. If
element is found return it.
Time complexity of this method is O(mLogm + nLogm)

Method 4 (Use Binary Search Tree)
1) Create a self balancing binary search tree (Red Black, AVL, Splay, etc) of all elements in first set.
2) Iterate through all elements of second set and search every element in the above constructed Binary
Search Tree. If element is found, return false.
3) If all elements are absent, return true.
Time complexity of this method is O(mLogm + nLogm).

1) Create an empty hash table.
2) Iterate through the first set and store every element in hash table.
3) Iterate through second set and check if any element is present in hash table. If present, then return false,
else ignore the element.
4) If all elements of second set are not present in hash table, return true.
Following is Java implementation of this method.
/* Java program to check if two sets are distinct or not */

import java.util.*;
class Main
{
// This function prints all distinct elements
static boolean areDisjoint(int set1[], int set2[])
{
// Traverse the first set and store its elements in hash

for (int i=0; i<set1.length; i++)
set.add(set1[i]);
// Traverse the second set and check if any element of it

// is already in hash or not.
for (int i=0; i<set2.length; i++)
if (set.contains(set2[i]))
return false;
return true;
}

public static void main (String[] args)
{
int set1[] = {10, 5, 3, 4, 6};
int set2[] = {8, 7, 9, 3};
if (areDisjoint(set1, set2)
System.out.println("Yes");
else
System.out.println("No");
}
}

Output:

Yes

Time complexity of the above implementation is O(m+n) under the assumption that hash set operations like
add() and contains() work in O(1) time.
This article is contributed by Rajeev. Please write comments if you find anything incorrect, or you want to
Time complexity of insertion sort when there are O(n) inversions?
What is an inversion?
Given an array arr[], a pair arr[i] and arr[j] forms an inversion if arr[i] j. For example, the array {1, 3, 2, 5}
has one inversion (3, 2) and array {5, 4, 3} has inversions (5, 4), (5, 3) and (4, 3). We have discussed a merge
sort based algorithm to count inversions
What is the time complexity of Insertion Sort when there are O(n) inversions?
Consider the following function of insertion sort.
/* Function to sort an array using insertion sort*/

void insertionSort(int arr[], int n)
{
int i, key, j;
for (i = 1; i < n; i++)
{
key = arr[i];
j = i-1;

/* Move elements of arr[0..i-1], that are
greater than key, to one position ahead
of their current position */
while (j >= 0 && arr[j] > key)
{
arr[j+1] = arr[j];
j = j-1;
}
arr[j+1] = key;
}
}

If we take a closer look at the insertion sort code, we can notice that every iteration of while loop reduces one
inversion. The while loop executes only if i > j and arr[i] 2).
discussed above
K’th Smallest/Largest Element in Unsorted Array | Set 1
Given an array and a number k where k is smaller than size of array, we need to find the k’th smallest
element in the given array. It is given that ll array elements are distinct.
Examples:
Input: arr[] = {7, 10, 4, 3, 20, 15}

k = 3
Output: 7
Input: arr[] = {7, 10, 4, 3, 20, 15}

k = 4
Output: 10

We have discussed a similar problem to print k largest elements.
Method 1 (Simple Solution)

A Simple Solution is to sort the given array using a O(nlogn) sorting algorithm like Merge Sort, Heap Sort,
etc and return the element at index k-1 in the sorted array. Time Complexity of this solution is O(nLogn).
// Simple C++ program to find k'th smallest element

#include<iostream>
#include<algorithm>
// Function to return k'th smallest element in a given array

int kthSmallest(int arr[], int n, int k)
{
// Sort the given array
sort(arr, arr+n);
// Return k'th element in the sorted array

return arr[k-1];
}
// Driver program to test above methods

int main()
{
int arr[] = {12, 3, 5, 7, 19};
int n = sizeof(arr)/sizeof(arr[0]), k = 2;
cout << "K'th smallest element is " << kthSmallest(arr, n, k);
return 0;
}

K'th smallest element is 5

Method 2 (Using Min Heap – HeapSelect)
We can find k’th smallest element in time complexity better than O(nLogn). A simple optomization is to
create a Min Heap of the given n elements and call extractMin() k times.
The following is C++ implementation of above method.
// A C++ program to find k'th smallest element using min heap

#include<iostream>
#include<climits>


class MinHeap
{
int capacity; // maximum possible size of min heap
int heap_size; // Current number of elements in min heap
public:
MinHeap(int a[], int size); // Constructor
void MinHeapify(int i); //To minheapify subtree rooted with index i
int parent(int i) { return (i-1)/2; }
int extractMin(); // extracts root (minimum) element

int getMin() { return harr[0]; } // Returns minimum
};

{
heap_size = size;
while (i >= 0)
{
MinHeapify(i);
i--;
}
}

{
if (heap_size == 0)
return INT_MAX;
// Store the minimum vakue.

int root = harr[0];
// If there are more than 1 items, move the last item to root
// and call heapify.
if (heap_size > 1)
{
MinHeapify(0);
}
heap_size--;
return root;
return root;
}

{
int l = left(i);
int r = right(i);
int smallest = i;
smallest = l;
smallest = r;
if (smallest != i)
{
}
}

{
int temp = *x;
*x = *y;
*y = temp;
}
// Function to return k'th smallest element in a given array

{
// Build a heap of n elements: O(n) time
MinHeap mh(arr, n);
// Do extract min (k-1) times

mh.extractMin();
// Return root
return mh.getMin();
}

int main()
{
int arr[] = {12, 3, 5, 7, 19};
return 0;
}

Output:

Time complexity of this solution is O(n + kLogn).

Method 3 (Using Max-Heap)
We can also use Max Heap for finding the k’th smallest element. Following is algorithm.
1) Build a Max-Heap MH of the first k elements (arr[0] to arr[k-1]) of the given array. O(k)
2) For each element, after the k’th element (arr[k] to arr[n-1]), compare it with root of MH.
……a) If the element is less than the root then make it root and call heapify for MH
……b) Else ignore it.
// The step 2 is O((n-k)*logk)
3) Finally, root of the MH is the kth smallest element.
Time complexity of this solution is O(k + (n-k)*Logk)
The following is C++ implementation of above algorithm
// A C++ program to find k'th smallest element using max heap

#include<iostream>
#include<climits>

// A class for Max Heap

class MaxHeap
{
int capacity; // maximum possible size of max heap
int heap_size; // Current number of elements in max heap
public:
MaxHeap(int a[], int size); // Constructor
void maxHeapify(int i); //To maxHeapify subtree rooted with index i
int extractMax(); // extracts root (maximum) element

int getMax() { return harr[0]; } // Returns maximum

void replaceMax(int x) { harr[0] = x; maxHeapify(0); }
};
MaxHeap::MaxHeap(int a[], int size)

{
heap_size = size;
while (i >= 0)
{
maxHeapify(i);
i--;
}
}
// Method to remove maximum element (or root) from max heap

int MaxHeap::extractMax()
{
if (heap_size == 0)
return INT_MAX;
// Store the maximum vakue.

int root = harr[0];
if (heap_size > 1)
{
maxHeapify(0);
}
heap_size--;
return root;
}

void MaxHeap::maxHeapify(int i)
{
int l = left(i);
int r = right(i);
int largest = i;
if (l < heap_size && harr[l] > harr[i])
largest = l;
if (r < heap_size && harr[r] > harr[largest])
largest = r;
if (largest != i)
{
swap(&harr[i], &harr[largest]);
maxHeapify(largest);
}
}

{
int temp = *x;
*x = *y;
*y = temp;
}
// Function to return k'th largest element in a given array

{
// Build a heap of first k elements: O(k) time
MaxHeap mh(arr, k);
// Process remaining n-k elements. If current element is

// smaller than root, replace root with current element
for (int i=k; i<n; i++)
if (arr[i] < mh.getMax())
mh.replaceMax(arr[i]);
// Return root
return mh.getMax();
}

int main()
{
int arr[] = {12, 3, 5, 7, 19};
return 0;
}

Output:

Method 4 (QuickSelect)
This is an optimization over method 1 if QuickSort is used as a sorting algorithm in first step. In QuickSort,
we pick a pivot element, then move the pivot element to its correct position and partition the array around it.
The idea is, not to do complete quicksort, but stop at the point where pivot itself is k’th smallest element.
Also, not to recur for both left and right sides of pivot, but recur for one of them according to the position of
pivot. The worst case time complexity of this method is O(n2), but it works in O(n) on average.
#include<iostream>
#include<climits>
int partition(int arr[], int l, int r);
// This function returns k'th smallest element in arr[l..r] using

// QuickSort based method. ASSUMPTION: ALL ELEMENTS IN ARR[] ARE DISTINCT
int kthSmallest(int arr[], int l, int r, int k)
{
// If k is smaller than number of elements in array
if (k > 0 && k <= r - l + 1)
{
// Partition the array around last element and get
// position of pivot element in sorted array
int pos = partition(arr, l, r);
// If position is same as k
if (pos-l == k-1)
return arr[pos];
if (pos-l > k-1) // If position is more, recur for left subarray
return kthSmallest(arr, l, pos-1, k);
// Else recur for right subarray

return kthSmallest(arr, pos+1, r, k-pos+l-1);
}
// If k is more than number of elements in array

return INT_MAX;
}

{
int temp = *a;
*a = *b;
*b = temp;
}
// Standard partition process of QuickSort(). It considers the last
// element as pivot and moves all smaller element to left of it
// and greater elements to right
int partition(int arr[], int l, int r)
{
int x = arr[r], i = l;
for (int j = l; j <= r - 1; j++)
{
if (arr[j] <= x)
{
i++;
}
}
swap(&arr[i], &arr[r]);
return i;
}

int main()
{
int arr[] = {12, 3, 5, 7, 4, 19, 26};
cout << "K'th smallest element is " << kthSmallest(arr, 0, n-1, k);
return 0;
}

Output:

There are two more solutions which are better than above discussed ones: One solution is to do randomized
version of quickSelect() and other solution is worst case linear time algorithm (see the following posts).
K’th Smallest/Largest Element in Unsorted Array | Set 2 (Expected Linear Time)

K’th Smallest/Largest Element in Unsorted Array | Set 3 (Worst Case Linear Time)
References:
http://www.cs.rit.edu/~ib/Classes/CS515_Spring12-13/Slides/022-SelectMasterThm.pdf
discussed above
K’th Smallest/Largest Element in Unsorted Array | Set 2 (Expected Linear
Time)
We recommend to read following post as a prerequisite of this post.
Examples:

Input: arr[] = {7, 10, 4, 3, 20, 15}
k = 3
Output: 7
Input: arr[] = {7, 10, 4, 3, 20, 15}

k = 4
Output: 10

We have discussed three different solutions here.
In this post method 4 is discussed which is mainly an extension of method 3 (QuickSelect) discussed in the
previous post. The idea is to randomly pick a pivot element. To implement randomized partition, we use a
random function, rand() to generate index between l and r, swap the element at randomly generated index
with the last element, and finally call the standard partition process which uses last element as pivot.
Following is C++ implementation of above Randomized QuickSelect.
// C++ implementation of randomized quickSelect

#include<iostream>
#include<climits>
#include<cstdlib>
int randomPartition(int arr[], int l, int r);
// This function returns k'th smallest element in arr[l..r] using

// QuickSort based method. ASSUMPTION: ALL ELEMENTS IN ARR[] ARE DISTINCT
{
if (k > 0 && k <= r - l + 1)
{
// Partition the array around a random element and
// get position of pivot element in sorted array
int pos = randomPartition(arr, l, r);
if (pos-l == k-1)
return arr[pos];
if (pos-l > k-1) // If position is more, recur for left subarray

}
return INT_MAX;
}

{
int temp = *a;
*a = *b;
*b = temp;
}
// Standard partition process of QuickSort(). It considers the last

// element as pivot and moves all smaller element to left of it and
// greater elements to right. This function is used by randomPartition()
int partition(int arr[], int l, int r)
{
int x = arr[r], i = l;
for (int j = l; j <= r - 1; j++)
{
if (arr[j] <= x)
{
i++;
}
}
return i;
}
// Picks a random pivot element between l and r and partitions

// arr[l..r] arount the randomly picked element using partition()
int randomPartition(int arr[], int l, int r)
{
int n = r-l+1;
int pivot = rand() % n;
swap(&arr[l + pivot], &arr[r]);
return partition(arr, l, r);
}

int main()
{
int arr[] = {12, 3, 5, 7, 4, 19, 26};
cout << "K'th smallest element is " << kthSmallest(arr, 0, n-1, k);
return 0;
}

Output:

Time Complexity:
The worst case time complexity of the above solution is still O(n 2). In worst case, the randomized function
may always pick a corner element. The expected time complexity of above randomized QuickSelect is Θ(n),
see CLRS book or MIT video lecture for proof. The assumption in the analysis is, random number generator
is equally likely to generate any number in the input range.
Sources:
MIT Video Lecture on Order Statistics, Median
Construct a Maximum Sum Linked List out of two Sorted Linked Lists
having some Common nodes
Given two sorted linked lists, construct a linked list that contains maximum sum path from start to end. The
result list may contain nodes from both input lists. When constructing the result list, we may switch to the
other input list only at the point of intersection (which mean the two node with the same value in the lists).
You are allowed to use O(1) extra space.
Input:
List1 = 1->3->30->90->120->240->511
List2 = 0->3->12->32->90->125->240->249
Output: Following is maximum sum linked list out of two input lists
list = 1->3->12->32->90->125->240->511
we switch at 3 and 240 to get above maximum sum linked list

The idea here in the below solution is to adjust next pointers after common nodes.
1. Start with head of both linked lists and find first common node. Use merging technique of sorted linked
list for that.
2. Keep track of sum of the elements too while doing this and set head of result list based on greater sum till
first common node.
3. After this till the current pointers of both lists don’t become NULL we need to adjust the next of prev
pointers based on greater sum.
This way it can be done in-place with constant extra space.

Time complexity of the below solution is O(n).
// C++ program to construct the maximum sum linked

// list out of two given sorted lists
#include<iostream>
//A linked list node

struct Node
{
int data; //data belong to that node
Node *next; //next pointer
};
// Push the data to the head of the linked list

void push(Node **head, int data)
{
//Alocation memory to the new node
Node *newnode = new Node;
//Assigning data to the new node

newnode->data = data;
//Adjusting next pointer of the new node

newnode->next = *head;
//New node becomes the head of the list

*head = newnode;
}
// Method that adjusts the pointers and prints the final list
void finalMaxSumList(Node *a, Node *b)
{
Node *result = NULL;
// Assigning pre and cur to the head of the

// linked list.
Node *pre1 = a, *curr1 = a;
Node *pre2 = b, *curr2 = b;
// Till either of the current pointers is not

// NULL execute the loop
while (curr1 != NULL || curr2 != NULL)
{
// Keeping 2 local variables at the start of every
// loop run to keep track of the sum between pre
// and cur pointer elements.
int sum1 = 0, sum2 = 0;
// Calculating sum by traversing the nodes of linked

// list as the merging of two linked list. The loop
// stops at a common node
while (curr1!=NULL && curr2!=NULL && curr1->data!=curr2->data)
{
if (curr1->data < curr2->data)
{
sum1 += curr1->data;
curr1 = curr1->next;
}
else // (curr2->data < curr1->data)
{
}
}
// If either of current pointers becomes NULL

// carry on the sum calculation for other one.
if (curr1 == NULL)
{
while (curr2 != NULL)
{
}
}
if (curr2 == NULL)
{
while (curr1 != NULL)
{
}
}
// First time adjustment of resultant head based on

// the maximum sum.
if (pre1 == a && pre2 == b)
result = (sum1 > sum2)? pre1 : pre2;
// If pre1 and pre2 don't contain the head pointers of

// lists adjust the next pointers of previous pointers.
else
{
if (sum1 > sum2)
pre2->next = pre1->next;
else
pre1->next = pre2->next;
}
// Adjusting previous pointers

pre1 = curr1, pre2 = curr2;
// If curr1 is not NULL move to the next.

if (curr1)
// If curr2 is not NULL move to the next.
if (curr2)
}
// Print the resultant list.

while (result != NULL)
{
cout << result->data << " ";
result = result->next;
}
}
//Main driver program

int main()
{
//Linked List 1 : 1->3->30->90->110->120->NULL
//Linked List 2 : 0->3->12->32->90->100->120->130->NULL
Node *head1 = NULL, *head2 = NULL;
push(&head1, 120);
push(&head1, 110);
push(&head1, 90);
push(&head1, 30);
push(&head1, 3);
push(&head1, 1);
push(&head2, 130);
push(&head2, 120);
push(&head2, 100);
push(&head2, 90);
push(&head2, 32);
push(&head2, 12);
push(&head2, 3);
push(&head2, 0);
finalMaxSumList(head1, head2);
return 0;
}

Output:
1 3 12 32 90 110 120 130

Time complexity = O(n) where n is the length of bigger linked list
Auxiliary space = O(1)
However a problem in this solution is that the original lists are changed.
Exercise
1. Try this problem when auxiliary space is not a constraint.
2. Try this problem when we don’t modify the actual list and create the resultant list.
This article is contributed by Kumar Gautam. Please write comments if you find anything incorrect, or
Find Index of 0 to be replaced with 1 to get longest continuous sequence of
1s in a binary array
Given an array of 0s and 1s, find the position of 0 to be replaced with 1 to get longest continuous sequence of
1s. Expected time complexity is O(n) and auxiliary space is O(1).
Example:

Input:
arr[] = {1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1}
Output:
Index 9
Assuming array index starts from 0, replacing 0 with 1 at index 9 causes
the maximum continuous sequence of 1s.
Input:
arr[] = {1, 1, 1, 1, 0}
Output:
Index 4

A Simple Solution is to traverse the array, for every 0, count the number of 1s on both sides of it. Keep
track of maximum count for any 0. Finally return index of the 0 with maximum number of 1s around it. The
time complexity of this solution is O(n2).
Using an Efficient Solution, the problem can solved in O(n) time. The idea is to keep track of three
indexes, current index (curr), previous zero index (prev_zero) and previous to previous zero index
(prev_prev_zero). Traverse the array, if current element is 0, calculate the difference between curr and
prev_prev_zero (This difference minus one is the number of 1s around the prev_zero). If the difference
between curr and prev_prev_zero is more than maximum so far, then update the maximum. Finally return
index of the prev_zero with maximum difference.

// C++ program to find Index of 0 to be replaced with 1 to get

// longest continuous sequence of 1s in a binary array
#include<iostream>
// Returns index of 0 to be replaced with 1 to get longest

// continuous sequence of 1s. If there is no 0 in array, then
// it returns -1.
int maxOnesIndex(bool arr[], int n)
{
int max_count = 0; // for maximum number of 1 around a zero
int max_index; // for storing result
int prev_zero = -1; // index of previous zero
int prev_prev_zero = -1; // index of previous to previous zero
// Traverse the input array

for (int curr=0; curr<n; ++curr)
{
// If current element is 0, then calculate the difference
// between curr and prev_prev_zero
if (arr[curr] == 0)
{
// Update result if count of 1s around prev_zero is more
if (curr - prev_prev_zero > max_count)
{
max_count = curr - prev_prev_zero;
max_index = prev_zero;
}
// Update for next iteration

prev_prev_zero = prev_zero;
prev_zero = curr;
}
}
// Check for the last encountered zero

if (n-prev_prev_zero > max_count)
max_index = prev_zero;
return max_index;
}
// Driver program
int main()
{
bool arr[] = {1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1};
cout << "Index of 0 to be replaced is "
<< maxOnesIndex(arr, n);
return 0;
}

Output:

Index of 0 to be replaced is 9

This article is contributed by Ankur Singh. Please write comments if you find anything incorrect, or you
Check a given sentence for a given set of simple grammer rules
A simple sentence if syntactically correct if it fulfills given rules. The following are given rules.
1. Sentence must start with a Uppercase character (e.g. Noun/ I/ We/ He etc.)
2. Then lowercase character follows.
3. There must be spaces between words.
4. Then the sentence must end with a full stop(.) after a word.
5. Two continuous spaces are not allowed.
6. Two continuous upper case characters are not allowed.
7. However the sentence can end after an upper case character.
Examples:
Correct sentences -
"My name is Ram."
"The vertex is S."
"I am single."
"I love Geeksquiz and Geeksforgeeks."
Incorrect sentence -
"My name is KG."
"I lovE cinema."
"GeeksQuiz. is a quiz site."
" You are my friend."
"I love cinema"

Question: Given a sentence, validate the given sentence for above given rules.
The idea is to use an automata for the given set of rules.
Algorithm :
1. Check for the corner cases
…..1.a) Check if the first character is uppercase or not in the sentence.
…..1.b) Check if the last character is a full stop or not.
2. For rest of the string, this problem could be solved by following a state diagram. Please refer to the below
state diagram for that.
3. We need to maintain previous and current state of different characters in the string. Based on that we can
always validate the sentence of every character traversed.
A C based implementation is below. (By the way this sentence is also correct according to the rule and code)
// C program to validate a given sentence for a set of rules

#include<stdio.h>
#include<string.h>
#include<stdbool.h>
// Method to check a given sentence for given rules

bool checkSentence(char str[])
{
// Calculate the length of the string.
// Check that the first character lies in [A-Z].

// Otherwise return false.
if (str[0] < 'A' || str[0] > 'Z')
return false;
//If the last character is not a full stop(.) no

//need to check further.
if (str[len - 1] != '.')
return false;
// Maintain 2 states. Previous and current state based

// on which vertex state you are. Initialise both with
// 0 = start state.
int prev_state = 0, curr_state = 0;
//Keep the index to the next character in the string.

int index = 1;
//Loop to go over the string.

while (str[index])
{
// Set states according to the input characters in the
// string and the rule defined in the description.
// If current character is [A-Z]. Set current state as 0.
if (str[index] >= 'A' && str[index] <= 'Z')
curr_state = 0;
// If current character is a space. Set current state as 1.
else if (str[index] == ' ')
curr_state = 1;
// If current character is [a-z]. Set current state as 2.

else if (str[index] >= 'a' && str[index] <= 'z')
curr_state = 2;
// If current state is a dot(.). Set current state as 3.

else if (str[index] == '.')
curr_state = 3;
// Validates all current state with previous state for the

// rules in the description of the problem.
if (prev_state == curr_state && curr_state != 2)
return false;
if (prev_state == 2 && curr_state == 0)

return false;
// If we have reached last state and previous state is not 1,

// then check next character. If next character is '\0', then
// return true, else false
if (curr_state == 3 && prev_state != 1)
return (str[index + 1] == '\0');
index++;
// Set previous state as current state before going over

// to the next character.
prev_state = curr_state;
}
return false;
}
// Driver program
int main()
{
char *str[] = { "I love cinema.", "The vertex is S.",
"I am single.", "My name is KG.",
"I lovE cinema.", "GeeksQuiz. is a quiz site.",
"I love Geeksquiz and Geeksforgeeks.",
" You are my friend.", "I love cinema" };
int str_size = sizeof(str) / sizeof(str[0]);
int i = 0;
for (i = 0; i < str_size; i++)
checkSentence(str[i])? printf("\"%s\" is correct \n", str[i]):
printf("\"%s\" is incorrect \n", str[i]);
return 0;
}

Output:

"I love cinema." is correct
"The vertex is S." is correct
"I am single." is correct
"My name is KG." is incorrect
"I lovE cinema." is incorrect
"GeeksQuiz. is a quiz site." is incorrect
"I love Geeksquiz and Geeksforgeeks." is correct
" You are my friend." is incorrect
"I love cinema" is incorrect

Time complexity – O(n), worst case as we have to traverse the full sentence where n is the length of the
sentence.
Auxiliary space – O(1)
K’th Smallest/Largest Element in Unsorted Array | Set 3 (Worst Case Linear
Time)
We recommend to read following posts as a prerequisite of this post.

Examples:

Input: arr[] = {7, 10, 4, 3, 20, 15}
k = 3
Output: 7
Input: arr[] = {7, 10, 4, 3, 20, 15}

k = 4
Output: 10

In previous post, we discussed an expected linear time algorithm. In this post, a worst case linear time
method is discussed. The idea in this new method is similar to quickSelect(), we get worst case linear time
by selecting a pivot that divides array in a balanced way (there are not very few elements on one side and
many on other side). After the array is divided in a balanced way, we apply the same steps as used in
quickSelect() to decide whether to go left or right of pivot.
Following is complete algorithm.

kthSmallest(arr[0..n-1], k)
1) Divide arr[] into ⌈n/5rceil; groups where size of each group is 5
except possibly the last group which may have less than 5 elements.
2) Sort the above created ⌈n/5⌉ groups and find median

of all groups. Create an auxiliary array 'median[]' and store medians
of all ⌈n/5⌉ groups in this median array.
// Recursively call this method to find median of median[0..⌈n/5⌉-1]

3) medOfMed = kthSmallest(median[0..⌈n/5⌉-1], ⌈n/10⌉)
4) Partition arr[] around medOfMed and obtain its position.

pos = partition(arr, n, medOfMed)
5) If pos == k return medOfMed

6) If pos < k return kthSmallest(arr[l..pos-1], k)
7) If poa > k return kthSmallest(arr[pos+1..r], k-pos+l-1)

In above algorithm, last 3 steps are same as algorithm in previous post. The first four steps are used to
obtain a good point for partitioning the array (to make sure that there are not too many elements either side
of pivot).

// C++ implementation of worst case linear time algorithm
// to find k'th smallest element
#include<iostream>
#include<algorithm>
#include<climits>
int partition(int arr[], int l, int r, int k);
// A simple function to find median of arr[]. This is called

// only for an array of size 5 in this program.
int findMedian(int arr[], int n)
{
sort(arr, arr+n); // Sort the array
return arr[n/2]; // Return middle element
}
// Returns k'th smallest element in arr[l..r] in worst case

// linear time. ASSUMPTION: ALL ELEMENTS IN ARR[] ARE DISTINCT
{
if (k > 0 && k <= r - l + 1)
{
int n = r-l+1; // Number of elements in arr[l..r]
// Divide arr[] in groups of size 5, calculate median

// of every group and store it in median[] array.
int i, median[(n+4)/5]; // There will be floor((n+4)/5) groups;
for (i=0; i<n/5; i++)
median[i] = findMedian(arr+l+i*5, 5);
if (i*5 < n) //For last group with less than 5 elements
{
median[i] = findMedian(arr+l+i*5, n%5);
i++;
}
// Find median of all medians using recursive call.

// If median[] has only one element, then no need
// of recursive call
int medOfMed = (i == 1)? median[i-1]:
kthSmallest(median, 0, i-1, i/2);

int pos = partition(arr, l, r, medOfMed);
if (pos-l == k-1)
return arr[pos];
if (pos-l > k-1) // If position is more, recur for left

}

return INT_MAX;
}

{
int temp = *a;
int temp = *a;
*a = *b;
*b = temp;
}
// It searches for x in arr[l..r], and partitions the array

// around x.
int partition(int arr[], int l, int r, int x)
{
// Search for x in arr[l..r] and move it to end
int i;
for (i=l; i<r; i++)
if (arr[i] == x)
break;
// Standard partition algorithm

i = l;
for (int j = l; j <= r - 1; j++)
{
if (arr[j] <= x)
{
i++;
}
}
return i;
}

int main()
{
int arr[] = {12, 3, 5, 7, 4, 19, 26};
cout << "K'th smallest element is "
<< kthSmallest(arr, 0, n-1, k);
return 0;
}

Output:


Time Complexity:
The worst case time complexity of the above algorithm is O(n). Let us analyze all steps.
The steps 1) and 2) take O(n) time as finding median of an array of size 5 takes O(1) time and there are n/5
arrays of size 5.
The step 3) takes T(n/5) time. The step 4 is standard partition and takes O(n) time.
The interesting steps are 6) and 7). At most, one of them is executed. These are recursive steps. What is the
worst case size of these recursive calls. The answer is maximum number of elements greater than medOfMed
(obtained in step 3) or maximum number of elements smaller than medOfMed.
How many elements are greater than medOfMed and how many are smaller?
At least half of the medians found in step 2 are greater than or equal to medOfMed. Thus, at least half of the
n/5 groups contribute 3 elements that are greater than medOfMed, except for the one group that has fewer
than 5 elements. Therefore, the number of elements greater than medOfMed is at least.
Similarly, the number of elements that are less than medOfMed is at least 3n/10 – 6. In the worst case, the
function recurs for at most n – (3n/10 – 6) which is 7n/10 + 6 elements.
Note that 7n/10 + 6 20 and that any input of 80 or fewer elements requires O(1) time. We can therefore
obtain the recurrence
We show that the running time is linear by substitution. Assume that T(n) cn for some constant c and all n >
80. Substituting this inductive hypothesis into the right-hand side of the recurrence yields
T(n)
since we can pick c large enough so that c(n/10 - 7) is larger than the function
described by the O(n) term for all n > 80. The worst-case running time of is therefore l
inear (Source: http://staff.ustc.edu.cn/~csli/graduate/algorithms/book6/chap10.htm ).
Note that the above algorithm is linear in worst case, but the constants are very high fo
r this algorithm. Therefore, this algorithm doesn't work well in practical situations, ra
ndomized quickSelect works much better and preferred.
Sources:
MIT Video Lecture on Order Statistics, Median
Introduction to Algorithms by Clifford Stein, Thomas H. Cormen, Charles E. Leiserson, Ro

nald L.
http://staff.ustc.edu.cn/~csli/graduate/algorithms/book6/chap10.htm
This article is contributed by Shivam. Please write comments if you find anything

Birthday Paradox
How many people must be there in a room to make the probability 100% that two people in the room have
same birthday?
Answer: 367 (since there are 366 possible birthdays, including February 29).
The above question was simple. Try the below question yourself.
How many people must be there in a room to make the probability 50% that two people in
the room have same birthday?
Answer: 23
The number is surprisingly very low. In fact, we need only 70 people to make the probability 99.9 %.
Let us discuss the generalized formula.
What is the probability that two persons among n have same birthday?
Let the probability that two people in a room with n have same birthday be P(same). P(Same) can be easily
evaluated in terms of P(different) where P(different) is the probability that all of them have different
birthday.
P(same) = 1 – P(different)
P(different) can be written as 1 x (364/365) x (363/365) x (362/365) x …. x (1 – (n-1)/365)
How did we get the above expression?

Persons from first to last can get birthdays in following order for all birthdays to be distinct:
The first person can have any birthday among 365
The second person should have a birthday which is not same as first person
The third person should have a birthday which is not same as first two persons.
…………….
……………
The n’th person should have a birthday which is not same as any of the earlier considered (n-1) persons.
Approximation of above expression

The above expression can be approximated using Taylor’s Series.
provides a first-order approximation for ex for x
To apply this approximation to the first expression derived for p(different), set x = -a / 365. Thus,
The above expression derived for p(different) can be written as

1 x (1 – 1/365) x (1 – 2/365) x (1 – 3/365) x …. x (1 – (n-1)/365)
By putting the value of 1 – a/365 as e-a/365, we get following.
Therefore,
p(same) = 1- p(different)
An even coarser approximation is given by

p(same)
By taking Log on both sides, we get the reverse formula.
Using the above approximate formula, we can approximate number of people for a given probability. For
example the following C++ function find() returns the smallest n for which the probability is greater than the
given p.
C++ Implementation of approximate formula.

The following is C++ program to approximate number of people for a given probability.
// C++ program to approximate number of people in Birthday Paradox

// problem
#include <cmath>
#include <iostream>
// Returns approximate number of people for a given probability

int find(double p)
{
return ceil(sqrt(2*365*log(1/(1-p))));
}
int main()
{
cout << find(0.70);
}

Output:

30

Source:
http://en.wikipedia.org/wiki/Birthday_problem
Applications:
1) Birthday Paradox is generally discussed with hashing to show importance of collision handling even for a
small set of keys.
2) Birthday Attack
Given a linked list of line segments, remove middle points
Given a linked list of co-ordinates where adjacent points either form a vertical line or a horizontal line.
Delete points from the linked list which are in the middle of a horizontal or vertical line.
Examples:
Input: (0,10)->(1,10)->(5,10)->(7,10)
|
(7,5)->(20,5)->(40,5)
Output: Linked List should be changed to following
(0,10)->(7,10)
|
(7,5)->(40,5)
The given linked list represents a horizontal line from (0,10)
to (7, 10) followed by a vertical line from (7, 10) to (7, 5),
followed by a horizontal line from (7, 5) to (40, 5).
Input: (2,3)->(4,3)->(6,3)->(10,3)->(12,3)
Output: Linked List should be changed to following
(2,3)->(12,3)
There is only one vertical line, so all middle points are removed.

Source: Microsoft Interview Experience
The idea is to keep track of current node, next node and next-next node. While the next node is same as
next-next node, keep deleting the next node. In this complete procedure we need to keep an eye on shifting
of pointers and checking for NULL values.
Following is C implementation of above idea.
// C program to remove intermediate points in a linked list that represents

// horizontal and vertical line segments
#include <stdio.h>
#include <stdlib.h>
// Node has 3 fields including x, y coordinates and a pointer to next node

struct node
{
int x, y;
struct node *next;
};

void push(struct node ** head_ref, int x,int y)
{
new_node->x = x;
new_node->y = y;
}
/* Utility function to print a singly linked list */

{
{
printf("(%d,%d)-> ", temp->x,temp->y);
temp = temp->next;
}
printf("\n");
// Utility function to remove Next from linked list and link nodes
// after it to head
void deleteNode(struct node *head, struct node *Next)
{
head->next = Next->next;
Next->next = NULL;
free(Next);
}
// This function deletes middle nodes in a sequence of horizontal and

// vertical line segments represented by linked list.
struct node* deleteMiddle(struct node *head)
{
// If only one node or no node...Return back
if (head==NULL || head->next ==NULL || head->next->next==NULL)
return head;
struct node* Next = head->next;

struct node *NextNext = Next->next ;
// Check if this is a vertical line or horizontal line

if (head->x == Next->x)
{
// Find middle nodes with same x value, and delete them
while (NextNext !=NULL && Next->x==NextNext->x)
{
deleteNode(head, Next);
// Update Next and NextNext for next iteration

Next = NextNext;
NextNext = NextNext->next;
}
}
else if (head->y==Next->y) // If horizontal line
{
// Find middle nodes with same y value, and delete them
while (NextNext !=NULL && Next->y==NextNext->y)
{
deleteNode(head, Next);
// Update Next and NextNext for next iteration

Next = NextNext;
NextNext = NextNext->next;
}
}
else // Adjacent points must have either same x or same y
{
puts("Given linked list is not valid");
return NULL;
}
// Recur for next segment

deleteMiddle(head->next);
deleteMiddle(head->next);
return head;
}
// Driver program to tsst above functions

int main()
{
push(&head, 40,5);
push(&head, 20,5);
push(&head, 10,5);
push(&head, 10,8);
push(&head, 10,10);
push(&head, 3,10);
push(&head, 1,10);
push(&head, 0,10);
printf("Given Linked List: \n");
printList(head);
if (deleteMiddle(head) != NULL);
{
printf("Modified Linked List: \n");
printList(head);
}
return 0;
}

Output:

Given Linked List:
(0,10)-> (1,10)-> (3,10)-> (10,10)-> (10,8)-> (10,5)-> (20,5)-> (40,5)->
Modified Linked List:
(0,10)-> (10,10)-> (10,5)-> (40,5)->

Time Complexity of the above solution is O(n) where n is number of nodes in given linked list.
Exercise:
The above code is recursive, write an iterative code for the same problem.
This article is contributed by Sanket Jain. Please write comments if you find anything incorrect, or you want
Given n appointments, find all conflicting appointments
Given n appointments, find all conflicting appointments.
Examples:
Input: appointments[] = { {1, 5} {3, 7}, {2, 6}, {10, 15}, {5, 6}, {4, 100}}
Output: Following are conflicting intervals
[3,7] Conflicts with [1,5]

An appointment is conflicting, if it conflicts with any of the previous appointments in array.
A Simple Solution is to one by one process all appointments from second appointment to last. For every
appointment i, check if it conflicts with i-1, i-2, … 0. The time complexity of this method is O(n2).
We can use Interval Tree to solve this problem in O(nLogn) time. Following is detailed algorithm.
1) Create an Interval Tree, initially with the first appointment.

2) Do following for all other appointments starting from the second one.
a) Check if the current appointment conflicts with any of the existing
appointments in Interval Tree. If conflicts, then print the current
appointment. This step can be done O(Logn) time.
b) Insert the current appointment in Interval Tree. This step also can
be done O(Logn) time.

// C++ program to print all conflicting appointments in a

// given set of appointments
#include <iostream>
// Structure to represent an interval

struct Interval
{
int low, high;
};
// Structure to represent a node in Interval Search Tree

struct ITNode
{
Interval *i; // 'i' could also be a normal variable
int max;
ITNode *left, *right;
};
// A utility function to create a new Interval Search Tree Node

{
ITNode *temp = new ITNode;
temp->i = new Interval(i);
temp->max = i.high;
};
// A utility function to insert a new Interval Search Tree

// Node. This is similar to BST Insert. Here the low value
// of interval is used tomaintain BST property
ITNode *insert(ITNode *root, Interval i)
{
// Base case: Tree is empty, new node becomes root
if (root == NULL)
return newNode(i);
// Get low value of interval at root

int l = root->i->low;
// If root's low value is smaller, then new interval

// goes to left subtree
if (i.low < l)
root->left = insert(root->left, i);
// Else, new node goes to right subtree.

else
root->right = insert(root->right, i);
// Update the max value of this ancestor if needed

if (root->max < i.high)
root->max = i.high;
return root;
}
// A utility function to check if given two intervals overlap

bool doOVerlap(Interval i1, Interval i2)
{
if (i1.low < i2.high && i2.low < i1.high)
return true;
return false;
}
// The main function that searches a given interval i

// in a given Interval Tree.
Interval *overlapSearch(ITNode *root, Interval i)
{
// Base Case, tree is empty
// If given interval overlaps with root

if (doOVerlap(*(root->i), i))
return root->i;
// If left child of root is present and max of left child

// is greater than or equal to given interval, then i may
// overlap with an interval is left subtree
if (root->left != NULL && root->left->max >= i.low)
return overlapSearch(root->left, i);
// Else interval can only overlap with right subtree

return overlapSearch(root->right, i);
}
// This function prints all conflicting appointments in a given
// array of apointments.
void printConflicting(Interval appt[], int n)
{
// Create an empty Interval Search Tree, add first
// appointment
ITNode *root = NULL;
root = insert(root, appt[0]);
// Process rest of the intervals

{
// If current appointment conflicts with any of the
// existing intervals, print it
Interval *res = overlapSearch(root, appt[i]);
if (res != NULL)
cout << "[" << appt[i].low << "," << appt[i].high
<< "] Conflicts with [" << res->low << ","
<< res->high << "]\n";
// Insert this appointment

root = insert(root, appt[i]);
}
}

int main()
{
// Let us create interval tree shown in above figure
Interval appt[] = { {1, 5}, {3, 7}, {2, 6}, {10, 15},
{5, 6}, {4, 100}};
int n = sizeof(appt)/sizeof(appt[0]);
cout << "Following are conflicting intervals\n";
printConflicting(appt, n);
return 0;
}

Output:

Following are conflicting intervals

Note that the above implementation uses simple Binary Search Tree insert operations. Therefore, time
complexity of the above implementation is more than O(nLogn). We can use Red-Black Tree or AVL Tree
balancing techniques to make the above implementation O(nLogn).
This article is contributed by Anmol. Please write comments if you find anything incorrect, or you want to
How to Implement Reverse DNS Look Up Cache?
Reverse DNS look up is using an internet IP address to find a domain name. For example, if you type
74.125.200.106 in browser, it automatically redirects to google.in.
How to implement Reverse DNS Look Up cache? Following are the operations needed from cache.
1) Add a IP address to URL Mapping in cache.
2) Find URL for a given IP address.
One solution is to use Hashing.
In this post, a Trie based solution is discussed. One advantage of Trie based solutions is, worst case upper
bound is O(1) for Trie, for hashing, the best possible average case time complexity is O(1). Also, with Trie we
can implement prefix search (finding all urls for a common prefix of IP addresses).
The general disadvantage of Trie is large amount of memory requirement, this is not a major problem here
as the alphabet size is only 11 here. Ten characters are needed for digits from ‘0’ to ‘9’ and one for dot (‘.’).
The idea is to store IP addresses in Trie nodes and in the last node we store the corresponding domain
name. Following is C style implementation in C++.
// C based program to implement reverse DNS lookup

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
// There are atmost 11 different chars in a valid IP address

#define CHARS 11
// Maximum length of a valid IP address

#define MAX 50
// A utility function to find index of child for a given character 'c'

int getIndex(char c) { return (c == '.')? 10: (c - '0'); }
// A utility function to find character for a given child index.

char getCharFromIndex(int i) { return (i== 10)? '.' : ('0' + i); }
// Trie Node.
struct trieNode
{
bool isLeaf;
char *URL;
struct trieNode *child[CHARS];
};
// Function to create a new trie node.

struct trieNode *newTrieNode(void)
{
struct trieNode *newNode = new trieNode;
newNode->isLeaf = false;
newNode->URL = NULL;
for (int i=0; i<CHARS; i++)
newNode->child[i] = NULL;
return newNode;
}
// This method inserts an ip address and the corresponding

// domain name in the trie. The last node in Trie contains the URL.
void insert(struct trieNode *root, char *ipAdd, char *URL)
{
// Length of the ip address
// Length of the ip address
int len = strlen(ipAdd);
struct trieNode *pCrawl = root;
// Traversing over the length of the ip address.

for (int level=0; level<len; level++)
{
// Get index of child node from current character
// in ipAdd[]. Index must be from 0 to 10 where
// 0 to 9 is used for digits and 10 for dot
int index = getIndex(ipAdd[level]);
// Create a new child if not exist already

if (!pCrawl->child[index])
pCrawl->child[index] = newTrieNode();
// Move to the child

pCrawl = pCrawl->child[index];
}
//Below needs to be carried out for the last node.

//Save the corresponding URL of the ip address in the
//last node of trie.
pCrawl->isLeaf = true;
pCrawl->URL = new char[strlen(URL) + 1];
strcpy(pCrawl->URL, URL);
}
// This function returns URL if given IP address is present in DNS cache.

// Else returns NULL
char *searchDNSCache(struct trieNode *root, char *ipAdd)
{
// Root node of trie.
int len = strlen(ipAdd);
// Traversal over the length of ip address.

for (int level=0; level<len; level++)
{
int index = getIndex(ipAdd[level]);
return NULL;
}
// If we find the last node for a given ip address, print the URL.
if (pCrawl!=NULL && pCrawl->isLeaf)
return pCrawl->URL;
return NULL;
}
//Driver function.
int main()
{
/* Change third ipAddress for validation */
char ipAdd[][MAX] = {"107.108.11.123", "107.109.123.255",
"74.125.200.106"};
char URL[][50] = {"www.samsung.com", "www.samsung.net",
"www.google.in"};
int n = sizeof(ipAdd)/sizeof(ipAdd[0]);
struct trieNode *root = newTrieNode();
// Inserts all the ip address and their corresponding

// domain name after ip address validation.
insert(root,ipAdd[i],URL[i]);
// If reverse DNS look up succeeds print the domain

// name along with DNS resolved.
char ip[] = "107.108.11.123";
char *res_url = searchDNSCache(root, ip);
if (res_url != NULL)
printf("Reverse DNS look up resolved in cache:\n%s --> %s",
ip, res_url);
else
printf("Reverse DNS look up not resolved in cache ");
return 0;
}

Output:

Reverse DNS look up resolved in cache:
107.108.11.123 --> www.samsung.com

Note that the above implementation of Trie assumes that the given IP address does not contain characters
other than {‘0′, ‘1’,….. ‘9’, ‘.’}. What if a user gives an invalid IP address that contains some other characters?
This problem can be resolved by validating the input IP address before inserting it into Trie. We can use the
approach discussed here for IP address validation.
Binary Indexed Tree or Fenwick tree
Let us consider the following problem to understand Binary Indexed Tree.
We have an array arr[0 . . . n-1]. We should be able to

1 Find the sum of first i elements.
2 Change value of a specified element of the array arr[i] = x where 0 <= i <= n-1.
A simple solution is to run a loop from 0 to i-1 and calculate sum of elements. To update a value, simply
do arr[i] = x. The first operation takes O(n) time and second operation takes O(1) time. Another simple
solution is to create another array and store sum from start to i at the i’th index in this array. Sum of a given
range can now be calculated in O(1) time, but update operation takes O(n) time now. This works well if the
number of query operations are large and very few updates.
Can we perform both the operations in O(log n) time once given the array?
One Efficient Solution is to use Segment Tree that does both operations in O(Logn) time.
Using Binary Indexed Tree, we can do both tasks in O(Logn) time. The advantages of Binary Indexed Tree
over Segment are, requires less space and very easy to implement..
Representation
Binary Indexed Tree is represented as an array. Let the array be BITree[]. Each node of Binary Indexed Tree
stores sum of some elements of given array. Size of Binary Indexed Tree is equal to n where n is size of input
array. In the below code, we have used size as n+1 for ease of implementation.
Construction
We construct the Binary Indexed Tree by first initializing all values in BITree[] as 0. Then we call update()
operation for all indexes to store actual sums, update is discussed below.
Operations
getSum(index): Returns sum of arr[0..index]

// Returns sum of arr[0..index] using BITree[0..n]. It assumes that
// BITree[] is constructed for given array arr[0..n-1]
1) Initialize sum as 0 and index as index+1.
2) Do following while index is greater than 0.
...a) Add BITree[index] to sum
...b) Go to parent of BITree[index]. Parent can be obtained by removing
the last set bit from index, i.e., index = index - (index & (-index))
3) Return sum.

The above diagram demonstrates working of getSum(). Following are some important observations.
Node at index 0 is a dummy node.
A node at index y is parent of a node at index x, iff y can be obtained by removing last set bit from binary
representation of x.
A child x of a node y stores sum of elements from of y(exclusive y) and of x(inclusive x).
update(index, val): Updates BIT for operation arr[index] += val

// Note that arr[] is not changed here. It changes
// only BI Tree for the already made change in arr[].
1) Initialize index as index+1.
2) Do following while index is smaller than or equal to n.
...a) Add value to BITree[index]
...b) Go to parent of BITree[index]. Parent can be obtained by removing
the last set bit from index, i.e., index = index - (index & (-index))

The update process needs to make sure that all BITree nodes that have arr[i] as part of the section they cover
must be updated. We get all such nodes of BITree by repeatedly adding the decimal number corresponding
to the last set bit.
How does Binary Indexed Tree work?

The idea is based on the fact that all positive integers can be represented as sum of powers of 2. For example
19 can be represented as 16 + 2 + 1. Every node of BI Tree stores sum of n elements where n is a power of 2.
For example, in the above first diagram for getSum(), sum of first 12 elements can be obtained by sum of last
4 elements (from 9 to 12) plus sum of 8 elements (from 1 to 8). The number of set bits in binary
representation of a number n is O(Logn). Therefore, we traverse at-most O(Logn) nodes in both getSum()
and update() operations. Time complexity of construction is O(nLogn) as it calls update() for all n elements.
Implementation:
Following is C++ implementation of Binary Indexed Tree.
// C++ code to demonstrate operations of Binary Index Tree

#include <iostream>
/* n --> No. of elements present in input array.

BITree[0..n] --> Array that represents Binary Indexed Tree.
arr[0..n-1] --> Input array for whic prefix sum is evaluated. */
// Returns sum of arr[0..index]. This function assumes

// that the array is preprocessed and partial sums of
// array elements are stored in BITree[].
int getSum(int BITree[], int n, int index)
{
{
int sum = 0; // Iniialize result
// index in BITree[] is 1 more than the index in arr[]

index = index + 1;
// Traverse ancestors of BITree[index]

while (index>0)
{
// Add current element of BITree to sum
sum += BITree[index];
// Move index to parent node

index -= index & (-index);
}
return sum;
}
// Updates a node in Binary Index Tree (BITree) at given index

// in BITree. The given value 'val' is added to BITree[i] and
// all of its ancestors in tree.
void updateBIT(int *BITree, int n, int index, int val)
{
// index in BITree[] is 1 more than the index in arr[]
index = index + 1;
// Traverse all ancestors and add 'val'

while (index <= n)
{
// Add 'val' to current node of BI Tree
BITree[index] += val;
// Update index to that of parent

index += index & (-index);
}
}
// Constructs and returns a Binary Indexed Tree for given

// array of size n.
int *constructBITree(int arr[], int n)
{
// Create and initialize BITree[] as 0
int *BITree = new int[n+1];
BITree[i] = 0;
// Store the actual values in BITree[] using update()

updateBIT(BITree, n, i, arr[i]);
// Uncomment below lines to see contents of BITree[]

//for (int i=1; i<=n; i++)
// cout << BITree[i] << " ";
return BITree;
}

int main()
{
int freq[] = {2, 1, 1, 3, 2, 3, 4, 5, 6, 7, 8, 9};
int n = sizeof(freq)/sizeof(freq[0]);
int *BITree = constructBITree(freq, n);
cout << "Sum of elements in arr[0..5] is "
cout << "Sum of elements in arr[0..5] is "
<< getSum(BITree, n, 5);
// Let use test the update operation

freq[3] += 6;
updateBIT(BITree, n, 3, 6); //Update BIT for above change in arr[]
cout << "\nSum of elements in arr[0..5] after update is "

<< getSum(BITree, n, 5);
return 0;
}

Output:

Sum of elements in arr[0..5] is 12
Sum of elements in arr[0..5] after update is 18

Can we extend the Binary Indexed Tree for range Sum in Logn time?
This is simple to answer. The rangeSum(l, r) can be obtained as getSum(r) – getSum(l-1).
Applications:
Used to implement the arithmetic coding algorithm. Development of operations it supports were primarily
motivated by use in that case. See this for more details.
References:
http://en.wikipedia.org/wiki/Fenwick_tree
http://community.topcoder.com/tc?module=Static&d1=tutorials&d2=binaryIndexedTrees
discussed above
Why is Binary Search preferred over Ternary Search?
The following is a simple recursive Binary Search function in C++ taken from here.
// A recursive binary search function. It returns location of x in

{
if (r >= l)
{
int mid = l + (r - l)/2;

// If the element is present at the middle itself

// in left subarray

}

return -1;
}

The following is a simple recursive Ternary Search function in C++.

// A recursive ternary search function. It returns location of x in

int ternarySearch(int arr[], int l, int r, int x)
{
if (r >= l)
{
int mid1 = l + (r - l)/3;
int mid2 = mid1 + (r - l)/3;
// If x is present at the mid1

if (arr[mid1] == x) return mid1;
// If x is present at the mid2

if (arr[mid2] == x) return mid2;
// If x is present in left one-third

if (arr[mid1] > x) return ternarySearch(arr, l, mid1-1, x);
// If x is present in right one-third

if (arr[mid2] < x) return ternarySearch(arr, mid2+1, r, x);
// If x is present in middle one-third

return ternarySearch(arr, mid1+1, mid2-1, x);
}
return -1;
}

Which of the above two does less comparisons in worst case?

From the first look, it seems the ternary search does less number of comparisons as it makes Log3n recursive
calls, but binary search makes Log 2n recursive calls. Let us take a closer look.
The following is recursive formula for counting comparisons in worst case of Binary Search.
T(n) = T(n/2) + 2, T(1) = 1

The following is recursive formula for counting comparisons in worst case of Ternary Search.
T(n) = T(n/3) + 4, T(1) = 1

In binary search, there are 2Log2n + 1 comparisons in worst case. In ternary search, there are 4Log 3n + 1
comparisons in worst case.
Therefore, the comparison of Ternary and Binary Searches boils down the comparison of expressions 2Logn 3
and Log2n . The value of 2Log 3n can be written as (2 / Log23) * Log2n . Since the value of (2 / Log23) is more
than one, Ternary Search does more comparisons than Binary Search in worst case.
Exercise:
Why Merge Sort divides input array in two halves, why not in three or more parts?
Bottom View of a Binary Tree
Given a Binary Tree, we need to print the bottom view from left to right. A node x is there in output if x is the
bottommost node at its horizontal distance. Horizontal distance of left child of a node x is equal to horizontal
distance of x minus 1, and that of right child is horizontal distance of x plus 1.
Examples:
20
/ \
8 22
/ \ \
5 3 25
/ \
10 14
For the above tree the output should be 5, 10, 3, 14, 25.
If there are multiple bottom-most nodes for a horizontal distance from root, then print the later one in level
traversal. For example, in the below diagram, 3 and 4 are both the bottom-most nodes at horizontal distance
0, we need to print 4.

20
/ \
8 22
/ \ / \
5 3 4 25
/ \
10 14

For the above tree the output should be 5, 10, 4, 14, 25.
The following are steps to print Bottom View of Bianry Tree.

1. We put tree nodes in a queue for the level order traversal.
2. Start with the horizontal distance(hd) 0 of the root node, keep on adding left child to queue along with the
horizontal distance as hd-1 and right child as hd+1.
3. Also, use a TreeMap which stores key value pair sorted on key.
4. Every time, we encounter a new horizontal distance or an existing horizontal distance put the node data
for the horizontal distance as key. For the first time it will add to the map, next time it will replace the value.
This will make sure that the bottom most element for that horizontal distance is present in the map and if
you see the tree from beneath that you will see that element.
A Java based implementation is below :
// Java Program to print Bottom View of Binary Tree

import java.util.*;
import java.util.Map.Entry;
// Tree node class

class TreeNode
{
int data; //data of the node
int hd; //horizontal distance of the node
TreeNode left, right; //left and right references
// Constructor of tree node

public TreeNode(int key)
{
data = key;
hd = Integer.MAX_VALUE;
}
}
//Tree class
class Tree
{
TreeNode root; //root node of tree
// Default constructor
public Tree() {}
// Parameterized tree constructor

public Tree(TreeNode node)
{
root = node;
}
// Method that prints the bottom view.

public void bottomView()
{
if (root == null)
return;
// Initialize a variable 'hd' with 0 for the root element.

int hd = 0;
// TreeMap which stores key value pair sorted on key value

Map<Integer, Integer> map = new TreeMap<>();
// Queue to store tree nodes in level order traversal

Queue<TreeNode> queue = new LinkedList<TreeNode>();
// Assign initialized horizontal distance value to root

// node and add it to the queue.
root.hd = hd;
queue.add(root);
// Loop until the queue is empty (standard level order loop)

while (!queue.isEmpty())
{
TreeNode temp = queue.remove();
// Extract the horizontal distance value from the

// dequeued tree node.
hd = temp.hd;
// Put the dequeued tree node to TreeMap having key

// as horizontal distance. Every time we find a node
// having same horizontal distance we need to replace
// having same horizontal distance we need to replace
// the data in the map.
map.put(hd, temp.data);
// If the dequeued node has a left child add it to the

// queue with a horizontal distance hd-1.
if (temp.left != null)
{
temp.left.hd = hd-1;
queue.add(temp.left);
}
// If the dequeued node has a left child add it to the
// queue with a horizontal distance hd+1.
if (temp.right != null)
{
temp.right.hd = hd+1;
queue.add(temp.right);
}
}
// Extract the entries of map into a set to traverse

// an iterator over that.
Set<Entry<Integer, Integer>> set = map.entrySet();
// Make an iterator
Iterator<Entry<Integer, Integer>> iterator = set.iterator();
// Traverse the map elements using the iterator.

while (iterator.hasNext())
{
Map.Entry<Integer, Integer> me = iterator.next();
System.out.print(me.getValue()+" ");
}
}
}
// Main driver class

public class BottomView
{
{
root.left.left = new TreeNode(5);
root.right.left = new TreeNode(4);
root.right.right = new TreeNode(25);
root.left.right.left = new TreeNode(10);
root.left.right.right = new TreeNode(14);
Tree tree = new Tree(root);
System.out.println("Bottom view of the given binary tree:");
tree.bottomView();
}
}

Output:

Bottom view of the given binary tree:
5 10 4 14 25

Exercise: Extend the above solution to print all bottommost nodes at a horizontal distance if there are
multiple bottommost nodes. For the above second example, the output should be 5 10 3 4 14 25.
Flood fill Algorithm – how to implement fill() in paint?
In MS-Paint, when we take the brush to a pixel and click, the color of the region of that pixel is replaced with
a new selected color. Following is the problem statement to do this task.
Given a 2D screen, location of a pixel in the screen and a color, replace color of the given pixel and all
adjacent same colored pixels with the given color.
Example:
Input:
screen[M][N] = {{1, 1, 1, 1, 1, 1, 1, 1},
{1, 1, 1, 1, 1, 1, 0, 0},
{1, 0, 0, 1, 1, 0, 1, 1},
{1, 2, 2, 2, 2, 0, 1, 0},
{1, 1, 1, 2, 2, 0, 1, 0},
{1, 1, 1, 2, 2, 2, 2, 0},
{1, 1, 1, 1, 1, 2, 1, 1},
{1, 1, 1, 1, 1, 2, 2, 1},
};
x = 4, y = 4, newColor = 3
The values in the given 2D screen indicate colors of the pixels.
x and y are coordinates of the brush, newColor is the color that
should replace the previous color on screen[x][y] and all surrounding
pixels with same color.
Output:
Screen should be changed to following.
screen[M][N] = {{1, 1, 1, 1, 1, 1, 1, 1},
{1, 1, 1, 1, 1, 1, 0, 0},
{1, 0, 0, 1, 1, 0, 1, 1},
{1, 3, 3, 3, 3, 0, 1, 0},
{1, 1, 1, 3, 3, 0, 1, 0},
{1, 1, 1, 3, 3, 3, 3, 0},
{1, 1, 1, 1, 1, 3, 1, 1},
{1, 1, 1, 1, 1, 3, 3, 1},
};

Flood Fill Algorithm:

The idea is simple, we first replace the color of current pixel, then recur for 4 surrounding points. The
following is detailed algorithm.
// A recursive function to replace previous color 'prevC' at '(x, y)'

// and all surrounding pixels of (x, y) with new color 'newC' and
floodFil(screen[M][N], x, y, prevC, newC)
1) If x or y is outside the screen, then return.
2) If color of screen[x][y] is not same as prevC, then return
3) Recur for north, south, east and west.
floodFillUtil(screen, x+1, y, prevC, newC);
floodFillUtil(screen, x-1, y, prevC, newC);
floodFillUtil(screen, x, y+1, prevC, newC);
floodFillUtil(screen, x, y-1, prevC, newC);


// A C++ program to implement flood fill algorithm

#include<iostream>
// Dimentions of paint screen

#define M 8
#define N 8
// A recursive function to replace previous color 'prevC' at '(x, y)'

// and all surrounding pixels of (x, y) with new color 'newC' and
void floodFillUtil(int screen[][N], int x, int y, int prevC, int newC)
{
// Base cases
if (x < 0 || x >= M || y < 0 || y >= N)
return;
if (screen[x][y] != prevC)
return;
// Replace the color at (x, y)

screen[x][y] = newC;
// Recur for north, east, south and west

floodFillUtil(screen, x+1, y, prevC, newC);
floodFillUtil(screen, x-1, y, prevC, newC);
floodFillUtil(screen, x, y+1, prevC, newC);
floodFillUtil(screen, x, y-1, prevC, newC);
}
// It mainly finds the previous color on (x, y) and

// calls floodFillUtil()
void floodFill(int screen[][N], int x, int y, int newC)
{
int prevC = screen[x][y];
floodFillUtil(screen, x, y, prevC, newC);
}

int main()
{
int screen[M][N] = {{1, 1, 1, 1, 1, 1, 1, 1},
{1, 1, 1, 1, 1, 1, 0, 0},
{1, 0, 0, 1, 1, 0, 1, 1},
{1, 2, 2, 2, 2, 0, 1, 0},
{1, 1, 1, 2, 2, 0, 1, 0},
{1, 1, 1, 2, 2, 2, 2, 0},
{1, 1, 1, 1, 1, 2, 1, 1},
{1, 1, 1, 1, 1, 2, 2, 1},
};
int x = 4, y = 4, newC = 3;
floodFill(screen, x, y, newC);
cout << "Updated screen after call to floodFill: \n";

for (int i=0; i<M; i++)
{
for (int j=0; j<N; j++)
cout << screen[i][j] << " ";
cout << endl;
}
}

Output:

Updated screen after call to floodFill:
1 1 1 1 1 1 1 1
1 1 1 1 1 1 0 0
1 0 0 1 1 0 1 1
1 3 3 3 3 0 1 0
1 1 1 3 3 0 1 0
1 1 1 3 3 3 3 0
1 1 1 1 1 3 1 1
1 1 1 1 1 3 3 1

References:
http://en.wikipedia.org/wiki/Flood_fill
Manacher’s Algorithm – Linear Time Longest Palindromic Substring – Part
2
In Manacher’s Algorithm – Part 1, we gone through some of the basics and LPS length array.
Here we will see how to calculate LPS length array efficiently.
To calculate LPS array efficiently, we need to understand how LPS length for any position may relate to LPS
length value of any previous already calculated position.
For string “abaaba”, we see following:
If we look around position 3:
LPS length value at position 2 and position 4 are same

We calculate LPS length values from left to right starting from position 0, so we can see if we already know
LPS length values at positions 1, 2 and 3 already then we may not need to calculate LPS length at positions 4
and 5 because they are equal to LPS length values at corresponding positions on left side of position 3.
If we look around position 6:

…………. and so on.

If we already know LPS length values at positions 1, 2, 3, 4, 5 and 6 already then we may not need to
calculate LPS length at positions 7, 8, 9, 10 and 11 because they are equal to LPS length values at
corresponding positions on left side of position 6.
For string “abababa”, we see following:
If we already know LPS length values at positions 1, 2, 3, 4, 5, 6 and 7 already then we may not need to
calculate LPS length at positions 8, 9, 10, 11, 12 and 13 because they are equal to LPS length values at
corresponding positions on left side of position 7.
Can you see why LPS length values are symmetric around positions 3, 6, 9 in string “abaaba”? That’s because
there is a palindromic substring around these positions. Same is the case in string “abababa” around
position 7.
Is it always true that LPS length values around at palindromic center position are always symmetric (same)?
Answer is NO.
Look at positions 3 and 11 in string “abababa”. Both positions have LPS length 3. Immediate left and right
positions are symmetric (with value 0), but not the next one. Positions 1 and 5 (around position 3) are not
symmetric. Similarly, positions 9 and 13 (around position 11) are not symmetric.
At this point, we can see that if there is a palindrome in a string centered at some position, then LPS length
values around the center position may or may not be symmetric depending on some situation. If we can
identify the situation when left and right positions WILL BE SYMMETRIC around the center position, we
NEED NOT calculate LPS length of the right position because it will be exactly same as LPS value of
corresponding position on the left side which is already known. And this fact where we are avoiding LPS
length computation at few positions makes Manacher’s Algorithm linear.
In situations when left and right positions WILL NOT BE SYMMETRIC around the center position, we
compare characters in left and right side to find palindrome, but here also algorithm tries to avoid certain no
of comparisons. We will see all these scenarios soon.
Let’s introduce few terms to proceed further:

(click to see it clearly)

centerPosition – This is the position for which LPS length is calculated and let’s say LPS length at
centerPosition is d (i.e. L[centerPosition] = d)
centerRightPosition – This is the position which is right to the centerPosition and d position away
from centerPosition (i.e. centerRightPosition = centerPosition + d )
centerLeftPosition – This is the position which is left to the centerPosition and d position away
from centerPosition (i.e. centerLeftPosition = centerPosition – d )
currentRightPosition – This is the position which is right of the centerPosition for which LPS
length is not yet known and has to be calculated
currentLeftPosition – This is the position on the left side of centerPosition which corresponds to
the currentRightPosition
centerPosition – currentLeftPosition = currentRightPosition – centerPosition
currentLeftPosition = 2* centerPosition – currentRightPosition
i-left palindrome – The palindrome i positions left of centerPosition, i.e. at currentLeftPosition
i-right palindrome – The palindrome i positions right of centerPosition, i.e. at currentRightPosition
center palindrome – The palindrome at centerPosition
When we are at centerPosition for which LPS length is known, then we also know LPS length of all positions
smaller than centerPosition. Let’s say LPS length at centerPosition is d, i.e.
L[centerPosition] = d
It means that substring between positions “centerPosition-d” to “centerPosition+d” is a palindrom.

Now we proceed further to calculate LPS length of positions greater than centerPosition.
Let’s say we are at currentRightPosition ( > centerPosition) where we need to find LPS length.
For this we look at LPS length of currentLeftPosition which is already calculated.
If LPS length of currentLeftPosition is less than “centerRightPosition – currentRightPosition”, then LPS
length of currentRightPosition will be equal to LPS length of currentLeftPosition. So
L[currentRightPosition] = L[currentLeftPosition] if L[currentLeftPosition] < centerRightPosition –
currentRightPosition. This is Case 1.
Let’s consider below scenario for string “abababa”:


We have calculated LPS length up-to position 7 where L[7] = 7, if we consider position 7 as centerPosition,
then centerLeftPosition will be 0 and centerRightPosition will be 14.
Now we need to calculate LPS length of other positions on the right of centerPosition.
For currentRightPosition = 8, currentLeftPosition is 6 and L[currentLeftPosition] = 0

Also centerRightPosition – currentRightPosition = 14 – 8 = 6
Case 1 applies here and so L[currentRightPosition] = L[8] = 0
Case 1 applies to positions 10 and 12, so,
L[10] = L[4] = 0
L[12] = L[2] = 0
If we look at position 9, then:

currentRightPosition = 9
currentLeftPosition = 2* centerPosition – currentRightPosition = 2*7 – 9 = 5
centerRightPosition – currentRightPosition = 14 – 9 = 5
Here L[currentLeftPosition] = centerRightPosition – currentRightPosition, so Case 1 doesn’t apply here.

Also note that centerRightPosition is the extreme end position of the string. That means center palindrome
is suffix of input string. In that case, L[currentRightPosition] = L[currentLeftPosition]. This is Case 2.
Case 2 applies to positions 9, 11, 13 and 14, so:

L[9] = L[5] = 5
L[11] = L[3] = 3
L[13] = L[1] = 1
L[14] = L[0] = 0
What is really happening in Case 1 and Case 2? This is just utilizing the palindromic symmetric property and
without any character match, it is finding LPS length of new positions.
When a bigger length palindrome contains a smaller length palindrome centered at left side of it’s own
center, then based on symmetric property, there will be another same smaller palindrome centered on the
right of bigger palindrome center. If left side smaller palindrome is not prefix of bigger palindrome, then
Case 1 applies and if it is a prefix AND bigger palindrome is suffix of the input string itself, then
Case 2
applies.
The longest palindrome i places to the right of the current center (the i-right palindrome) is as long as the
longest palindrome i places to the left of the current center (the i-left palindrome) if the i-left palindrome is
completely contained in the longest palindrome around the current center (the center palindrome) and the
i-left palindrome is not a prefix of the center palindrome (Case 1) or (i.e. when i-left palindrome is a prefix
of center palindrome) if the center palindrome is a suffix of the entire string (Case 2).
In Case 1 and Case 2, i-right palindrome can’t expand more than corresponding i-left palindrome (can you
visualize why it can’t expand more?), and so LPS length of i-right palindrome is exactly same as LPS length
of i-left palindrome.
Here both i-left and i-right palindromes are completely contained in center palindrome (i.e.
L[currentLeftPosition] <= centerRightPosition – currentRightPosition)
Now if i-left palindrome is not a prefix of center palindrome (L[currentLeftPosition] < centerRightPosition –
currentRightPosition), that means that i-left palindrome was not able to expand up-to position
centerLeftPosition.
If we look at following with centerPosition = 11, then


centerLeftPosition would be 11 – 9 = 2, and centerRightPosition would be 11 + 9 = 20

If we take currentRightPosition = 15, it’s currentLeftPosition is 7. Case 1 applies here and so L[15] = 3. i-left
palindrome at position 7 is “bab” which is completely contained in center palindrome at position 11 (which is
“dbabcbabd”). We can see that i-right palindrome (at position 15) can’t expand more than i-left palindrome
(at position 7).
If there was a possibility of expansion, i-left palindrome could have expanded itself more already. But there
is no such possibility as i-left palindrome is prefix of center palindrome. So due to symmetry property, i-
right palindrome will be exactly same as i-left palindrome and it can’t expand more. This makes
L[currentRightPosition] = L[currentLeftPosition] in Case 1.
Now if we consider centerPosition = 19, then centerLeftPosition = 12 and centerRightPosition = 26

If we take currentRightPosition = 23, it’s currentLeftPosition is 15. Case 2 applies here and so L[23] = 3. i-
left palindrome at position 15 is “bab” which is completely contained in center palindrome at position 19
(which is “babdbab”). In Case 2, where i-left palindrome is prefix of center palindrome, i-right palindrome
can’t expand more than length of i-left palindrome because center palindrome is suffix of input string so
there are no more character left to compare and expand. This makes L[currentRightPosition] =
L[currentLeftPosition] in Case 2.
Case 1: L[currentRightPosition] = L[currentLeftPosition] applies when:
i-left palindrome is completely contained in center palindrome

i-left palindrome is NOT a prefix of center palindrome
Both above conditions are satisfied when

L[currentLeftPosition] < centerRightPosition – currentRightPosition
Case 2: L[currentRightPosition] = L[currentLeftPosition] applies when:
i-left palindrome is prefix of center palindrome (means completely contained also)

center palindrome is suffix of input string
Above conditions are satisfied when

L[currentLeftPosition] = centerRightPosition – currentRightPosition (For 1st condition) AND
centerRightPosition = 2*N where N is input string length N (For 2nd condition).
Case 3: L[currentRightPosition] > = L[currentLeftPosition] applies when:
i-left palindrome is prefix of center palindrome (and so i-left palindrome is completely contained in
center palindrome)
center palindrome is NOT suffix of input string
Above conditions are satisfied when

L[currentLeftPosition] = centerRightPosition – currentRightPosition (For 1st condition) AND
centerRightPosition < 2*N where N is input string length N (For 2nd condition).
In this case, there is a possibility of i-right palindrome expansion and so length of i-right palindrome is at
least as long as length of i-left palindrome.
Case 4: L[currentRightPosition] > = centerRightPosition – currentRightPosition applies when:
i-left palindrome is NOT completely contained in center palindrome
Above condition is satisfied when

L[currentLeftPosition] > centerRightPosition – currentRightPosition
In this case, length of i-right palindrome is at least as long (centerRightPosition – currentRightPosition) and
there is a possibility of i-right palindrome expansion.
In following figure,


If we take center position 7, then Case 3 applies at currentRightPosition 11 because i-left palindrome at
currentLeftPosition 3 is a prefix of center palindrome and i-right palindrome is not suffix of input string, so
here L[11] = 9, which is greater than i-left palindrome length L[3] = 3. In the case, it is guaranteed that L[11]
will be at least 3, and so in implementation, we 1st set L[11] = 3 and then we try to expand it by comparing
characters in left and right side starting from distance 4 (As up-to distance 3, it is already known that
characters will match).
If we take center position 11, then Case 4 applies at currentRightPosition 15 because L[currentLeftPosition] =
L[7] = 7 > centerRightPosition – currentRightPosition = 20 – 15 = 5. In the case, it is guaranteed that L[15]
will be at least 5, and so in implementation, we 1st set L[15] = 5 and then we try to expand it by comparing
characters in left and right side starting from distance 5 (As up-to distance 5, it is already known that
characters will match).
Now one point left to discuss is, when we work at one center position and compute LPS lengths for different
rightPositions, how to know that what would be next center position. We change centerPosition to
currentRightPosition if palindrome centered at currentRightPosition expands beyond centerRightPosition.
Here we have seen four different cases on how LPS length of a position will depend on a previous position’s
LPS length.
In Part 3, we have discussed code implementation of it and also we have looked at these four cases in a
different way and implement that too.
1
Given a string, find the longest substring which is palindrome.
if the given string is “forgeeksskeegfor”, the output should be “geeksskeeg”

if the given string is “abaaba”, the output should be “abaaba”
if the given string is “abababa”, the output should be “abababa”
if the given string is “abcbabcbabcba”, the output should be “abcbabcba”
We have already discussed Naïve [O(n3)] and quadratic [O(n2)] approaches at Set 1 and Set 2.
In this article, we will talk about Manacher’s algorithm which finds Longest Palindromic Substring in linear
time.
One way (Set 2) to find a palindrome is to start from the center of the string and compare characters in both
directions one by one. If corresponding characters on both sides (left and right of the center) match, then
they will make a palindrome.
Let’s consider string “abababa”.
Here center of the string is 4th character (with index 3) b. If we match characters in left and right of the
center, all characters match and so string “abababa” is a palindrome.
Here center position is not only the actual string character position but it could be the position between two
characters also.
Consider string “abaaba” of even length. This string is palindrome around the position between 3rd and 4th
characters a and a respectively.
To find Longest Palindromic Substring of a string of length N, one way is take each possible 2*N + 1 centers
(the N character positions, N-1 between two character positions and 2 positions at left and right ends), do
the character match in both left and right directions at each 2*N+ 1 centers and keep track of LPS. This
approach takes O(N^2) time and that’s what we are doing in Set 2.
Let’s consider two strings “abababa” and “abaaba” as shown below:

In these two strings, left and right side of the center positions (position 7 in 1st string and position 6 in 2nd
string) are symmetric. Why? Because the whole string is palindrome around the center position.
If we need to calculate Longest Palindromic Substring at each 2*N+1 positions from left to right, then
palindrome’s symmetric property could help to avoid some of the unnecessary computations (i.e. character
comparison). If there is a palindrome of some length L cantered at any position P, then we may not need to
compare all characters in left and right side at position P+1. We already calculated LPS at positions before P
and they can help to avoid some of the comparisons after position P.
This use of information from previous positions at a later point of time makes the Manacher’s algorithm
linear. In Set 2, there is no reuse of previous information and so that is quadratic.
Manacher’s algorithm is probably considered complex to understand, so here we will discuss it in as detailed
way as we can. Some of it’s portions may require multiple reading to understand it properly.
Let’s look at string “abababa”. In 3rd figure above, 15 center positions are shown. We need to calculate
length of longest palindromic string at each of these positions.
At position 0, there is no LPS at all (no character on left side to compare), so length of LPS will be 0.
At position 1, LPS is a, so length of LPS will be 1.
At position 2, there is no LPS at all (left and right characters a and b don’t match), so length of LPS
will be 0.
At position 3, LPS is aba, so length of LPS will be 3.
At position 4, there is no LPS at all (left and right characters b and a don’t match), so length of LPS
will be 0.
At position 5, LPS is ababa, so length of LPS will be 5.
…… and so on
We store all these palindromic lengths in an array, say L. Then string S and LPS Length L look like below:

Similarly, LPS Length L of string “abaaba” will look like:
In LPS Array L:
LPS length value at odd positions (the actual character positions) will be odd and greater than or
equal to 1 (1 will come from the center character itself if nothing else matches in left and right side of
it)
LPS length value at even positions (the positions between two characters, extreme left and right
positions) will be even and greater than or equal to 0 (0 will come when there is no match in left and
right side)
Position and index for the string are two different things here. For a given string S of length
N, indexes will be from 0 to N-1 (total N indexes) and positions will be from 0 to 2*N (total
2*N+1 positions).
LPS length value can be interpreted in two ways, one in terms of index and second in terms of position. LPS
value d at position I (L[i] = d) tells that:
Substring from position i-d to i+d is a palindrome of length d (in terms of position)
Substring from index (i-d)/2 to [(i+d)/2 – 1] is a palindrome of length d (in terms of index)
e.g. in string “abaaba”, L[3] = 3 means substring from position 0 (3-3) to 6 (3+3) is a palindrome which is
“aba” of length 3, it also means that substring from index 0 [(3-3)/2] to 2 [(3+3)/2 – 1] is a palindrome
which is “aba” of length 3.
Now the main task is to compute LPS array efficiently. Once this array is computed, LPS of string S will be
centered at position with maximum LPS length value.
We will see it in Part 2.
How to Implement Forward DNS Look Up Cache?
We have discussed implementation of Reverse DNS Look Up Cache. Forward DNS look up is getting IP
address for a given domain name typed in the web browser.
The cache should do the following operations :

1. Add a mapping from URL to IP address
2. Find IP address for a given URL.
There are a few changes from reverse DNS look up cache that we need to incorporate.
1. Instead of [0-9] and (.) dot we need to take care of [A-Z], [a-z] and (.) dot. As most of the domain name
contains only lowercase characters we can assume that there will be [a-z] and (.) 27 children for each trie
node.
2. When we type www.google.in and google.in the browser takes us to the same page. So, we need to add a
domain name into trie for the words after www(.). Similarly while searching for a domain name
corresponding IP address remove the www(.) if the user has provided it.
This is left as an exercise and for simplicity we have taken care of www. also.
One solution is to use Hashing. In this post, a Trie based solution is discussed. One advantage of Trie based
solutions is, worst case upper bound is O(1) for Trie, for hashing, the best possible average case time
complexity is O(1). Also, with Trie we can implement prefix search (finding all IPs for a common prefix of
URLs). The general disadvantage of Trie is large amount of memory requirement.
The idea is to store URLs in Trie nodes and store the corresponding IP address in last or leaf node.
Following is C style implementation in C++.
// C based program to implement reverse DNS lookup

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
// There are atmost 27 different chars in a valid URL

// assuming URL consists [a-z] and (.)
#define CHARS 27
// Maximum length of a valid URL

#define MAX 100
// A utility function to find index of child for a given character 'c'

int getIndex(char c)
{
return (c == '.') ? 26 : (c - 'a');
}
// A utility function to find character for a given child index.

char getCharFromIndex(int i)
{
return (i == 26) ? '.' : ('a' + i);
}
// Trie Node.
struct trieNode
{
bool isLeaf;
char *ipAdd;
struct trieNode *child[CHARS];
};
};

{
newNode->isLeaf = false;
newNode->ipAdd = NULL;
for (int i = 0; i<CHARS; i++)
return newNode;
}
// This method inserts a URL and corresponding IP address

// in the trie. The last node in Trie contains the ip address.
void insert(struct trieNode *root, char *URL, char *ipAdd)
{
// Length of the URL
int len = strlen(URL);
// Traversing over the length of the URL.

for (int level = 0; level<len; level++)
{
// in URL[] Index must be from 0 to 26 where
// 0 to 25 is used for alphabets and 26 for dot
int index = getIndex(URL[level]);


}
//Below needs to be carried out for the last node.

//Save the corresponding ip address of the URL in the
//last node of trie.
pCrawl->isLeaf = true;
pCrawl->ipAdd = new char[strlen(ipAdd) + 1];
strcpy(pCrawl->ipAdd, ipAdd);
}
// This function returns IP address if given URL is

// present in DNS cache. Else returns NULL
char *searchDNSCache(struct trieNode *root, char *URL)
{
// Root node of trie.
int len = strlen(URL);
// Traversal over the length of URL.

{
int index = getIndex(URL[level]);
return NULL;
}
// If we find the last node for a given ip address,

// print the ip address.
if (pCrawl != NULL && pCrawl->isLeaf)
if (pCrawl != NULL && pCrawl->isLeaf)
return pCrawl->ipAdd;
return NULL;
}
// Driver function.
int main()
{
char URL[][50] = { "www.samsung.com", "www.samsung.net",
"www.google.in"
};
char ipAdd[][MAX] = { "107.108.11.123", "107.109.123.255",
"74.125.200.106"
};
int n = sizeof(URL) / sizeof(URL[0]);
// Inserts all the domain name and their corresponding

// ip address
insert(root, URL[i], ipAdd[i]);
// If forward DNS look up succeeds print the url along

// with the resolved ip address.
char url[] = "www.samsung.com";
char *res_ip = searchDNSCache(root, url);
if (res_ip != NULL)
printf("Forward DNS look up resolved in cache:\n%s --> %s",
url, res_ip);
else
printf("Forward DNS look up not resolved in cache ");
return 0;
}

Output:
Forward DNS look up resolved in cache:

www.samsung.com --> 107.108.11.123

3
In Manacher’s Algorithm Part 1 and Part 2, we gone through some of the basics, understood LPS length
array and how to calculate it efficiently based on four cases. Here we will implement the same.
We have seen that there are no new character comparison needed in case 1 and case 2. In case 3 and case 4,
necessary new comparison are needed.
In following figure,


If at all we need a comparison, we will only compare actual characters, which are at “odd” positions like 1, 3,
5, 7, etc.
Even positions do not represent a character in string, so no comparison will be preformed for even positions.
If two characters at different odd positions match, then they will increase LPS length by 2.
There are many ways to implement this depending on how even and odd positions are handled. One way
would be to create a new string 1 st where we insert some unique character (say #, $ etc) in all even positions
and then run algorithm on that (to avoid different way of even and odd position handling). Other way could
be to work on given string itself but here even and odd positions should be handled appropriately.
Here we will start with given string itself. When there is a need of expansion and character comparison
required, we will expand in left and right positions one by one. When odd position is found, comparison will
be done and LPS Length will be incremented by ONE. When even position is found, no comparison done
and LPS Length will be incremented by ONE (So overall, one odd and one even positions on both left and
right side will increase LPS Length by TWO).
// A C program to implement Manacher’s Algorithm

#include <stdio.h>
#include <string.h>
char text[100];
void findLongestPalindromicString()
{
int N = strlen(text);
if(N == 0)
return;
N = 2*N + 1; //Position count
int L[N]; //LPS Length Array
L[0] = 0;
L[1] = 1;
int C = 1; //centerPosition
int R = 2; //centerRightPosition
int i = 0; //currentRightPosition
int iMirror; //currentLeftPosition
int expand = -1;
int diff = -1;
int maxLPSLength = 0;
int maxLPSCenterPosition = 0;
int start = -1;
int end = -1;
int end = -1;

//Uncomment it to print LPS Length array
//printf("%d %d ", L[0], L[1]);
for (i = 2; i < N; i++)
{
//get currentLeftPosition iMirror for currentRightPosition i
iMirror = 2*C-i;
//Reset expand - means no expansion required
expand = 0;
diff = R - i;
//If currentRightPosition i is within centerRightPosition R
if(diff > 0)
{
if(L[iMirror] < diff) // Case 1
L[i] = L[iMirror];
else if(L[iMirror] == diff && i == N-1) // Case 2
L[i] = L[iMirror];
else if(L[iMirror] == diff && i < N-1) // Case 3
{
L[i] = L[iMirror];
expand = 1; // expansion required
}
else if(L[iMirror] > diff) // Case 4
{
L[i] = diff;
}
}
else
{
L[i] = 0;
}

if(expand == 1)
{
//Attempt to expand palindrome centered at currentRightPosition i
//Here for odd positions, we compare characters and
//if match then increment LPS Length by ONE
//If even position, we just increment LPS by ONE without
//any character comparison
while ( ((i + L[i]) < N && (i - L[i]) > 0) &&
( ((i + L[i] + 1) % 2 == 0) ||
(text[(i + L[i] + 1)/2] == text[(i - L[i] - 1)/2] )))
{
L[i]++;
}
}
if(L[i] > maxLPSLength) // Track maxLPSLength

{
maxLPSLength = L[i];
maxLPSCenterPosition = i;
}
// If palindrome centered at currentRightPosition i

// expand beyond centerRightPosition R,
// adjust centerPosition C based on expanded palindrome.
if (i + L[i] > R)
{
C = i;
R = i + L[i];
}
//printf("%d ", L[i]);
}
//printf("\n");
start = (maxLPSCenterPosition - maxLPSLength)/2;
end = start + maxLPSLength - 1;
//printf("start: %d end: %d\n", start, end);
printf("LPS of string is %s : ", text);
for(i=start; i<=end; i++)
printf("\n");
}

{
strcpy(text, "babcbabcbaccba");
findLongestPalindromicString();
strcpy(text, "abaaba");
strcpy(text, "abababa");
strcpy(text, "abcbabcbabcba");
strcpy(text, "forgeeksskeegfor");
strcpy(text, "caba");
strcpy(text, "abacdfgdcaba");
strcpy(text, "abacdfgdcabba");
strcpy(text, "abacdedcaba");
return 0;
}

Output:
LPS of string is babcbabcbaccba : abcbabcba

LPS of string is abaaba : abaaba
LPS of string is abababa : abababa
LPS of string is abcbabcbabcba : abcbabcbabcba
LPS of string is forgeeksskeegfor : geeksskeeg
LPS of string is caba : aba
LPS of string is abacdfgdcaba : aba
LPS of string is abacdfgdcabba : abba
LPS of string is abacdedcaba : abacdedcaba

This is the implementation based on the four cases discussed in Part 2. In Part 4, we have discussed a
different way to look at these four cases and few other approaches.
Diagonal Sum of a Binary Tree
Consider lines of slope -1 passing between nodes (dotted lines in below diagram). Diagonal sum in a binary
tree is sum of all node’s data lying between these lines. Given a Binary Tree, print all diagonal sums.
For the following input tree, output should be 9, 19, 42.

9 is sum of 1, 3 and 5.
19 is sum of 2, 6, 4 and 7.
42 is sum of 9, 10, 11 and 12.
We strongly recommend to minimize your browser and try this yourself first
Algorithm:
The idea is to keep track of vertical distance from top diagonal passing through root. We increment the
vertical distance we go down to next diagonal.
1. Add root with vertical distance as 0 to the queue.
2. Process the sum of all right child and right of right child and so on.
3. Add left child current node into the queue for later processing. The vertical distance of left child is vertical
distance of current node plus 1.
4. Keep doing 2nd, 3rd and 4th step till the queue is empty.
Following is Java implementation of above idea.
// Java Program to find diagonal sum in a Binary Tree

import java.util.*;
import java.util.Map.Entry;
//Tree node
class TreeNode
{
int data; //node data
int vd; //vertical distance diagonally
TreeNode left, right; //left and right child's reference
TreeNode left, right; //left and right child's reference
// Tree node constructor

public TreeNode(int data)
{
this.data = data;
vd = Integer.MAX_VALUE;
}
}
// Tree class
class Tree
{
TreeNode root;//Tree root
// Tree constructor
public Tree(TreeNode root) { this.root = root; }
// Diagonal sum method

public void diagonalSum()
{
// Queue which stores tree nodes
Queue<TreeNode> queue = new LinkedList<TreeNode>();
// Map to store sum of node's data lying diagonally

Map<Integer, Integer> map = new TreeMap<>();
// Assign the root's vertical distance as 0.

root.vd = 0;
// Add root node to the queue

queue.add(root);
// Loop while the queue is not empty

while (!queue.isEmpty())
{
// Remove the front tree node from queue.
TreeNode curr = queue.remove();
// Get the vertical distance of the dequeued node.

int vd = curr.vd;
// Sum over this node's right-child, right-of-right-child

// and so on
while (curr != null)
{
int prevSum = (map.get(vd) == null)? 0: map.get(vd);
map.put(vd, prevSum + curr.data);
// If for any node the left child is not null add

// it to the queue for future processing.
if (curr.left != null)
{
curr.left.vd = vd+1;
queue.add(curr.left);
}
// Move to the current node's right child.

curr = curr.right;
}
}
// Make an entry set from map.

// Make an iterator
Iterator<Entry<Integer, Integer>> iterator = set.iterator();
// Traverse the map elements using the iterator.

while (iterator.hasNext())
{
Map.Entry<Integer, Integer> me = iterator.next();
System.out.print(me.getValue()+" ");
}
}
}
//Driver class
public class DiagonalSum
{
{
root.left.left = new TreeNode(9);
root.right.left = new TreeNode(4);
root.right.right = new TreeNode(5);
root.right.left.left = new TreeNode(12);
root.right.left.right = new TreeNode(7);
root.left.right.left = new TreeNode(11);
root.left.left.right = new TreeNode(10);
Tree tree = new Tree(root);
tree.diagonalSum();
}
}

Output:

9, 19, 42

Exercise:
This problem was for diagonals from top to bottom and slope -1. Try the same problem for slope +1.
Longest Even Length Substring such that Sum of First and Second Half is
same
Given a string ‘str’ of digits, find length of the longest substring of ‘str’, such that the length of the substring is
2k digits and sum of left k digits is equal to the sum of right k digits.
Examples:
Input: str = "123123"

Output: 6
The complete string is of even length and sum of first and second
half digits is same
Input: str = "1538023"

Output: 4
The longest substring with same first and second half sum is "5380"

Simple Solution [ O(n3) ]

A Simple Solution is to check every substring of even length. The following is C based implementation of
simple approach.

// A simple C based program to find length of longest even length

// substring with same sum of digits in left and right
#include<stdio.h>
#include<string.h>
int findLength(char *str)

{
int maxlen =0; // Initialize result
// Choose starting point of every substring

{
// Choose ending point of even length substring
for (int j =i+1; j<n; j += 2)
{
int length = j-i+1;//Find length of current substr
// Calculate left & right sums for current substr

int leftsum = 0, rightsum =0;
for (int k =0; k<length/2; k++)
{
leftsum += (str[i+k]-'0');
rightsum += (str[i+k+length/2]-'0');
}
// Update result if needed

if (leftsum == rightsum && maxlen < length)
maxlen = length;
}
}
return maxlen;
}

int main(void)
{
char str[] = "1538023";
printf("Length of the substring is %d", findLength(str));
return 0;
}

Output:

Length of the substring is 4

Dynamic Programming [ O(n 2) and O(n2) extra space]

The above solution can be optimized to work in O(n2) using Dynamic Programming. The idea is to build
a 2D table that stores sums of substrings. The following is C based implementation of Dynamic
Programming approach.

// A C based program that uses Dynamic Programming to find length of the

// longest even substring with same sum of digits in left and right half
#include <stdio.h>
#include <string.h>
int findLength(char *str)

{
int maxlen = 0; // Initialize result
// A 2D table where sum[i][j] stores sum of digits

// from str[i] to str[j]. Only filled entries are
// the entries where j >= i
int sum[n][n];
// Fill the diagonal values for sunstrings of length 1

for (int i =0; i<n; i++)
sum[i][i] = str[i]-'0';
// Fill entries for substrings of length 2 to n

for (int len=2; len<=n; len++)
{
// Pick i and j for current substring
for (int i=0; i<n-len+1; i++)
{
int j = i+len-1;
int k = len/2;
// Calculate value of sum[i][j]

sum[i][j] = sum[i][j-k] + sum[j-k+1][j];
// Update result if 'len' is even, left and right

// sums are same and len is more than maxlen
if (len%2 == 0 && sum[i][j-k] == sum[(j-k+1)][j]
&& len > maxlen)
maxlen = len;
}
}
return maxlen;
}

int main(void)
{
char str[] = "153803";
printf("Length of the substring is %d", findLength(str));
return 0;
}

Output:


Time complexity of the above solution is O(n2), but it requires O(n2) extra space.
2
[A O(n2) and O(n) extra space solution]
The idea is to use a single dimensional array to store cumulative sum.
// A O(n^2) time and O(n) extra space solution

int findLength(string str, int n)

{
int sum[n+1]; // To store cumulative sum from first digit to nth digit
sum[0] = 0;
/* Store cumulative sum of digits from first to last digit */

for (int i = 1; i <= n; i++)
sum[i] = (sum[i-1] + str[i-1] - '0'); /* convert chars to int */
int ans = 0; // initialize result
/* consider all even length substrings one by one */

for (int len = 2; len <= n; len += 2)
{
for (int i = 0; i <= n-len; i++)
{
int j = i + len - 1;
/* Sum of first and second half is same than update ans */

if (sum[i+len/2] - sum[i] == sum[i+len] - sum[i+len/2])
ans = max(ans, len);
}
}
return ans;
}

int main()
{
string str = "123123";
cout << "Length of the substring is " << findLength(str, str.length());
return 0;
}

Output:


[A O(n2) time and O(1) extra space solution]

The idea is to consider all possible mid points (of even length substrings) and keep expanding on both sides
to get and update optimal length as the sum of two sides become equal.
Below is C++ implementation of the above idea.

// A O(n^2) time and O(1) extra space solution

int findLength(string str, int n)

{
int ans = 0; // Initialize result
// Consider all possible midpoints one by one

for (int i = 0; i <= n-2; i++)
{
/* For current midpoint 'i', keep expanding substring on
both sides, if sum of both sides becomes equal update
ans */
int l = i, r = i + 1;
/* initialize left and right sum */

int lsum = 0, rsum = 0;
/* move on both sides till indexes go out of bounds */

while (r < n && l >= 0)
{
lsum += str[l] - '0';
rsum += str[r] - '0';
if (lsum == rsum)
ans = max(ans, r-l+1);
l--;
r++;
}
}
return ans;
}

int main()
{
cout << "Length of the substring is " << findLength(str, str.length());
return 0;
}

Output:


Nuts & Bolts Problem (Lock & Key problem)
Given a set of n nuts of different sizes and n bolts of different sizes. There is a one-one mapping between
nuts and bolts. Match nuts and bolts efficiently.
Constraint: Comparison of a nut to another nut or a bolt to another bolt is not allowed. It means nut can
only be compared with bolt and bolt can only be compared with nut to see which one is bigger/smaller.
Other way of asking this problem is, given a box with locks and keys where one lock can be opened by one
key in the box. We need to match the pair.
Brute force Way: Start with the first bolt and compare it with each nut until we find a match. In the worst
case we require n comparisons. Doing this for all bolts gives us O(n^2) complexity.
Quick Sort Way: We can use quick sort technique to solve this. We represent nuts and bolts in character
array for understanding the logic.
Nuts represented as array of character

char nuts[] = {‘@’, ‘#’, ‘$’, ‘%’, ‘^’, ‘&’}
Bolts represented as array of character

char bolts[] = {‘$’, ‘%’, ‘&’, ‘^’, ‘@’, ‘#’}
This algorithm first performs a partition by picking last element of bolts array as pivot, rearrange the array
of nuts and returns the partition index ‘i’ such that all nuts smaller than nuts[i] are on the left side and all
nuts greater than nuts[i] are on the right side. Next using the nuts[i] we can partition the array of bolts.
Partitioning operations can easily be implemented in O(n). This operation also makes nuts and bolts array
nicely partitioned. Now we apply this partitioning recursively on the left and right sub-array of nuts and
bolts.
As we apply partitioning on nuts and bolts both so the total time complexity will be Θ(2*nlogn) = Θ(nlogn)
on average.
Here for the sake of simplicity we have chosen last element always as pivot. We can do randomized quick
sort too.
A Java based implementation of idea is below:
// Java program to solve nut and bolt problem using Quick Sort
public class NutsAndBoltsMatch
{
//Driver method
{
// Nuts and bolts are represented as array of characters
char nuts[] = {'@', '#', '$', '%', '^', '&'};
char bolts[] = {'$', '%', '&', '^', '@', '#'};
// Method based on quick sort which matches nuts and bolts

matchPairs(nuts, bolts, 0, 5);
System.out.println("Matched nuts and bolts are : ");

printArray(nuts);
printArray(bolts);
}
// Method to print the array

private static void printArray(char[] arr) {
for (char ch : arr){
System.out.print(ch + " ");
System.out.print(ch + " ");
}
System.out.print("\n");
}
// Method which works just like quick sort

private static void matchPairs(char[] nuts, char[] bolts, int low,
int high)
{
if (low < high)
{
// Choose last character of bolts array for nuts partition.
int pivot = partition(nuts, low, high, bolts[high]);
// Now using the partition of nuts choose that for bolts

// partition.
partition(bolts, low, high, nuts[pivot]);
// Recur for [low...pivot-1] & [pivot+1...high] for nuts and

// bolts array.
matchPairs(nuts, bolts, low, pivot-1);
matchPairs(nuts, bolts, pivot+1, high);
}
}
// Similar to standard partition method. Here we pass the pivot element

// too instead of choosing it inside the method.
private static int partition(char[] arr, int low, int high, char pivot)
{
int i = low;
char temp1, temp2;
for (int j = low; j < high; j++)
{
if (arr[j] < pivot){
temp1 = arr[i];
arr[i] = arr[j];
arr[j] = temp1;
i++;
} else if(arr[j] == pivot){
temp1 = arr[j];
arr[j] = arr[high];
arr[high] = temp1;
j--;
}
}
temp2 = arr[i];
arr[i] = arr[high];
arr[high] = temp2;
// Return the partition index of an array based on the pivot

// element of other array.
return i;
}
}

Output:

Matched nuts and bolts are :

# $ % & @ ^
# $ % & @ ^

4
In Manacher’s Algorithm Part 1 and Part 2, we gone through some of the basics, understood LPS length
array and how to calculate it efficiently based on four cases. In Part 3, we implemented the same.
Here we will review the four cases again and try to see it differently and implement the same.
All four cases depends on LPS length value at currentLeftPosition (L[iMirror]) and value of
(centerRightPosition – currentRightPosition), i.e. (R – i). These two information are know before which
helps us to reuse previous available information and avoid unnecessary character comparison.


If we look at all four cases, we will see that we 1st set minimum of L[iMirror] and R-i to L[i] and then we
try to expand the palindrome in whichever case it can expand.
Above observation may look more intuitive, easier to understand and implement, given that one
understands LPS length array, position, index, symmetry property etc.
// A C program to implement Manacher’s Algorithm

#include <stdio.h>
#include <string.h>
char text[100];
{
int res = a;
if(b < a)
res = b;
return res;
}
void findLongestPalindromicString()
{
int N = strlen(text);
if(N == 0)
return;
N = 2*N + 1; //Position count
int L[N]; //LPS Length Array
L[0] = 0;
L[1] = 1;
int C = 1; //centerPosition
int R = 2; //centerRightPosition
int i = 0; //currentRightPosition
int iMirror; //currentLeftPosition
int maxLPSLength = 0;
int maxLPSCenterPosition = 0;
int start = -1;
int end = -1;
int diff = -1;

//printf("%d %d ", L[0], L[1]);
for (i = 2; i < N; i++)
{
//get currentLeftPosition iMirror for currentRightPosition i
iMirror = 2*C-i;
L[i] = 0;
diff = R - i;
//If currentRightPosition i is within centerRightPosition R
if(diff > 0)
L[i] = min(L[iMirror], diff);
//Attempt to expand palindrome centered at currentRightPosition i

//Here for odd positions, we compare characters and
//if match then increment LPS Length by ONE
//If even position, we just increment LPS by ONE without
//any character comparison
while ( ((i + L[i]) < N && (i - L[i]) > 0) &&
( ((i + L[i] + 1) % 2 == 0) ||
(text[(i + L[i] + 1)/2] == text[(i - L[i] - 1)/2] )))
{
L[i]++;
}
if(L[i] > maxLPSLength) // Track maxLPSLength

{
maxLPSLength = L[i];
maxLPSCenterPosition = i;
}
//If palindrome centered at currentRightPosition i

//expand beyond centerRightPosition R,
//adjust centerPosition C based on expanded palindrome.
if (i + L[i] > R)
{
C = i;
R = i + L[i];
}
//printf("%d ", L[i]);
}
//printf("\n");
start = (maxLPSCenterPosition - maxLPSLength)/2;
end = start + maxLPSLength - 1;
printf("LPS of string is %s : ", text);
for(i=start; i<=end; i++)
printf("\n");
}

{
strcpy(text, "babcbabcbaccba");
strcpy(text, "abaaba");
strcpy(text, "abababa");
strcpy(text, "abcbabcbabcba");
strcpy(text, "forgeeksskeegfor");
strcpy(text, "caba");
strcpy(text, "abacdfgdcaba");
strcpy(text, "abacdfgdcabba");
strcpy(text, "abacdedcaba");
return 0;
}

Output:
LPS of string is babcbabcbaccba : abcbabcba

LPS of string is abaaba : abaaba
LPS of string is abababa : abababa
LPS of string is abcbabcbabcba : abcbabcbabcba
LPS of string is forgeeksskeegfor : geeksskeeg
LPS of string is caba : aba
LPS of string is abacdfgdcaba : aba
LPS of string is abacdfgdcabba : abba
LPS of string is abacdedcaba : abacdedcaba

Other Approaches
We have discussed two approaches here. One in Part 3 and other in current article. In both approaches, we
worked on given string. Here we had to handle even and odd positions differently while comparing
characters for expansion (because even positions do not represent any character in string).
To avoid this different handling of even and odd positions, we need to make even positions also to represent
some character (actually all even positions should represent SAME character because they MUST match
while character comparison). One way to do this is to set some character at all even positions by modifying
given string or create a new copy of given string. For example, if input string is “abcb”, new string should be
“#a#b#c#b#” if we add # as unique character at even positions.
The two approaches discussed already can be modified a bit to work on modified string where different
handling of even and odd positions will not be needed.
We may also add two DIFFERENT characters (not yet used anywhere in string at even and odd positions) at
start and end of string as sentinels to avoid bound check. With these changes string “abcb” will look like
“^#a#b#c#b#$” where ^ and $ are sentinels.
This implementation may look cleaner with the cost of more memory.
We are not implementing these here as it’s a simple change in given implementations.
Implementation of approach discussed in current article on a modified string can be found at Longest
Palindromic Substring Part II and a Java Translation of the same by Princeton.
Find the closest leaf in a Binary Tree
Given a Binary Tree and a key ‘k’, find distance of the closest leaf from ‘k’.
Examples:
A
/ \
B C
/ \
E F
/ \
G H
/ \ /
I J K
Closest leaf to 'H' is 'K', so distance is 1 for 'H'

Closest leaf to 'C' is 'B', so distance is 2 for 'C'
Closest leaf to 'E' is either 'I' or 'J', so distance is 2 for 'E'
Closest leaf to 'B' is 'B' itself, so distance is 0 for 'B'

The main point to note here is that a closest key can either be a descendent of given key or can be reached
through one of the ancestors.
The idea is to traverse the given tree in preorder and keep track of ancestors in an array. When we reach the
given key, we evaluate distance of the closest leaf in subtree rooted with given key. We also traverse all
ancestors one by one and find distance of the closest leaf in the subtree rooted with ancestor. We compare all
distances and return minimum.
// A C++ program to find the closesr leaf of a given key in Binary Tree
#include <iostream>
#include <climits>
/* A binary tree Node has key, pocharer to left and right children */
struct Node
{
char key;
};

given data and NULL left and right pocharers. */
Node *newNode(char k)
{
node->key = k;
return node;
}
// A utility function to find minimum of x and y

int getMin(int x, int y)
{
return (x < y)? x :y;
}
}
// A utility function to find distance of closest leaf of the tree

// rooted under given root
int closestDown(struct Node *root)
{
// Base cases
if (root == NULL)
return INT_MAX;
return 0;
// Return minimum of left and right, plus one

return 1 + getMin(closestDown(root->left), closestDown(root->right));
}
// Returns distance of the cloest leaf to a given key 'k'. The array
// ancestors is used to keep track of ancestors of current node and
// 'index' is used to keep track of curremt index in 'ancestors[]'
int findClosestUtil(struct Node *root, char k, struct Node *ancestors[],
int index)
{
// Base case
if (root == NULL)
return INT_MAX;
// If key found
if (root->key == k)
{
// Find the cloest leaf under the subtree rooted with given key
int res = closestDown(root);
// Traverse all ancestors and update result if any parent node

// gives smaller distance
for (int i = index-1; i>=0; i--)
res = getMin(res, index - i + closestDown(ancestors[i]));
return res;
}
// If key node found, store current node and recur for left and
// right childrens
ancestors[index] = root;
return getMin(findClosestUtil(root->left, k, ancestors, index+1),
findClosestUtil(root->right, k, ancestors, index+1));
// The main function that returns distance of the closest key to 'k'. It
// mainly uses recursive function findClosestUtil() to find the closes
// distance.
int findClosest(struct Node *root, char k)
{
// Create an array to store ancestors
// Assumptiom: Maximum height of tree is 100
struct Node *ancestors[100];
return findClosestUtil(root, k, ancestors, 0);

}

int main()
{
struct Node *root = newNode('A');
root->left = newNode('B');
root->left = newNode('B');
root->right = newNode('C');
root->right->left = newNode('E');
root->right->right = newNode('F');
root->right->left->left = newNode('G');
root->right->left->left->left = newNode('I');
root->right->left->left->right = newNode('J');
root->right->right->right = newNode('H');
root->right->right->right->left = newNode('K');
char k = 'H';
cout << "Distace of the closest key from " << k << " is "
<< findClosest(root, k) << endl;
k = 'C';
k = 'E';
k = 'B';
return 0;
}

Output:

Distace of the closest key from H is 1
Distace of the closest key from C is 2
Distace of the closest key from E is 2
Distace of the closest key from B is 0

The above code can be optimized by storing the left/right information also in ancestor array. The idea is, if
given key is in left subtree of an ancestors, then there is no point to call closestDown(). Also, the loop can
that traverses ancestors array can be optimized to not traverse ancestors which are at more distance than
current result.
Exercise:
Extend the above solution to print not only distance, but the key of closest leaf also.
This article is contributed by Shubham. Please write comments if you find anything incorrect, or you want to
Print all possible strings that can be made by placing spaces
Given a string you need to print all possible strings that can be made by placing spaces (zero or one) in
between them.
Input: str[] = "ABC"

Output: ABC
AB C
A BC
A B C

Source: Amazon Interview Experience | Set 158, Round 1 ,Q 1.
The idea is to use recursion and create a buffer that one by one contains all output strings having spaces. We
keep updating buffer in every recursive call. If the length of given string is ‘n’ our updated string can have
maximum length of n + (n-1) i.e. 2n-1. So we create buffer size of 2n (one extra character for string
termination).
We leave 1st character as it is, starting from the 2nd character, we can either fill a space or a character. Thus
one can write a recursive function like below.

// C++ program to print permutations of a given string with spaces.

#include <iostream>
#include <cstring>
/* Function recursively prints the strings having space pattern.

i and j are indices in 'str[]' and 'buff[]' respectively */
void printPatternUtil(char str[], char buff[], int i, int j, int n)
{
if (i==n)
{
buff[j] = '\0';
cout << buff << endl;
return;
}
// Either put the character

buff[j] = str[i];
printPatternUtil(str, buff, i+1, j+1, n);
// Or put a space followed by next character

buff[j] = ' ';
buff[j+1] = str[i];
printPatternUtil(str, buff, i+1, j+2, n);

}
// This function creates buf[] to store individual output string and uses
// printPatternUtil() to print all permutations.
void printPattern(char *str)
{
// Buffer to hold the string containing spaces

char buf[2*n]; // 2n-1 characters and 1 string terminator
// Copy the first character as it is, since it will be always

// at first position
buf[0] = str[0];
printPatternUtil(str, buf, 1, 1, n);

}

int main()
{
char *str = "ABCDE";
printPattern(str);
return 0;
}

Output:

ABCD
ABC D
AB CD
AB C D
A BCD
A BC D
A B CD
A B C D

Time Complexity: Since number of Gaps are n-1, there are total 2^(n-1) patters each having length ranging
from n to 2n-1. Thus overall complexity would be O(n*(2^n)).
This article is contributed by Gaurav Sharma. Please write comments if you find anything incorrect, or
Given a matrix of ‘O’ and ‘X’, find the largest subsquare surrounded by ‘X’
Given a matrix where every element is either ‘O’ or ‘X’, find the largest subsquare surrounded by ‘X’.
In the below article, it is assumed that the given matrix is also square matrix. The code given below can be
easily extended for rectangular matrices.
Examples:
Input: mat[N][N] = { {'X', 'O', 'X', 'X', 'X'},

{'X', 'X', 'X', 'X', 'X'},
{'X', 'X', 'O', 'X', 'O'},
{'X', 'X', 'X', 'X', 'X'},
{'X', 'X', 'X', 'O', 'O'},
};
Output: 3
The square submatrix starting at (1, 1) is the largest
submatrix surrounded by 'X'
Input: mat[M][N] = { {'X', 'O', 'X', 'X', 'X', 'X'},

{'X', 'O', 'X', 'X', 'O', 'X'},
{'X', 'X', 'X', 'O', 'O', 'X'},
{'X', 'X', 'X', 'X', 'X', 'X'},
{'X', 'X', 'X', 'O', 'X', 'O'},
};
Output: 4
The square submatrix starting at (0, 2) is the largest
submatrix surrounded by 'X'

A Simple Solution is to consider every square submatrix and check whether is has all corner edges filled
with ‘X’. The time complexity of this solution is O(N4).
We can solve this problem in O(N 3) time using extra space. The idea is to create two auxiliary arrays
hor[N][N] and ver[N][N]. The value stored in hor[i][j] is the number of horizontal continuous ‘X’ characters
till mat[i][j] in mat[][]. Similarly, the value stored in ver[i][j] is the number of vertical continuous ‘X’
characters till mat[i][j] in mat[][]. Following is an example.

mat[6][6] = X O X X X X
X O X X O X
X X X O O X
O X X X X X
X X X O X O
O O X O O O
hor[6][6] = 1 0 1 2 3 4
1 0 1 2 0 1
1 2 3 0 0 1
0 1 2 3 4 5
1 2 3 0 1 0
0 0 1 0 0 0
ver[6][6] = 1 0 1 1 1 1
2 0 2 2 0 2
3 1 3 0 0 3
0 2 4 1 1 4
1 3 5 0 2 0
0 0 6 0 0 0

Once we have filled values in hor[][] and ver[][], we start from the bottommost-rightmost corner of matrix
and move toward the leftmost-topmost in row by row manner. For every visited entry mat[i][j], we compare
the values of hor[i][j] and ver[i][j], and pick the smaller of two as we need a square. Let the smaller of two be
‘small’. After picking smaller of two, we check if both ver[][] and hor[][] for left and up edges respectively. If
they have entries for the same, then we found a subsquare. Otherwise we try for small-1.
// A C++ program to find the largest subsquare

// surrounded by 'X' in a given matrix of 'O' and 'X'
#include<iostream>
// Size of given matrix is N X N

#define N 6

int getMin(int x, int y) { return (x<y)? x: y; }
// Returns size of maximum size subsquare matrix

// surrounded by 'X'
int findSubSquare(int mat[][N])
{
int max = 1; // Initialize result
// Initialize the left-top value in hor[][] and ver[][]

int hor[N][N], ver[N][N];
hor[0][0] = ver[0][0] = (mat[0][0] == 'X');
// Fill values in hor[][] and ver[][]

for (int i=0; i<N; i++)
{
{
{
if (mat[i][j] == 'O')
ver[i][j] = hor[i][j] = 0;
else
{
hor[i][j] = (j==0)? 1: hor[i][j-1] + 1;
ver[i][j] = (i==0)? 1: ver[i-1][j] + 1;
}
}
}
// Start from the rightmost-bottommost corner element and find

// the largest ssubsquare with the help of hor[][] and ver[][]
for (int i = N-1; i>=1; i--)
{
for (int j = N-1; j>=1; j--)
{
// Find smaller of values in hor[][] and ver[][]
// A Square can only be made by taking smaller
// value
int small = getMin(hor[i][j], ver[i][j]);
// At this point, we are sure that there is a right

// vertical line and bottom horizontal line of length
// at least 'small'.
// We found a bigger square if following conditions

// are met:
// 1)If side of square is greater than max.
// 2)There is a left vertical line of length >= 'small'
// 3)There is a top horizontal line of length >= 'small'
while (small > max)
{
if (ver[i][j-small+1] >= small &&
hor[i-small+1][j] >= small)
{
max = small;
}
small--;
}
}
}
return max;
}

int main()
{
int mat[][N] = {{'X', 'O', 'X', 'X', 'X', 'X'},
{'X', 'O', 'X', 'X', 'O', 'X'},
{'X', 'X', 'X', 'O', 'O', 'X'},
{'O', 'X', 'X', 'X', 'X', 'X'},
{'X', 'X', 'X', 'O', 'X', 'O'},
{'O', 'O', 'X', 'O', 'O', 'O'},
};
cout << findSubSquare(mat);
return 0;
}

Output:

4

This article is contributed by Anuj. Please write comments if you find anything incorrect, or you want to
How to check if an instance of 8 puzzle is solvable?
What is 8 puzzle?
Given a 3×3 board with 8 tiles (every tile has one number from 1 to 8) and one empty space. The objective is
to place the numbers on tiles in order using the empty space. We can slide four adjacent (left, right, above
and below) tiles into the empty space.
How to find if given state is solvable?

Following are two examples, the first example can reach goal state by a series of slides. The second example
cannot.
Following is simple rule to check if a 8 puzzle is solvable.

It is not possible to solve an instance of 8 puzzle if number of inversions is odd in the input state.
In the
examples given in above figure, the first example has 10 inversions, therefore solvable. The second example
has 11 inversions, therefore unsolvable.
What is inversion?
A pair of tiles form an inversion if the the values on tiles are in reverse order of their appearance in goal
state. For example, the following instance of 8 puzzle has two inversions, (8, 6) and (8, 7).
1 2 3
4 _ 5
8 6 7

Following is a simple C++ program to check whether a given instance of 8 puzzle is solvable or not. The idea
is simple, we count inversions in the given 8 puzzle.

// C++ program to check if a given instance of 8 puzzle is solvable or not

#include <iostream>
// A utility function to count inversions in given array 'arr[]'

int getInvCount(int arr[])
{
int inv_count = 0;
for (int i = 0; i < 9 - 1; i++)
for (int j = i+1; j < 9; j++)
// Value 0 is used for empty space
if (arr[j] && arr[i] && arr[i] > arr[j])
inv_count++;
return inv_count;
}
// This function returns true if given 8 puzzle is solvable.

bool isSolvable(int puzzle[3][3])
{
// Count inversions in given 8 puzzle
int invCount = getInvCount((int *)puzzle);
// return true if inversion count is even.

return (invCount%2 == 0);
}

int main(int argv, int** args)
{
int puzzle[3][3] = {{1, 8, 2},
{0, 4, 3}, // Value 0 is used for empty space
{7, 6, 5}};
isSolvable(puzzle)? cout << "Solvable":
cout << "Not Solvable";
return 0;
}
Output:

Solvable

Note that the above implementation uses simple algorithm for inversion count. It is done this way for
simplicity. The code can be optimized to O(nLogn) using the merge sort based algorithm for inversion count.
How does this work?

The idea is based on the fact the parity of inversions remains same after a set of moves, i.e., if the inversion
count is odd in initial stage, then it remain odd after any sequence of moves and if the inversion count is
even, then it remains even after any sequence of moves. In the goal state, there are 0 inversions. So we can
reach goal state only from a state which has even inversion count.
How parity of inversion count is invariant?

When we slide a tile, we either make a row move (moving a left or right tile into the blank space), or make a
column move (moving a up or down tile to the blank space).
a) A row move doesn’t change the inversion count. See following example
1 2 3 Row Move 1 2 3
4 _ 5 ----------> _ 4 5
8 6 7 8 6 7
Inversion count remains 2 after the move
1 2 3 Row Move 1 2 3
4 _ 5 ----------> 4 5 _
8 6 7 8 6 7

b) A column move does one of the following three.

…..(i) Increases inversion count by 2. See following example.
1 2 3 Column Move 1 _ 3
4 _ 5 -----------> 4 2 5
8 6 7 8 6 7
Inversion count increases by 2 (changes from 2 to 4)

…..(ii) Decreases inversion count by 2
1 3 4 Column Move 1 3 4
5 _ 6 ------------> 5 2 6
7 2 8 7 _ 8
Inversion count decreases by 2 (changes from 5 to 3)

…..(iii) Keeps the inversion count same.
1 2 3 Column Move 1 2 3
4 _ 5 ------------> 4 6 5
7 6 8 7 _ 8

So if a move either increases/decreases inversion count by 2, or keeps the inversion count same, then it is not
possible to change parity of a state by any sequence of row/column moves.
Exercise: How to check if a given instance of 15 puzzle is solvable or not. In a 15 puzzle, we have 4×4 board
where 15 tiles have a number and one empty space. Note that the above simple rules of inversion count don’t
directly work for 15 puzzle, the rules need to be modified for 15 puzzle.
This article is contributed by Ishan. Please write comments if you find anything incorrect, or you want to
Biconnected Components
A biconnected component is a maximal biconnected subgraph.
Biconnected Graph is already discussed here. In this article, we will see how to find biconnected component
in a graph using algorithm by John Hopcroft and Robert Tarjan.
In above graph, following are the biconnected components:
4–2 3–4 3–1 2–3 1–2

8–9
8–5 7–8 5–7
6–0 5–6 1–5 0–1
10–11
Algorithm is based on Disc and Low Values discussed in Strongly Connected Components Article.
Idea is to store visited edges in a stack while DFS on a graph and keep looking for Articulation Points
(highlighted in above figure). As soon as an Articulation Point u is found, all edges visited while DFS from
node u onwards will form one biconnected component. When DFS completes for one connected component,
all edges present in stack will form a biconnected component.
If there is no Articulation Point in graph, then graph is biconnected and so there will be one biconnected
component which is the graph itself.
// A C++ program to find biconnected components in a given undirected graph

#include<iostream>
#include <list>
#include <stack>
#define NIL -1
int count = 0;
class Edge
{
public:
int u;
int v;
Edge(int u, int v);
};
Edge::Edge(int u, int v)
{
this->u = u;
this->v = v;
}

// A class that represents an directed graph
class Graph
{
int E; // No. of edges

// A Recursive DFS based function used by BCC()
void BCCUtil(int u, int disc[], int low[],
list<Edge> *st, int parent[]);
public:
void BCC(); // prints strongly connected components
};

Graph::Graph(int V)
{
this->V = V;
this->E = 0;
}

{
E++;
}

// A recursive function that finds and prints strongly connected
// components using DFS traversal
// low[] -- >> earliest visited vertex (the vertex with minimum
// discovery time) that can be reached from subtree
// rooted with current vertex
// *st -- >> To store visited edges
void Graph::BCCUtil(int u, int disc[], int low[], list<Edge> *st,
int parent[])
{
// A static variable is used for simplicity, we can avoid use
// of static variable by passing a pointer.

int children = 0;

// Go through all vertices adjacent to this
{
int v = *i; // v is current adjacent of 'u'

if (disc[v] == -1)
{
children++;
parent[v] = u;
//store the edge in stack
st->push_back(Edge(u,v));
BCCUtil(v, disc, low, st, parent);

// connection to one of the ancestors of 'u'
// Case 1 -- per Strongly Connected Components Article

//If u is an articulation point,
//pop all edges from stack till u -- v
if( (disc[u] == 1 && children > 1) ||
(disc[u] > 1 && low[v] >= disc[u]) )
{
while(st->back().u != u || st->back().v != v)
{
cout << st->back().u << "--" << st->back().v << " ";
st->pop_back();
}
cout << st->back().u << "--" << st->back().v;
st->pop_back();
cout << endl;
count++;
}
}

// Update low value of 'u' only of 'v' is still in stack
// (i.e. it's a back edge, not cross edge).
// Case 2 -- per Strongly Connected Components Article
else if(v != parent[u] && disc[v] < low[u])
{
st->push_back(Edge(u,v));
}
}
}

// The function to do DFS traversal. It uses BCCUtil()
void Graph::BCC()
{
list<Edge> *st = new list<Edge>[E];

// Initialize disc and low, and parent arrays
for (int i = 0; i < V; i++)
{
disc[i] = NIL;
low[i] = NIL;
parent[i] = NIL;
}

for (int i = 0; i < V; i++)
{
if (disc[i] == NIL)
BCCUtil(i, disc, low, st, parent);

int j = 0;
//If stack is not empty, pop all edges from stack
while(st->size() > 0)
{
j = 1;
cout << st->back().u << "--" << st->back().v << " ";
st->pop_back();
}
if(j == 1)
{
cout << endl;
count++;
}
}
}

int main()
{
Graph g(12);
g.addEdge(0,1);g.addEdge(1,0);
g.BCC();
cout << "Above are " << count << " biconnected components in graph";
return 0;
}

Output:
4--2 3--4 3--1 2--3 1--2

8--9
8--5 7--8 5--7
6--0 5--6 1--5 0--1
10--11
Above are 5 biconnected components in graph

Sort an array in wave form
Given an unsorted array of integers, sort the array into a wave like array. An array ‘arr[0..n-1]’ is sorted in
wave form if arr[0] >= arr[1] = arr[3] = …..
Examples:
Input: arr[] = {10, 5, 6, 3, 2, 20, 100, 80}

Output: arr[] = {10, 5, 6, 2, 20, 3, 100, 80} OR
{20, 5, 10, 2, 80, 6, 100, 3} OR
any other array that is in wave form
Input: arr[] = {20, 10, 8, 6, 4, 2}

Output: arr[] = {20, 8, 10, 4, 6, 2} OR
{10, 8, 20, 2, 6, 4} OR
Input: arr[] = {2, 4, 6, 8, 10, 20}

Output: arr[] = {4, 2, 8, 6, 20, 10} OR
Input: arr[] = {3, 6, 5, 10, 7, 20}

Output: arr[] = {6, 3, 10, 5, 20, 7} OR

A Simple Solution is to use sorting. First sort the input array, then swap all adjacent elements.
For example, let the input array be {3, 6, 5, 10, 7, 20}. After sorting, we get {3, 5, 6, 7, 10, 20}. After
swapping adjacent elements, we get {5, 3, 7, 6, 20, 10}. Below is C++ implementation of this simple
approach.

// A C++ program to sort an array in wave form using a sorting function

#include<iostream>
#include<algorithm>
// A utility method to swap two numbers.

{
int temp = *x;
*x = *y;
*y = temp;
}
// This function sorts arr[0..n-1] in wave form, i.e.,

// arr[0] >= arr[1] <= arr[2] >= arr[3] <= arr[4] >= arr[5]..
void sortInWave(int arr[], int n)
{
// Sort the input array
sort(arr, arr+n);
// Swap adjacent elements

for (int i=0; i<n-1; i += 2)
swap(&arr[i], &arr[i+1]);
}

int main()
{
int arr[] = {10, 90, 49, 2, 1, 5, 23};
sortInWave(arr, n);
cout << "Sorted array \n";
cout << arr[i] << " ";
return 0;
}

Output:

Sorted array
2 1 10 5 49 23 90

The time complexity of the above solution is O(nLogn) if a O(nLogn) sorting algorithm like Merge Sort, Heap
Sort, .. etc is used.
This can be done in O(n) time by doing a single traversal of given array. The idea is based on the fact
that if we make sure that all even positioned (at index 0, 2, 4, ..) elements are greater than their adjacent odd
elements, we don’t need to worry about odd positioned element. Following are simple steps.
1) Traverse all even positioned elements of input array, and do following.
….a) If current element is smaller than previous odd element, swap previous and current.
….b) If current element is smaller than next odd element, swap next and current.
Below is C++ implementation of above simple algorithm.

// A O(n) program to sort an input array in wave form

#include<iostream>
// A utility method to swap two numbers.

{
int temp = *x;
*x = *y;
*y = temp;
}
// This function sorts arr[0..n-1] in wave form, i.e., arr[0] >=

// arr[1] <= arr[2] >= arr[3] <= arr[4] >= arr[5] ....
void sortInWave(int arr[], int n)
{
// Traverse all even elements
for (int i = 0; i < n; i+=2)
{
// If current even element is smaller than previous
if (i>0 && arr[i-1] > arr[i] )
swap(&arr[i], &arr[i-1]);
// If current even element is smaller than next

if (i<n-1 && arr[i] < arr[i+1] )
swap(&arr[i], &arr[i + 1]);
}
}

int main()
{
int arr[] = {10, 90, 49, 2, 1, 5, 23};
sortInWave(arr, n);
cout << "Sorted array \n";
cout << arr[i] << " ";
return 0;
}

Output:

Sorted array
90 10 49 1 5 2 23

Given a binary string, count number of substrings that start and end with 1.
Given a binary string, count number of substrings that start and end with 1. For example, if the input string is
“00100101”, then there are three substrings “1001”, “100101” and “101”.
Source: Amazon Interview Experience | Set 162
A Simple Solution is to run two loops. Outer loops picks every 1 as starting point and inner loop searches
for ending 1 and increments count whenever it finds 1.
// A simple C++ program to count number of substrings starting and ending

// with 1
#include<iostream>
int countSubStr(char str[])

{

for (int i=0; str[i] !='\0'; i++)
{
if (str[i] == '1')
{
// Search for all possible ending point
for (int j=i+1; str[j] !='\0'; j++)
if (str[j] == '1')
res++;
}
}
return res;
}

int main()
{
char str[] = "00100101";
cout << countSubStr(str);
return 0;
}

Output:
Time Complexity of the above solution is O(n2). We can find count in O(n) using a single traversal of
input string. Following are steps.
a) Count the number of 1’s. Let the count of 1’s be m.
b) Return m(m-1)/2
The idea is to count total number of possible pairs of 1’s.

// A O(n) C++ program to count number of substrings starting and ending

// with 1
#include<iostream>
int countSubStr(char str[])

{
int m = 0; // Count of 1's in input string
// Travers input string and count of 1's in it

for (int i=0; str[i] !='\0'; i++)
{
if (str[i] == '1')
m++;
}
// Return count of possible pairs among m 1's

return m*(m-1)/2;
}

int main()
{
char str[] = "00100101";
cout << countSubStr(str);
return 0;
}

Output:
Suffix Tree Application 6 – Longest Palindromic Substring
Given a string, find the longest substring which is palindrome.
We have already discussed Naïve [O(n3)], quadratic [O(n2)] and linear [O(n)] approaches in Set 1, Set 2 and
Manacher’s Algorithm.
In this article, we will discuss another linear time approach based on suffix tree.
If given string is S, then approach is following:
Reverse the string S (say reversed string is R)

Get Longest Common Substring of S and R given that LCS in S and R must be from same
position in S
Can you see why we say that LCS in R and S must be from same position in S ?
Let’s look at following examples:
For S = xababayz and R = zyababax, LCS and LPS both are ababa (SAME)
For S = abacdfgdcaba and R = abacdgfdcaba, LCS is abacd and LPS is aba (DIFFERENT)
For S = pqrqpabcdfgdcba and R = abcdgfdcbapqrqp, LCS and LPS both are pqrqp (SAME)
For S = pqqpabcdfghfdcba and R = abcdfhgfdcbapqqp, LCS is abcdf and LPS is pqqp (DIFFERENT)
We can see that LCS and LPS are not same always. When they are different ?
When S has a reversed copy of a non-palindromic substring in it which is of same or longer length than
LPS in S, then LCS and LPS will be different.
In 2nd example above (S = abacdfgdcaba), for substring abacd, there exists a reverse copy dcaba in S, which
is of longer length than LPS aba and so LPS and LCS are different here. Same is the scenario in 4th example.
To handle this scenario we say that LPS in S is same as LCS in S and R

given that LCS in R and S must
be from same position in S.
If we look at 2nd example again, substring aba in R comes from exactly same position in S as substring aba
in S which is ZERO (0th index) and so this is LPS.
The Position Constraint:


We will refer string S index as forward index (S) and string R index as reverse index (R).
i i
Based on above figure, a character with index i (forward index) in a string S of length N, will be at index N-1-i
(reverse index) in it’s reversed string R.
If we take a substring of length L in string S with starting index i and ending index j (j = i+L-1), then in it’s
reversed string R, the reversed substring of the same will start at index N-1-j and will end at index N-1-i.
If there is a common substring of length L at indices Si (forward index) and R (reverse index) in S and R,
i
then these will come from same position in S if Ri = (N – 1) – (S i + L – 1) where N is string length.
So to find LPS of string S, we find longest common string of S and R where both substrings satisfy above
constraint, i.e. if substring in S is at index Si, then same substring should be in R at index (N – 1) – (S + L –
i
1). If this is not the case, then this substring is not LPS candidate.
Naive [O(N*M2)] and Dynamic Programming [O(N*M)] approaches to find LCS of two strings are already
discussed here which can be extended to add position constraint to give LPS of a given string.
Now we will discuss suffix tree approach which is nothing but an extension to Suffix Tree LCS approach
where we will add the position constraint.
While finding LCS of two strings X and Y, we just take deepest node marked as XY (i.e. the node which has
suffixes from both strings as it’s children).
While finding LPS of string S, we will again find LCS of S and R with a condition that the common substring
should satisfy the position constraint (the common substring should come from same position in S). To
verify position constraint, we need to know all forward and reverse indices on each internal node (i.e. the
suffix indices of all leaf children below the internal nodes).
In Generalized Suffix Tree of S#R$, a substring on the path from root to an internal node is a common
substring if the internal node has suffixes from both strings S and R. The index of the common substring in
S and R can be found by looking at suffix index at respective leaf node.
If string S# is of length N then:
If suffix index of a leaf is less than N, then that suffix belongs to S and same suffix index will become
forward index of all ancestor nodes
If suffix index of a leaf is greater than N, then that suffix belongs to R and reverse index for all
ancestor nodes will be N – suffix index
Let’s take string S = cabbaabb. The figure below is Generalized Suffix Tree for cabbaabb#bbaabbac$ where
we have shown forward and reverse indices of all children suffixes on all internal nodes (except root).
Forward indices are in Parentheses () and reverse indices are in square bracket [].


In above figure, all leaf nodes will have one forward or reverse index depending on which string (S or R) they
belong to. Then children’s forward or reverse indices propagate to the parent.
Look at the figure to understand what would be the forward or reverse index on a leaf with a given suffix
index. At the bottom of figure, it is shown that leaves with suffix indices from 0 to 8 will get same values (0
to 8) as their forward index in S and leaves with suffix indices 9 to 17 will get reverse index in R from 0 to 8.
For example, the highlighted internal node has two children with suffix indices 2 and 9. Leaf with suffix
index 2 is from position 2 in S and so it’s forward index is 2 and shown in (). Leaf with suffix index 9 is from
position 0 in R and so it’s reverse index is 0 and shown in []. These indices propagate to parent and the
parent has one leaf with suffix index 14 for which reverse index is 4. So on this parent node forward index is
(2) and reverse index is [0,4]. And in same way, we should be able to understand the how forward and
reverse indices are calculated on all nodes.
In above figure, all internal nodes have suffixes from both strings S and R, i.e. all of them represent a
common substring on the path from root to themselves. Now we need to find deepest node satisfying
position constraint. For this, we need to check if there is a forward index Si on a node, then there must be a
reverse index R i with value (N – 2) – (S + L – 1) where N is length of string
i S# and L is node depth (or
substring length). If yes, then consider this node as a LPS candidate, else ignore it. In above figure, deepest
node is highlighted which represents LPS as bbaabb.
We have not shown forward and reverse indices on root node in figure. Because root node itself doesn’t
represent any common substring (In code implementation also, forward and reverse indices will not be
calculated on root node)
How to implement this apprach to find LPS? Here are the things that we need:
We need to know forward and reverse indices on each node.

For a given forward index S on an internal node, we need know if reverse index
i Ri = (N – 2) – (S i +
L – 1) also present on same node.
Keep track of deepest internal node satisfying above condition.
One way to do above is:

While DFS on suffix tree, we can store forward and reverse indices on each node in some way (storage will
help to avoid repeated traversals on tree when we need to know forward and reverse indices on a node).
Later on, we can do another DFS to look for nodes satisfying position constraint. For position constraint
check, we need to search in list of indices.
What data structure is suitable here to do all these in quickest way ?
If we store indices in array, it will require linear search which will make overall approach non-linear in
time.
If we store indices in tree (set in C++, TreeSet in Java), we may use binary search but still overall
approach will be non-linear in time.
If we store indices in hash function based set (unordered_set in C++, HashSet in Java), it will provide
a constant search on average and this will make overall approach linear in time. A hash function based
set may take more space depending on values being stored.
We will use two unordered_set (one for forward and other from reverse indices) in our implementation,
added as a member variable in SuffixTreeNode structure.
// A C++ program to implement Ukkonen's Suffix Tree Construction

// Here we build generalized suffix tree for given string S
// and it's reverse R, then we find
// longest palindromic substring of given string S
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <iostream>
#include <unordered_set>


int start;
int *end;

int suffixIndex;

//To store indices of children suffixes in given string
unordered_set<int> *forwardIndices;
//To store indices of children suffixes in reversed string

unordered_set<int> *reverseIndices;
};





// be added in tree
int leafEnd = -1;
int size1 = 0; //Size of 1st string
int reverseIndex; //Index of a suffix in reversed string
unordered_set<int>::iterator forwardIndex;

{
int i;

next extension*/
node->end = end;

node->forwardIndices = new unordered_set<int>;
node->reverseIndices = new unordered_set<int>;
return node;
}

if(n == root)
return 0;
}

{
{
return 1;
}
return 0;
}

{
leafEnd = pos;

added in tree*/

lastNewNode = NULL;



{

reset.*/
{
lastNewNode = NULL;
}
}
// from activeNode
else
{
// with activeEdge
Node *next = activeNode->children[text[activeEdge]] ;
{
continue;
}
{
//APCFER3
activeLength++;
break;
}


//New internal node


reset, do it now.*/
{
}

}

{
activeLength--;
}
{
}
}
}

{
int k;
for (k=i; k<=j && text[k] != '#'; k++)
if(k<=j)
printf("#");
}

{

{
//print(n->start, *(n->end));
}
int leaf = 1;
int i;
{
{
// if (leaf == 1 && n->start != -1)

//edges from it.
leaf = 0;
if(n != root)
{
//Add chldren's suffix indices in parent
n->forwardIndices->insert(
n->children[i]->forwardIndices->begin(),
n->children[i]->forwardIndices->end());
n->reverseIndices->insert(
n->children[i]->reverseIndices->begin(),
n->children[i]->reverseIndices->end());
}
}
}
if (leaf == 1)
{
{
if(text[i] == '#')
{
*(n->end) = i;
}
}
if(n->suffixIndex < size1) //Suffix of Given String

n->forwardIndices->insert(n->suffixIndex);
else //Suffix of Reversed String
n->reverseIndices->insert(n->suffixIndex - size1);

}
}

{
if (n == NULL)
return;
int i;
{
{
}
}
free(n->end);
free(n);
}

{
int i;
*rootEnd = - 1;


}
void doTraversal(Node *n, int labelHeight, int* maxHeight,

{
if(n == NULL)
{
return;
}
int i=0;
int ret = -1;
if(n->suffixIndex < 0) //If it is internal node
{
{
{
doTraversal(n->children[i], labelHeight +
edgeLength(n->children[i]),
maxHeight, substringStartIndex);

if(*maxHeight < labelHeight
&& n->forwardIndices->size() > 0 &&
n->reverseIndices->size() > 0)
{
for (forwardIndex=n->forwardIndices->begin();
forwardIndex!=n->forwardIndices->end();
++forwardIndex)
{
reverseIndex = (size1 - 2) -
(*forwardIndex + labelHeight - 1);
//If reverse suffix comes from
//SAME position in given string
//Keep track of deepest node
if(n->reverseIndices->find(reverseIndex) !=
n->reverseIndices->end())
{
*maxHeight = labelHeight;
*substringStartIndex = *(n->end) -
labelHeight + 1;
break;
}
}
}
}
}
}
}
void getLongestPalindromicSubstring()
{
int maxHeight = 0;

int k;
if(k == 0)
printf("No palindromic substring");
else
printf(", of length: %d",maxHeight);
printf("\n");
}

{
size1 = 9;
printf("Longest Palindromic Substring in cabbaabb is: ");
strcpy(text, "cabbaabb#bbaabbac$"); buildSuffixTree();
getLongestPalindromicSubstring();
size1 = 17;
printf("Longest Palindromic Substring in forgeeksskeegfor is: ");
strcpy(text, "forgeeksskeegfor#rofgeeksskeegrof$"); buildSuffixTree();
size1 = 6;
printf("Longest Palindromic Substring in abcde is: ");
strcpy(text, "abcde#edcba$"); buildSuffixTree();
size1 = 7;
printf("Longest Palindromic Substring in abcdae is: ");
strcpy(text, "abcdae#eadcba$"); buildSuffixTree();
size1 = 6;
printf("Longest Palindromic Substring in abacd is: ");
strcpy(text, "abacd#dcaba$"); buildSuffixTree();
size1 = 6;
printf("Longest Palindromic Substring in abcdc is: ");
strcpy(text, "abcdc#cdcba$"); buildSuffixTree();
size1 = 13;
printf("Longest Palindromic Substring in abacdfgdcaba is: ");
strcpy(text, "abacdfgdcaba#abacdgfdcaba$"); buildSuffixTree();
size1 = 15;
printf("Longest Palindromic Substring in xyabacdfgdcaba is: ");
strcpy(text, "xyabacdfgdcaba#abacdgfdcabayx$"); buildSuffixTree();
size1 = 9;
printf("Longest Palindromic Substring in xababayz is: ");
strcpy(text, "xababayz#zyababax$"); buildSuffixTree();
size1 = 6;
printf("Longest Palindromic Substring in xabax is: ");
strcpy(text, "xabax#xabax$"); buildSuffixTree();
return 0;
}

Output:
Longest Palindromic Substring in cabbaabb is: bbaabb, of length: 6

Longest Palindromic Substring in forgeeksskeegfor is: geeksskeeg, of length: 10
Longest Palindromic Substring in abcde is: a, of length: 1
Longest Palindromic Substring in abcdae is: a, of length: 1
Longest Palindromic Substring in abacd is: aba, of length: 3
Longest Palindromic Substring in abcdc is: cdc, of length: 3
Longest Palindromic Substring in abacdfgdcaba is: aba, of length: 3
Longest Palindromic Substring in xyabacdfgdcaba is: aba, of length: 3
Longest Palindromic Substring in xababayz is: ababa, of length: 5
Longest Palindromic Substring in xabax is: xabax, of length: 5

Followup:
Detect ALL palindromes in a given string.
e.g. For string abcddcbefgf, all possible palindromes are a, b, c, d, e, f, g, dd, fgf, cddc, bcddcb.
Check if a given array contains duplicate elements within k distance from
each other
Given an unsorted array that may contain duplicates. Also given a number k which is smaller than size of
array. Write a function that returns true if array contains duplicates within k distance.
Examples:
Input: k = 3, arr[] = {1, 2, 3, 4, 1, 2, 3, 4}

Output: false
All duplicates are more than k distance away.
Input: k = 3, arr[] = {1, 2, 3, 1, 4, 5}

Output: true
1 is repeated at distance 3.
Input: k = 3, arr[] = {1, 2, 3, 4, 5}

Output: false
Input: k = 3, arr[] = {1, 2, 3, 4, 4}

Output: true

A Simple Solution is to run two loops. The outer loop picks every element ‘arr[i]’ as a starting element, the
inner loop compares all elements which are within k distance of ‘arr[i]’. The time complexity of this solution
is O(kn).
We can solve this problem in Θ(n) time using Hashing. The idea is to one by add elements to hash. We
also remove elements which are at more than k distance from current element. Following is detailed
algorithm.
1) Create an empty hashtable.

2) Traverse all elements from left from right. Let the current element be ‘arr[i]’
….a) If current element ‘arr[i]’ is present in hashtable, then return true.
….b) Else add arr[i] to hash and remove arr[i-k] from hash if i is greater than or equal to k

/* Java program to Check if a given array contains duplicate

elements within k distance from each other */
import java.util.*;
class Main
{
static boolean checkDuplicatesWithinK(int arr[], int k)
{
// Traverse the input array

for (int i=0; i<arr.length; i++)
{
// If already present n hash, then we found
// a duplicate within k distance
if (set.contains(arr[i]))
return true;
// Add this item to hashset

set.add(arr[i]);
// Remove the k+1 distant item

if (i >= k)
set.remove(arr[i-k]);
}
return false;
}

{
int arr[] = {10, 5, 3, 4, 3, 5, 6};
if (checkDuplicatesWithinK(arr, 3))
System.out.println("Yes");
else
System.out.println("No");
}
}

Output:

Yes

This article is contributed by Anuj. Please write comments if you find anything incorrect, or you want to
Given a matrix of ‘O’ and ‘X’, replace ‘O’ with ‘X’ if surrounded by ‘X’
Given a matrix where every element is either ‘O’ or ‘X’, replace ‘O’ with ‘X’ if surrounded by ‘X’. A ‘O’ (or a set
of ‘O’) is considered to be by surrounded by ‘X’ if there are ‘X’ at locations just below, just above, just left and
just right of it.
Examples:

Input: mat[M][N] = {{'X', 'O', 'X', 'X', 'X', 'X'},
{'X', 'O', 'X', 'X', 'O', 'X'},
{'X', 'X', 'X', 'O', 'O', 'X'},
{'O', 'X', 'X', 'X', 'X', 'X'},
{'X', 'X', 'X', 'O', 'X', 'O'},
{'O', 'O', 'X', 'O', 'O', 'O'},
};
Output: mat[M][N] = {{'X', 'O', 'X', 'X', 'X', 'X'},
{'X', 'O', 'X', 'X', 'X', 'X'},
{'X', 'X', 'X', 'X', 'X', 'X'},
{'O', 'X', 'X', 'X', 'X', 'X'},
{'X', 'X', 'X', 'O', 'X', 'O'},
{'O', 'O', 'X', 'O', 'O', 'O'},
};

Input: mat[M][N] = {{'X', 'X', 'X', 'X'}
{'X', 'O', 'X', 'X'}
{'X', 'O', 'O', 'X'}
{'X', 'O', 'X', 'X'}
{'X', 'X', 'O', 'O'}
};

Input: mat[M][N] = {{'X', 'X', 'X', 'X'}
{'X', 'X', 'X', 'X'}
{'X', 'X', 'X', 'X'}
{'X', 'X', 'X', 'X'}
{'X', 'X', 'O', 'O'}
};


This is mainly an application of Flood-Fill algorithm. The main difference here is that a ‘O’ is not replaced by
‘X’ if it lies in region that ends on a boundary. Following are simple steps to do this special flood fill.
1) Traverse the given matrix and replace all ‘O’ with a special character ‘-‘.
2) Traverse four edges of given matrix and call floodFill(‘-‘, ‘O’) for every ‘-‘ on edges. The remaining ‘-‘ are
the characters that indicate ‘O’s (in the original matrix) to be replaced by ‘X’.
3) Traverse the matrix and replace all ‘-‘s with ‘X’s.
Let us see steps of above algorithm with an example. Let following be the input matrix.

mat[M][N] = {{'X', 'O', 'X', 'X', 'X', 'X'},

{'X', 'O', 'X', 'X', 'O', 'X'},
{'X', 'X', 'X', 'O', 'O', 'X'},
{'O', 'X', 'X', 'X', 'X', 'X'},
{'X', 'X', 'X', 'O', 'X', 'O'},
{'O', 'O', 'X', 'O', 'O', 'O'},
};

Step 1: Replace all ‘O’ with ‘-‘.
mat[M][N] = {{'X', '-', 'X', 'X', 'X', 'X'},

{'X', '-', 'X', 'X', '-', 'X'},
{'X', 'X', 'X', '-', '-', 'X'},
{'-', 'X', 'X', 'X', 'X', 'X'},
{'X', 'X', 'X', '-', 'X', '-'},
{'-', '-', 'X', '-', '-', '-'},
};

Step 2: Call floodFill(‘-‘, ‘O’) for all edge elements with value equals to ‘-‘
mat[M][N] = {{'X', 'O', 'X', 'X', 'X', 'X'},

{'X', 'O', 'X', 'X', '-', 'X'},
{'X', 'X', 'X', '-', '-', 'X'},
{'O', 'X', 'X', 'X', 'X', 'X'},
{'X', 'X', 'X', 'O', 'X', 'O'},
{'O', 'O', 'X', 'O', 'O', 'O'},
};

Step 3: Replace all ‘-‘ with ‘X’.
mat[M][N] = {{'X', 'O', 'X', 'X', 'X', 'X'},

{'X', 'O', 'X', 'X', 'X', 'X'},
{'X', 'X', 'X', 'X', 'X', 'X'},
{'O', 'X', 'X', 'X', 'X', 'X'},
{'X', 'X', 'X', 'O', 'X', 'O'},
{'O', 'O', 'X', 'O', 'O', 'O'},
};

// A C++ program to replace all 'O's with 'X''s if surrounded by 'X'

#include<iostream>
// Size of given matrix is M X N
#define M 6
#define N 6
// A recursive function to replace previous value 'prevV' at '(x, y)'

// and all surrounding values of (x, y) with new value 'newV'.
void floodFillUtil(char mat[][N], int x, int y, char prevV, char newV)
{
// Base cases
if (x < 0 || x >= M || y < 0 || y >= N)
return;
if (mat[x][y] != prevV)
return;
// Replace the color at (x, y)

mat[x][y] = newV;
// Recur for north, east, south and west

floodFillUtil(mat, x+1, y, prevV, newV);
floodFillUtil(mat, x-1, y, prevV, newV);
floodFillUtil(mat, x, y+1, prevV, newV);
floodFillUtil(mat, x, y-1, prevV, newV);
}
// Returns size of maximum size subsquare matrix

// surrounded by 'X'
int replaceSurrounded(char mat[][N])
{
// Step 1: Replace all 'O' with '-'
if (mat[i][j] == 'O')
mat[i][j] = '-';
// Call floodFill for all '-' lying on edges

for (int i=0; i<M; i++) // Left side
if (mat[i][0] == '-')
floodFillUtil(mat, i, 0, '-', 'O');
for (int i=0; i<M; i++) // Right side
if (mat[i][N-1] == '-')
floodFillUtil(mat, i, N-1, '-', 'O');
for (int i=0; i<N; i++) // Top side
if (mat[0][i] == '-')
floodFillUtil(mat, 0, i, '-', 'O');
for (int i=0; i<N; i++) // Bottom side
if (mat[M-1][i] == '-')
floodFillUtil(mat, M-1, i, '-', 'O');
// Step 3: Replace all '-' with 'X'

if (mat[i][j] == '-')
mat[i][j] = 'X';

int main()
{
char mat[][N] = {{'X', 'O', 'X', 'O', 'X', 'X'},
{'X', 'O', 'X', 'X', 'O', 'X'},
{'X', 'X', 'X', 'O', 'X', 'X'},
{'O', 'X', 'X', 'X', 'X', 'X'},
{'O', 'X', 'X', 'X', 'X', 'X'},
{'X', 'X', 'X', 'O', 'X', 'O'},
{'O', 'O', 'X', 'O', 'O', 'O'},
};
replaceSurrounded(mat);

{
cout << mat[i][j] << " ";
cout << endl;
}
return 0;
}

Output:

X O X O X X
X O X X X X
X X X X X X
O X X X X X
X X X O X O
O O X O O O

Time Complexity of the above solution is O(MN). Note that every element of matrix is processed at most
three times.
Boggle (Find all possible words in a board of characters)
Given a dictionary, a method to do lookup in dictionary and a M x N board where every cell has one
character. Find all possible words that can be formed by a sequence of adjacent charactersNote that we can
move to any of 8 adjacent characters, but a word should not have multiple instances of same cell.
Example:
Input: dictionary[] = {"GEEKS", "FOR", "QUIZ", "GO"};

boggle[][] = {{'G','I','Z'},
{'U','E','K'},
{'Q','S','E'}};
isWord(str): returns true if str is present in dictionary
else false.
Output: Following words of dictionary are present

GEEKS
QUIZ

The idea is to consider every character as a starting character and find all words starting with it. All words
starting from a character can be found using Depth First Traversal. We do depth first traversal starting from
every cell. We keep track of visited cells to make sure that a cell is considered only once in a word.
// C++ program for Boggle game

#include<iostream>
#include<cstring>
#define M 3
#define N 3
// Let the given dictionary be following

string dictionary[] = {"GEEKS", "FOR", "QUIZ", "GO"};
int n = sizeof(dictionary)/sizeof(dictionary[0]);
// A given function to check if a given string is present in

// dictionary. The implementation is naive for simplicity. As
// per the question dictionary is givem to us.
bool isWord(string &str)
{
{
// Linearly search all words
if (str.compare(dictionary[i]) == 0)
return true;
return false;
}
// A recursive function to print all words present on boggle

void findWordsUtil(char boggle[M][N], bool visited[M][N], int i,
int j, string &str)
{
// Mark current cell as visited and append current character
// to str
visited[i][j] = true;
str = str + boggle[i][j];
// If str is present in dictionary, then print it

if (isWord(str))
cout << str << endl;
// Traverse 8 adjacent cells of boggle[i][j]

for (int row=i-1; row<=i+1 && row<M; row++)
for (int col=j-1; col<=j+1 && col<N; col++)
if (row>=0 && col>=0 && !visited[row][col])
findWordsUtil(boggle,visited, row, col, str);
// Erase current character from string and mark visited

// of current cell as false
str.erase(str.length()-1);
visited[i][j] = false;
}
// Prints all words present in dictionary.

void findWords(char boggle[M][N])
{
// Mark all characters as not visited
bool visited[M][N] = {{false}};
// Initialize current string

string str = "";
// Consider every character and look for all words

// starting with this character
findWordsUtil(boggle, visited, i, j, str);
}

int main()
{
char boggle[M][N] = {{'G','I','Z'},
{'U','E','K'},
{'Q','S','E'}};
cout << "Following words of dictionary are present\n";

findWords(boggle);
return 0;
}

Output:

Following words of dictionary are present

GEEKS
QUIZ

Note that the above solution may print same word multiple times. For example, if we add “SEEK” to
dictionary, it is printed multiple times. To avoid this, we can use hashing to keep track of all printed words.
This article is contributed by Rishabh. Please write comments if you find anything incorrect, or you want to
Minimize Cash Flow among a given set of friends who have borrowed
money from each other
Given a number of friends who have to give or take some amount of money from one another. Design an
algorithm by which the total cash flow among all the friends is minimized.
Example:
Following diagram shows input debts to be settled.
Above debts can be settled in following optimized way
The idea is to use Greedy algorithm where at every step, settle all amounts of one person and recur for
remaining n-1 persons.
How to pick the first person? To pick the first person, calculate the net amount for every person where net
amount is obtained by subtracting all debts (amounts to pay) from all credits (amounts to be paid). Once net
amount for every person is evaluated, find two persons with maximum and minimum net amounts. These
two persons are the most creditors and debtors. The person with minimum of two is our first person to be
settled and removed from list. Let the minimum of two amounts be x. We pay ‘x’ amount from the maximum
debtor to maximum creditor and settle one person. If x is equal to the maximum debit, then maximum
debtor is settled, else maximum creditor is settled.
The following is detailed algorithm.
Do following for every person Pi where i is from 0 to n-1.

1) Compute the net amount for every person. The net amount for person ‘i’ can be computed be subtracting
sum of all debts from sum of all credits.
2) Find the two persons that are maximum creditor and maximum debtor. Let the maximum amount to be
credited maximum creditor be maxCredit and maximum amount to be debited from maximum debtor be
maxDebit. Let the maximum debtor be Pd and maximum creditor be Pc.
3) Find the minimum of maxDebit and maxCredit. Let minimum of two be x. Debit ‘x’ from Pd and credit
this amount to Pc
4) If x is equal to maxCredit, then remove Pc from set of persons and recur for remaining (n-1) persons.
5) If x is equal to maxDebit, then remove Pd from set of persons and recur for remaining (n-1) persons.
Thanks to Balaji S for suggesting this method in a comment here.
// C++ program to fin maximum cash flow among a set of persons

#include<iostream>
// Number of persons (or vertices in the graph)

#define N 3
// A utility function that returns index of minimum value in arr[]

int getMin(int arr[])
{
int minInd = 0;
if (arr[i] < arr[minInd])
minInd = i;
return minInd;
}
// A utility function that returns index of maximum value in arr[]

int getMax(int arr[])
{
int maxInd = 0;
if (arr[i] > arr[maxInd])
maxInd = i;
return maxInd;
}
// A utility function to return minimum of 2 values

int minOf2(int x, int y)
{
return (x<y)? x: y;
}
// amount[p] indicates the net amount to be credited/debited

// to/from person 'p'
// If amount[p] is positive, then i'th person will amount[i]
// If amount[p] is negative, then i'th person will give -amount[i]
void minCashFlowRec(int amount[])
{
// Find the indexes of minimum and maximum values in amount[]
// amount[mxCredit] indicates the maximum amount to be given
// (or credited) to any person .
// And amount[mxDebit] indicates the maximum amount to be taken
// (or debited) from any person.
// So if there is a positive value in amount[], then there must
// be a negative value
int mxCredit = getMax(amount), mxDebit = getMin(amount);
// If both amounts are 0, then all amounts are settled

if (amount[mxCredit] == 0 && amount[mxDebit] == 0)
if (amount[mxCredit] == 0 && amount[mxDebit] == 0)
return;
// Find the minimum of two amounts

int min = minOf2(-amount[mxDebit], amount[mxCredit]);
amount[mxCredit] -= min;
amount[mxDebit] += min;
// If minimum is the maximum amount to be

cout << "Person " << mxDebit << " pays " << min
<< " to " << "Person " << mxCredit << endl;
// Recur for the amount array. Note that it is guaranteed that

// the recursion would terminate as either amount[mxCredit]
// or amount[mxDebit] becomes 0
minCashFlowRec(amount);
}
// Given a set of persons as graph[] where graph[i][j] indicates

// the amount that person i needs to pay person j, this function
// finds and prints the minimum cash flow to settle all debts.
void minCashFlow(int graph[][N])
{
// Create an array amount[], initialize all value in it as 0.
int amount[N] = {0};
// Calculate the net amount to be paid to person 'p', and

// stores it in amount[p]. The value of amount[p] can be
// calculated by subtracting debts of 'p' from credits of 'p'
for (int p=0; p<N; p++)
amount[p] += (graph[i][p] - graph[p][i]);
minCashFlowRec(amount);
}

int main()
{
// graph[i][j] indicates the amount that person i needs to
// pay person j
int graph[N][N] = { {0, 1000, 2000},
{0, 0, 5000},
{0, 0, 0},};

minCashFlow(graph);
return 0;
}

Output:

Person 1 pays 4000 to Person 2
Person 0 pays 3000 to Person 2

Algorithmic Paradigm: Greedy

Time Complexity: O(N2) where N is the number of persons.
This article is contributed by Gaurav. Please write comments if you find anything incorrect, or you want to
We have already discussed 2 different ways to clone a linked list. In this post, one more simple method to
clone a linked list is discussed.
The idea is to use Hashing. Below is algorithm.

1. Traverse the original linked list and make a copy in terms of data.
2. Make a hash map of key value pair with original linked list node and copied linked list node.
3. Traverse the original linked list again and using the hash map adjust the next and random reference of
cloned linked list nodes.
A Java based approach of the above idea is below.
// Java program to clone a linked list with random pointers

import java.util.Map;
// Linked List Node class

class Node
{
int data;//Node data
Node next, random;//Next and random reference
//Node constructor
public Node(int data)
{
this.data = data;
this.next = this.random = null;
}
}
// linked list class

class LinkedList
{
Node head;//Linked list head reference
// Linked list constructor

public LinkedList(Node head)
{
this.head = head;
}
// push method to put data always at the head

// in the linked list.
public void push(int data)
{
Node node = new Node(data);
node.next = this.head;
this.head = node;
}
// Method to print the list.

void print()
{
Node temp = head;
while (temp != null)
{
Node random = temp.random;
int randomData = (random != null)? random.data: -1;
System.out.println("Data = " + temp.data +
", Random data = "+ randomData);
temp = temp.next;
}
}
// Actual clone method which returns head

// reference of cloned linked list.
public LinkedList clone()
{
// Initialize two references, one with original
// list's head.
Node origCurr = this.head, cloneCurr = null;
// Hash map which contains node to node mapping of

// original and clone linked list.
Map<Node, Node> map = new HashMap<Node, Node>();
// Traverse the original list and make a copy of that

// in the clone linked list.
while (origCurr != null)
{
cloneCurr = new Node(origCurr.data);
map.put(origCurr, cloneCurr);
origCurr = origCurr.next;
}
// Adjusting the original list reference again.

origCurr = this.head;
// Traversal of original list again to adjust the next

// and random references of clone list using hash map.
while (origCurr != null)
{
cloneCurr = map.get(origCurr);
cloneCurr.next = map.get(origCurr.next);
cloneCurr.random = map.get(origCurr.random);
origCurr = origCurr.next;
}
//return the head reference of the clone list.

return new LinkedList(map.get(this.head));
}
}
// Driver Class
class Main
{
// Main method.
{
// Pushing data in the linked list.
LinkedList list = new LinkedList(new Node(5));
list.push(4);
list.push(3);
list.push(2);
list.push(1);
// Setting up random references.

list.head.random = list.head.next.next;
list.head.next.random =
list.head.next.next.next;
list.head.next.next.random =
list.head.next.next.next.next;
list.head.next.next.next.random =
list.head.next.next.next.next.next;
list.head.next.next.next.next.random =
list.head.next;
// Making a clone of the original linked list.

LinkedList clone = list.clone();
// Print the original and cloned linked list.

System.out.println("Original linked list");
list.print();
System.out.println("\nCloned linked list");
clone.print();
}
}

Output:
Original linked list

Data = 1, Random data = 3
Data = 4, Random data = -1
Cloned linked list

Data = 4, Random data = -1

Time complexity : O(n)

Auxiliary space : O(n)
Find the missing number in Arithmetic Progression
Given an array that represents elements of arithmetic progression in order. One element is missing in the
progression, find the missing number.
Examples:
Input: arr[] = {2, 4, 8, 10, 12, 14}

Output: 6
Input: arr[] = {1, 6, 11, 16, 21, 31};

Output: 26

A Simple Solution is to linearly traverse the array and find the missing number. Time complexity of this
solution is O(n).
We can solve this problem in O(Logn) time using Binary Search. The idea is to go to the middle element.
Check if the difference between middle and next to middle is equal to diff or not, if not then the missing
element lies between mid and mid+1. If the middle element is equal to n/2th term in Arithmetic Series (Let
n be the number of elements in input array), then missing element lies in right half. Else element lies in left
half.
// A C program to find the missing number in a given

// arithmetic progression
#include <stdio.h>
#include <limits.h>
// A binary search based recursive function that returns

// the missing element in arithmetic progression
int findMissingUtil(int arr[], int low, int high, int diff)
{
// There must be two elements to find the missing
if (high <= low)
return INT_MAX;
// Find index of middle element

// The element just after the middle element is missing.

// The arr[mid+1] must exist, because we return when
// (low == high) and take floor of (high-low)/2
if (arr[mid+1] - arr[mid] != diff)
return (arr[mid] + diff);
// The element just before mid is missing

if (mid > 0 && arr[mid] - arr[mid-1] != diff)
return (arr[mid-1] + diff);
// If the elements till mid follow AP, then recur

// for right half
if (arr[mid] == arr[0] + mid*diff)
if (arr[mid] == arr[0] + mid*diff)
return findMissingUtil(arr, mid+1, high, diff);
// Else recur for left half

return findMissingUtil(arr, low, mid-1, diff);
}
// The function uses findMissingUtil() to find the missing

// element in AP. It assumes that there is exactly one missing
// element and may give incorrect result when there is no missing
// element or more than one missing elements.
// This function also assumes that the difference in AP is an
// integer.
int findMissing(int arr[], int n)
{
// If exactly one element is missing, then we can find
// difference of arithmetic progression using following
// formula. Example, 2, 4, 6, 10, diff = (10-2)/4 = 2.
// The assumption in formula is that the difference is
// an integer.
int diff = (arr[n-1] - arr[0])/n;
// Binary search for the missing number using above

// calculated diff
return findMissingUtil(arr, 0, n-1, diff);
}

int main()
{
int arr[] = {2, 4, 8, 10, 12, 14};
printf("The missing element is %d", findMissing(arr, n));
return 0;
}

Output:

The missing element is 6

Exercise:
Solve the same problem for Geometrical Series. What is the time complexity of your solution? What about
Fibonacci Series?
This article is contributed by Harshit Agrawal. Please write comments if you find anything incorrect, or
Find if a given string can be represented from a substring by iterating the
substring “n” times
Given a string ‘str’, check if it can be constructed by taking a substring of it and appending multiple copies of
the substring together.
Examples:
Input: str = "abcabcabc"

Output: true
The given string is 3 times repetition of "abc"
Input: str = "abadabad"

Output: true
The given string is 2 times repetition of "abad"
Input: str = "aabaabaabaab"

Output: true
The given string is 4 times repetition of "aab"
Input: str = "abcdabc"

Output: false

There can be many solutions to this problem. The challenging part is to solve the problem in O(n) time.
Below is a O(n) algorithm.
Let the given string be ‘str’ and length of given string be ‘n’.
1) Find length of the longest proper prefix of ‘str’ which is also a suffix. Let the length of the longest proper
prefix suffix be ‘len’. This can be computed in O(n) time using pre-processing step of KMP string matching
algorithm.
2) If value of ‘n – len’ divides n (or ‘n % (n-len)’ is 0), then return true, else return false.
In case of ‘true’ , the substring ‘str[0..n-len-1]’ is the substring that repeats n%(n-len) times.
Let us take few examples.
Input: str = “ABCDABCD”, n = 8 (Number of characters in ‘str’)

The value of len is 4 (“ABCD” is the longest substring which is both prefix and suffix)
Since (n-len) divides n, the answer is true.
Input: str = “ABCDABC”, n = 8 (Number of characters in ‘str’)

The value of len is 3 (“ABC” is the longest substring which is both prefix and suffix)
Since (n-len) doesn’t divides n, the answer is false.
Input: str = “ABCABCABCABCABC”, n = 15 (Number of characters in ‘str’)

The value of len is 12 (“ABCABCABCABC” is the longest substring which is both prefix and suffix)
Since (n-len) divides n, the answer is true.
How does this work?

length of longest proper prefix-suffix (or len) is always between 0 to n-1. If len is n-1, then all characters in
string are same. For example len is 3 for “AAAA”. If len is n-2 and n is even, then two characters in string
repeat n/2 times. For example “ABABABAB”, length of lps is 6. The reason is if the first n-2 characters are
same as last n-2 character, the starting from the first pair, every pair of characters is identical to the next
pair. The following diagram demonstrates same for substring of length 4.
// A C++ program to check if a string is 'n' times

// repetition of one of its substrings
#include<iostream>
#include<cstring>
// A utility function to fill lps[] or compute prefix funcrion

// used in KMP string matching algorithm. Refer
// http://www.geeksforgeeks.org/archives/11902 for details
void computeLPSArray(char str[], int M, int lps[])
{
int len = 0; //lenght of the previous longest prefix suffix
int i;
lps[0] = 0; //lps[0] is always 0

i = 1;
// the loop calculates lps[i] for i = 1 to M-1

while (i < M)
{
if (str[i] == str[len])
{
len++;
lps[i] = len;
i++;
}
else // (pat[i] != pat[len])
{
if (len != 0)
{
len = lps[len-1];
// Also, note that we do not increment i here

}
else // if (len == 0)
{
lps[i] = 0;
i++;
}
}
}
}
// Returns true if str is repetition of one of its substrings

// else return false.
bool isRepeat(char str[])
{
// Find length of string and create an array to
// store lps values used in KMP
int lps[n];
// Preprocess the pattern (calculate lps[] array)

computeLPSArray(str, n, lps);
// Find length of longest suffix which is also

// prefix of str.
int len = lps[n-1];
// If there exist a suffix which is also prefix AND

// Length of the remaining substring divides total
// length, then str[0..n-len-1] is the substring that
// repeats n/(n-len) times (Readers can print substring
// and value of n/(n-len) for more clarity.
return (len > 0 && n%(n-len) == 0)? true: false;
}

int main()
{
char txt[][100] = {"ABCABC", "ABABAB", "ABCDABCD", "GEEKSFORGEEKS",
"GEEKGEEK", "AAAACAAAAC", "ABCDABC"};
int n = sizeof(txt)/sizeof(txt[0]);
isRepeat(txt[i])? cout << "True\n" : cout << "False\n";
return 0;
}
Output:

True
True
True
False
True
True
False

Time Complexity: Time complexity of the above solution is O(n) as it uses KMP preprocessing algorithm
which is linear time algorithm.
Factorial of a large number
How to compute factorial of 100 using a C/C++ program?
Factorial of 100 has 158 digits. It is not possible to store these many digits even if we use long long int.
Following is a simple solution where we use an array to store individual digits of the result. The idea is to use
basic mathematics for multiplication.
The following is detailed algorithm for finding factorial.
factorial(n)
1) Create an array ‘res[]’ of MAX size where MAX is number of maximum digits in output.
2) Initialize value stored in ‘res[]’ as 1 and initialize ‘res_size’ (size of ‘res[]’) as 1.
3) Do following for all numbers from x = 2 to n.
……a) Multiply x with res[] and update res[] and res_size to store the multiplication result.
How to multiply a number ‘x’ with the number stored in res[]?

The idea is to use simple school mathematics. We one by one multiply x with every digit of res[]. The
important point to note here is digits are multiplied from rightmost digit to leftmost digit. If we store digits
in same order in res[], then it becomes difficult to update res[] without extra space. That is why res[] is
maintained in reverse way, i.e., digits from right to left are stored.
multiply(res[], x)
1) Initialize carry as 0.
2) Do following for i = 0 to res_size – 1
….a) Find value of res[i] * x + carry. Let this value be prod.
….b) Update res[i] by storing last digit of prod in it.
….c) Update carry by storing remaining digits in carry.
3) Put all digits of carry in res[] and increase res_size by number of digits in carry.
Example to show working of multiply(res[], x)

A number 5189 is stored in res[] as following.
res[] = {9, 8, 1, 5}
x = 10
Initialize carry = 0;
i = 0, prod = res[0]*x + carry = 9*10 + 0 = 90.

res[0] = 0, carry = 9
i = 1, prod = res[1]*x + carry = 8*10 + 9 = 89

res[1] = 9, carry = 8
i = 2, prod = res[2]*x + carry = 1*10 + 8 = 18

res[2] = 8, carry = 1
i = 3, prod = res[3]*x + carry = 5*10 + 1 = 51

res[3] = 1, carry = 5
res[4] = carry = 5
res[] = {0, 9, 8, 1, 5}

Below is C++ implementation of above algorithm.

// C++ program to compute factorial of big numbers
#include<iostream>
// Maximum number of digits in output

#define MAX 500
int multiply(int x, int res[], int res_size)
// This function finds factorial of large numbers and prints them

void factorial(int n)
{
int res[MAX];
res[0] = 1;
int res_size = 1;
// Apply simple factorial formula n! = 1 * 2 * 3 * 4...*n

for (int x=2; x<=n; x++)
res_size = multiply(x, res, res_size);
cout << "Factorial of given number is \n";

for (int i=res_size-1; i>=0; i--)
cout << res[i];
}
// This function multiplies x with the number represented by res[].

// res_size is size of res[] or number of digits in the number represented
// by res[]. This function uses simple school mathematics for multiplication.
// This function may value of res_size and returns the new value of res_size
int multiply(int x, int res[], int res_size)
{
// One by one multiply n with individual digits of res[]

for (int i=0; i<res_size; i++)
{
int prod = res[i] * x + carry;
res[i] = prod % 10; // Store last digit of 'prod' in res[]
carry = prod/10; // Put rest in carry
}
// Put carry in res and increase result size

while (carry)
{
res[res_size] = carry%10;
carry = carry/10;
res_size++;
}
return res_size;
}
// Driver program
int main()
{
factorial(100);
return 0;
}

Output:
Factorial of given number is

9332621544394415268169923885626670049071596826438162146859296389
5217599993229915608941463976156518286253697920827223758251185210
916864000000000000000000000000

The above approach can be optimized in many ways. We will soon be discussing optimized solution for
same.
Remove nodes on root to leaf paths of length
Given a Binary Tree and a number k, remove all nodes that lie only on root to leaf path(s) of length smaller
than k. If a node X lies on multiple root-to-leaf paths and if any of the paths has path length >= k, then X is
not deleted from Binary Tree. In other words a node is deleted if all paths going through it have lengths
smaller than k.
Consider the following example Binary Tree
1
/ \
2 3
/ \ \
4 5 6
/ /
7 8
Input: Root of above Binary Tree
k = 4
Output: The tree should be changed to following

1
/ \
2 3
/ \
4 6
/ /
7 8
There are 3 paths
i) 1->2->4->7 path length = 4
ii) 1->2->5 path length = 3
iii) 1->3->6->8 path length = 4
There is only one path " 1->2->5 " of length smaller than 4.
The node 5 is the only node that lies only on this path, so
node 5 is removed.
Nodes 2 and 1 are not removed as they are parts of other paths
of length 4 as well.
If k is 5 or greater than 5, then whole tree is deleted.
If k is 3 or less than 3, then nothing is deleted.

The idea here is to use post order traversal of the tree. Before removing a node we need to check that all the
children of that node in the shorter path are already removed. There are 2 cases for a node whose child or
cho
i) This node becomes a leaf node in which case it needs to be deleted.
ii) This node has other child on a path with path length >= k. In that case it needs not to be deleted.
A C++ based code on this approach is below
// C++ program to remove nodes on root to leaf paths of length < K

#include<iostream>
struct Node
struct Node
{
int data;
Node *left, *right;
};
//New node of a tree

{
node->data = data;
return node;
}
// Utility method that actually removes the nodes which are not
// on the pathLen >= k. This method can change the root as well.
Node *removeShortPathNodesUtil(Node *root, int level, int k)
{
//Base condition
if (root == NULL)
return NULL;
// Traverse the tree in postorder fashion so that if a leaf

// node path length is shorter than k, then that node and
// all of its descendants till the node which are not
// on some other path are removed.
root->left = removeShortPathNodesUtil(root->left, level + 1, k);
root->right = removeShortPathNodesUtil(root->right, level + 1, k);
// If root is a leaf node and it's level is less than k then

// remove this node.
// This goes up and check for the ancestor nodes also for the
// same condition till it finds a node which is a part of other
// path(s) too.
if (root->left == NULL && root->right == NULL && level < k)
{
delete root;
return NULL;
}
// Return root;
return root;
}
// Method which calls the utitlity method to remove the short path
// nodes.
Node *removeShortPathNodes(Node *root, int k)
{
int pathLen = 0;
return removeShortPathNodesUtil(root, 1, k);
}
//Method to print the tree in inorder fashion.

void printInorder(Node *root)
{
if (root)
{
}
}
// Driver method.
// Driver method.
int main()
{
int k = 4;
cout << "Inorder Traversal of Original tree" << endl;
printInorder(root);
cout << endl;
cout << "Inorder Traversal of Modified tree" << endl;
Node *res = removeShortPathNodes(root, k);
printInorder(res);
return 0;
}

Output:

Inorder Traversal of Original tree
7 4 2 5 1 3 8 6
Inorder Traversal of Modified tree
7 4 2 1 3 8 6

Time complexity of the above solution is O(n) where n is number of nodes in given Binary Tree.
Print all paths from a given source to a destination
Given a directed graph, a source vertex ‘s’ and a destination vertex ‘d’, print all paths from given ‘s’ to ‘d’.
Consider the following directed graph. Let the s be 2 and d be 3. There are 4 different paths from 2 to 3.
The idea is to do Depth First Traversal of given directed graph. Start the traversal from source. Keep storing
the visited vertices in an array say ‘path[]’. If we reach the destination vertex, print contents of path[]. The
important thing is to mark current vertices in path[] as visited also, so that the traversal doesn’t go in a cycle.
// C++ program to print all paths from a source to destination.

#include<iostream>
#include <list>
// A directed graph using adjacency list representation

class Graph
{
int V; // No. of vertices in graph
// A recursive function used by printAllPaths()

void printAllPathsUtil(int , int , bool [], int [], int &);
public:
void addEdge(int u, int v);
void printAllPaths(int s, int d);
};
Graph::Graph(int V)
{
this->V = V;
}
void Graph::addEdge(int u, int v)

{
adj[u].push_back(v); // Add v to u’s list.
}
// Prints all paths from 's' to 'd'

void Graph::printAllPaths(int s, int d)
void Graph::printAllPaths(int s, int d)
{
// Create an array to store paths

int *path = new int[V];
int path_index = 0; // Initialize path[] as empty
// Initialize all vertices as not visited

for (int i = 0; i < V; i++)
visited[i] = false;
// Call the recursive helper function to print all paths

printAllPathsUtil(s, d, visited, path, path_index);
}
// A recursive function to print all paths from 'u' to 'd'.

// visited[] keeps track of vertices in current path.
// path[] stores actual vertices and path_index is current
// index in path[]
void Graph::printAllPathsUtil(int u, int d, bool visited[],
int path[], int &path_index)
{
// Mark the current node and store it in path[]
visited[u] = true;
path[path_index] = u;
path_index++;
// If current vertex is same as destination, then print

// current path[]
if (u == d)
{
for (int i = 0; i<path_index; i++)
cout << path[i] << " ";
cout << endl;
}
else // If current vertex is not destination
{
// Recur for all the vertices adjacent to current vertex
if (!visited[*i])
printAllPathsUtil(*i, d, visited, path, path_index);
}
// Remove current vertex from path[] and mark it as unvisited

path_index--;
visited[u] = false;
}
// Driver program
int main()
{
Graph g(4);
g.addEdge(0, 1);
g.addEdge(0, 2);
g.addEdge(0, 3);
g.addEdge(2, 0);
g.addEdge(2, 1);
g.addEdge(1, 3);
int s = 2, d = 3;
cout << "Following are all different paths from " << s
cout << "Following are all different paths from " << s
<< " to " << d << endl;
g.printAllPaths(s, d);
return 0;
}
Output:
Following are all different paths from 2 to 3

2 0 1 3
2 0 3
2 1 3

This article is contributed by Shivam Gupta. Please write comments if you find anything incorrect, or you
Optimal read list for given number of days
A person is determined to finish the book in ‘k’ days but he never wants to stop a chapter in between. Find
the optimal assignment of chapters, such that the person doesn’t read too many extra/less pages overall.
Example 1:
Input: Number of Days to Finish book = 2
Number of pages in chapters = {10, 5, 5}
Output: Day 1: Chapter 1
Day 2: Chapters 2 and 3
Example 2:
Input: Number of Days to Finish book = 3
Number of pages in chapters = {8, 5, 6, 12}
Output: Day 1: Chapter 1
Day 2: Chapters 2 and 3
Day 2: Chapter 4

The target is to minimize the sum of differences between the pages read on each day and average number of
pages. If the average number of pages is a non-integer, then it should be rounded to closest integer.
In above example 2, average number of pages is (8 + 5 + 6 + 12)/3 = 31/3 which is rounded to 10. So the
difference between average and number of pages on each day for the output shown above is “abs(8-10) +
abs(5+6-10) + abs(12-10)” which is 5. The value 5 is the optimal value of sum of differences.
Consider the example 2 above where a book has 4 chapters with pages 8, 5, 6 and 12. User wishes to finish it
in 3 days. The graphical representation of the above scenario is,
In the above graph vertex represents the chapter and an edge e(u, v) represents number of pages to be read
to reach ‘v ‘ from ‘u ‘. Sink node is added to symbolize the end of book.
First, calculate the average number of pages to read in a day (here 31/3 roughly 10). New edge weight e ‘(u,
v) would be the mean difference |avg – e(u, v)|. Modified graph for the above problem would be,
Thanks to Armadillo for initiating this thought in a comment.
The idea is to start from chapter 1 and do a DFS to find sink with count of edges being ‘k ‘. Keep storing the
visited vertices in an array say ‘path[]’. If we reach the destination vertex, and path sum is less than the
optimal path update the optimal assignment optimal_path[]. Note, that the graph is DAG thus there is no
need to take care of cycles during DFS.
Following, is the C++ implementation of the same, adjacency matrix is used to represent the graph. The
following program has mainly 4 phases.
1) Construct a directed acyclic graph.
2) Find the optimal path using DFS.
3) Print the found optimal path.
// C++ DFS solution to schedule chapters for reading in

// given days
# include <iostream>
# include <cstdlib>
# include <climits>
# include <cmath>
// Define total chapters in the book

// Number of days user can spend on reading
# define CHAPTERS 4
# define DAYS 3
# define NOLINK -1
// Array to store the final balanced schedule

int optimal_path[DAYS+1];
// Graph - Node chapter+1 is the sink described in the

// above graph
int DAG[CHAPTERS+1][CHAPTERS+1];
// Updates the optimal assignment with current assignment

void updateAssignment(int* path, int path_len);
// A DFS based recursive function to store the optimal path

// in path[] of size path_len. The variable sum stores sum of
// of all edges on current path. k is number of days spent so
// far.
void assignChapters(int u, int* path, int path_len, int sum, int k)
{
static int min = INT_MAX;
// Ignore the assignment which requires more than required days
if (k < 0)
return;
// Current assignment of chapters to days

path[path_len] = u;
path_len++;
// Update the optimal assignment if necessary

if (k == 0 && u == CHAPTERS)
{
if (sum < min)
{
updateAssignment(path, path_len);
min = sum;
}
}
// DFS - Depth First Search for sink

for (int v = u+1; v <= CHAPTERS; v++)
{
sum += DAG[u][v];
assignChapters(v, path, path_len, sum, k-1);
sum -= DAG[u][v];
}
}
// This function finds and prints optimal read list. It first creates a
// graph, then calls assignChapters().
void minAssignment(int pages[])
{
// 1) ............CONSTRUCT GRAPH.................
// Partial sum array construction S[i] = total pages
// till ith chapter
int avg_pages = 0, sum = 0, S[CHAPTERS+1], path[DAYS+1];
S[0] = 0;
for (int i = 0; i < CHAPTERS; i++)

{
sum += pages[i];
S[i+1] = sum;
}
// Average pages to be read in a day

avg_pages = round(sum/DAYS);
/* DAG construction vertices being chapter name &

* Edge weight being |avg_pages - pages in a chapter|
* Adjacency matrix representation */
for (int i = 0; i <= CHAPTERS; i++)
{
for (int j = 0; j <= CHAPTERS; j++)
{
if (j <= i)
DAG[i][j] = NOLINK;
else
{
sum = abs(avg_pages - (S[j] - S[i]));
DAG[i][j] = sum;
}
}
}
// 2) ............FIND OPTIMAL PATH................
assignChapters(0, path, 0, 0, DAYS);
// 3) ..PRINT OPTIMAL READ LIST USING OPTIMAL PATH....

cout << "Optimal Chapter Assignment :" << endl;
int ch;
for (int i = 0; i < DAYS; i++)
{
ch = optimal_path[i];
cout << "Day" << i+1 << ": " << ch << " ";
ch++;
while ( (i < DAYS-1 && ch < optimal_path[i+1]) ||
(i == DAYS-1 && ch <= CHAPTERS))
{
cout << ch << " ";
ch++;
}
cout << endl;
}
}
// This funtion updates optimal_path[]

void updateAssignment(int* path, int path_len)
{
for (int i = 0; i < path_len; i++)
optimal_path[i] = path[i] + 1;
}
// Driver program to test the schedule

int main(void)
{
int pages[CHAPTERS] = {7, 5, 6, 12};
// Get read list for given days

minAssignment(pages);
return 0;
}

Output:

Optimal Chapter Assignment :
Day1: 1
Day2: 2 3
Day3: 4

This article is contributed by Balaji S. Please write comments if you find anything incorrect, or you want to
Weighted Job Scheduling
Given N jobs where every job is represented by following three elements of it.
1) Start Time
2) Finish Time.
3) Profit or Value Associated.
Find the maximum profit subset of jobs such that no two jobs in the subset overlap.
Example:
Input: Number of Jobs n = 4

Job Details {Start Time, Finish Time, Profit}
Job 1: {1, 2, 50}
Job 2: {3, 5, 20}
Job 3: {6, 19, 100}
Job 4: {2, 100, 200}
Output: The maximum profit is 250.
We can get the maximum profit by scheduling jobs 1 and 4.
Note that there is longer schedules possible Jobs 1, 2 and 3
but the profit with this schedule is 20+50+100 which is less than 250.

A simple version of this problem is discussed here where every job has same profit or value. The Greedy
Strategy for activity selection doesn’t work here as the longer schedule may have smaller profit or value.
The above problem can be solved using following recursive solution.
1) First sort jobs according to finish time.

2) Now apply following recursive process.
// Here arr[] is array of n jobs
findMaximumProfit(arr[], n)
{
a) if (n == 1) return arr[0];
b) Return the maximum of following two profits.
(i) Maximum profit by excluding current job, i.e.,
findMaximumProfit(arr, n-1)
(ii) Maximum profit by including the current job
}
How to find the profit excluding current job?

The idea is to find the latest job before the current job (in
sorted array) that doesn't conflict with current job 'arr[n-1]'.
Once we find such a job, we recur for all jobs till that job and
add profit of current job to result.
In the above example, for job 1 is the latest non-conflicting
job for job 4 and job 2 is the latest non-conflicting job for
job 3.

The following is C++ implementation of above naive recursive method.
// C++ program for weighted job scheduling using Naive Recursive Method
#include <iostream>
#include <iostream>
// A job has start time, finish time and profit.

struct Job
{
int start, finish, profit;
};
// A utility function that is used for sorting events

// according to finish time
bool myfunction(Job s1, Job s2)
{
return (s1.finish < s2.finish);
}
// Find the latest job (in sorted array) that doesn't

// conflict with the job[i]. If there is no compatible job,
// then it returns -1.
int latestNonConflict(Job arr[], int i)
{
for (int j=i-1; j>=0; j--)
{
if (arr[j].finish <= arr[i-1].start)
return j;
}
return -1;
}
// A recursive function that returns the maximum possible

// profit from given array of jobs. The array of jobs must
// be sorted according to finish time.
int findMaxProfitRec(Job arr[], int n)
{
// Base case
if (n == 1) return arr[n-1].profit;
// Find profit when current job is inclueded

int inclProf = arr[n-1].profit;
int i = latestNonConflict(arr, n);
if (i != -1)
inclProf += findMaxProfitRec(arr, i+1);
// Find profit when current job is excluded

int exclProf = findMaxProfitRec(arr, n-1);
return max(inclProf, exclProf);

}
// The main function that returns the maximum possible

// profit from given array of jobs
int findMaxProfit(Job arr[], int n)
{
// Sort jobs according to finish time
sort(arr, arr+n, myfunction);
return findMaxProfitRec(arr, n);

}
// Driver program
int main()
{
Job arr[] = {{3, 10, 20}, {1, 2, 50}, {6, 19, 100}, {2, 100, 200}};
cout << "The optimal profit is " << findMaxProfit(arr, n);
return 0;
}

Output:

The optimal profit is 250

The above solution may contain many overlapping subproblems. For example if lastNonConflicting() always
returns previous job, then findMaxProfitRec(arr, n-1) is called twice and the time complexity becomes
O(n*2n). As another example when lastNonConflicting() returns previous to previous job, there are two
recursive calls, for n-2 and n-1. In this example case, recursion becomes same as Fibonacci Numbers.
So this problem has both properties of Dynamic Programming, Optimal Substructure and Overlapping
Subproblems.
Like other Dynamic Programming Problems, we can solve this problem by making a table that stores
solution of subproblems.
Below is C++ implementation based on Dynamic Programming.
// C++ program for weighted job scheduling using Dynamic Programming.

#include <iostream>
// A job has start time, finish time and profit.

struct Job
{
int start, finish, profit;
};
// A utility function that is used for sorting events

// according to finish time
bool myfunction(Job s1, Job s2)
{
return (s1.finish < s2.finish);
}
// Find the latest job (in sorted array) that doesn't

// conflict with the job[i]
int latestNonConflict(Job arr[], int i)
{
for (int j=i-1; j>=0; j--)
{
if (arr[j].finish <= arr[i].start)
return j;
}
return -1;
}
// The main function that returns the maximum possible

// profit from given array of jobs
int findMaxProfit(Job arr[], int n)
{
sort(arr, arr+n, myfunction);
// Create an array to store solutions of subproblems. table[i]

// stores the profit for jobs till arr[i] (including arr[i])
int *table = new int[n];
table[0] = arr[0].profit;
// Fill entries in M[] using recursive property

{
// Find profit including the current job
int inclProf = arr[i].profit;
int l = latestNonConflict(arr, i);
if (l != -1)
inclProf += table[l];
// Store maximum of including and excluding

table[i] = max(inclProf, table[i-1]);
}
// Store result and free dynamic memory allocated for table[]

int result = table[n-1];
delete[] table;
return result;
}
// Driver program
int main()
{
Job arr[] = {{3, 10, 20}, {1, 2, 50}, {6, 19, 100}, {2, 100, 200}};
cout << "The optimal profit is " << findMaxProfit(arr, n);
return 0;
}

Output:
The optimal profit is 250

Time Complexity of the above Dynamic Programming Solution is O(n2). Note that the above solution can be
optimized to O(nLogn) using Binary Search in latestNonConflict() instead of linear search. Thanks to Garvit
for suggesting this optimization.
References:
http://courses.cs.washington.edu/courses/cse521/13wi/slides/06dp-sched.pdf
Applications of Breadth First Traversal
We have earlier discussed Breadth First Traversal Algorithm for Graphs. We have also discussed
Applications of Depth First Traversal. In this article, applications of Breadth First Search are discussed.
1) Shortest Path and Minimum Spanning Tree for unweighted graph In unweighted graph, the
shortest path is the path with least number of edges. With Breadth First, we always reach a vertex from given
source using minimum number of edges. Also, in case of unweighted graphs, any spanning tree is Minimum
Spanning Tree and we can use either Depth or Breadth first traversal for finding a spanning tree.
2) Peer to Peer Networks. In Peer to Peer Networks like BitTorrent, Breadth First Search is used to find
all neighbor nodes.
3) Crawlers in Search Engines: Crawlers build index using Bread First. The idea is to start from source
page and follow all links from source and keep doing same. Depth First Traversal can also be used for
crawlers, but the advantage with Breadth First Traversal is, depth or levels of built tree can be limited.
4) Social Networking Websites: In social networks, we can find people within a given distance ‘k’ from a
person using Breadth First Search till ‘k’ levels.
5) GPS Navigation systems: Breadth First Search is used to find all neighboring locations.
6) Broadcasting in Network: In networks, a broadcasted packet follows Breadth First Search to reach all
nodes.
7) In Garbage Collection: Breadth First Search is used in copying garbage collection using Cheney’s
algorithm. Refer this and for details. Breadth First Search is preferred over Depth First Search because of
better locality of reference:
8) Cycle detection in undirected graph: In undirected graphs, either Breadth First Search or Depth
First Search can be used to detect cycle. In directed graph, only depth first search can be used.
9) Ford–Fulkerson algorithm In Ford-Fulkerson algorithm, we can either use Breadth First or Depth
First Traversal to find the maximum flow. Breadth First Traversal is preferred as it reduces worst case time
complexity to O(VE2).
10) To test if a graph is Bipartite We can either use Breadth First or Depth First Traversal.
11) Path Finding We can either use Breadth First or Depth First Traversal to find if there is a path between
two vertices.
12) Finding all nodes within one connected component: We can either use Breadth First or Depth
First Traversal to find all nodes reachable from a given node.
Many algorithms like Prim’s Minimum Spanning Tree and Dijkstra’s Single Source Shortest Path use
structure similar to Breadth First Search.
There can be many more applications as Breadth First Search is one of the core algorithm for Graphs.
This article is contributed by Neeraj Jain. Please write comments if you find anything incorrect, or you
Fill two instances of all numbers from 1 to n in a specific way
Given a number n, create an array of size 2n such that the array contains 2 instances of every number from 1
to n, and the number of elements between two instances of a number i is equal to i. If such a configuration is
not possible, then print the same.
Examples:
Input: n = 3
Output: res[] = {3, 1, 2, 1, 3, 2}
Input: n = 2
Output: Not Possible
Input: n = 4
Output: res[] = {4, 1, 3, 1, 2, 4, 3, 2}

One solution is to Backtracking. The idea is simple, we place two instances of n at a place, then recur for n-1.
If recurrence is successful, we return true, else we backtrack and try placing n at different location.
Following is C implementation of the idea.

// A backtracking based C Program to fill two instances of all numbers

// from 1 to n in a specific way
#include <stdio.h>
// A recursive utility function to fill two instances of numbers from

// 1 to n in res[0..2n-1]. 'curr' is current value of n.
bool fillUtil(int res[], int curr, int n)
{
// If current number becomes 0, then all numbers are filled
if (curr == 0) return true;
// Try placing two instances of 'curr' at all possible locations

// till solution is found
int i;
for (i=0; i<2*n-curr-1; i++)
{
// Two 'curr' should be placed at 'curr+1' distance
if (res[i] == 0 && res[i + curr + 1] == 0)
{
// Plave two instances of 'curr'
res[i] = res[i + curr + 1] = curr;
// Recur to check if the above placement leads to a solution

if (fillUtil(res, curr-1, n))
return true;
// If solution is not possible, then backtrack

res[i] = res[i + curr + 1] = 0;
}
}
return false;
}
// This function prints the result for input number 'n' using fillUtil()
void fill(int n)
{
// Create an array of size 2n and initialize all elements in it as 0
int res[2*n], i;
for (i=0; i<2*n; i++)
res[i] = 0;
// If solution is possible, then print it.

if (fillUtil(res, n, n))
{
for (i=0; i<2*n; i++)
printf("%d ", res[i]);
}
else
puts("Not Possible");
}
// Driver program
int main()
{
fill(7);
return 0;
}

Output:

7 3 6 2 5 3 2 4 7 6 5 1 4 1

The above solution may not be the best possible solution. There seems to be a pattern in the output. I an
Looking for a better solution from other geeks.
This article is contributed by Asif. Please write comments if you find anything incorrect, or you want to
Can QuickSort be implemented in O(nLogn) worst case time complexity?
The worst case time complexity of a typical implementation of QuickSort is O(n2). The worst case occurs
when the picked pivot is always an extreme (smallest or largest) element. This happens when input array is
sorted or reverse sorted and either first or last element is picked as pivot.
Although randomized QuickSort works well even when the array is sorted, there is still possibility that the
randomly picked element is always an extreme. Can the worst case be reduced to O(nLogn)?
The answer is yes, we can achieve O(nLogn) worst case. The idea is based on the fact that the median
element of an unsorted array can be found in linear time. So we find the median first, then partition the
array around the median element.
Following is C++ implementation based on above idea. Most of the functions in below progran are copied
from K’th Smallest/Largest Element in Unsorted Array | Set 3 (Worst Case Linear Time)
/* A worst case O(nLogn) implementation of quicksort */

#include<cstring>
#include<iostream>
#include<algorithm>
#include<climits>
// Following functions are taken from http://goo.gl/ih05BF

int partition(int arr[], int l, int r, int k);
int kthSmallest(int arr[], int l, int r, int k);
/* A O(nLogn) time complexity function for sorting arr[l..h] */

void quickSort(int arr[], int l, int h)
{
if (l < h)
{
// Find size of current subarray
int n = h-l+1;
// Find median of arr[].

int med = kthSmallest(arr, l, h, n/2);
// Partition the array around median

int p = partition(arr, l, h, med);
// Recur for left and right of partition

quickSort(arr, l, p - 1);
quickSort(arr, p + 1, h);
}
}
// A simple function to find median of arr[]. This is called

// only for an array of size 5 in this program.
int findMedian(int arr[], int n)
{
sort(arr, arr+n); // Sort the array
return arr[n/2]; // Return middle element
}
// Returns k'th smallest element in arr[l..r] in worst case

// linear time. ASSUMPTION: ALL ELEMENTS IN ARR[] ARE DISTINCT
{
if (k > 0 && k <= r - l + 1)
{
int n = r-l+1; // Number of elements in arr[l..r]
// Divide arr[] in groups of size 5, calculate median

// of every group and store it in median[] array.
int i, median[(n+4)/5]; // There will be floor((n+4)/5) groups;
for (i=0; i<n/5; i++)
median[i] = findMedian(arr+l+i*5, 5);
if (i*5 < n) //For last group with less than 5 elements
{
median[i] = findMedian(arr+l+i*5, n%5);
i++;
}
// Find median of all medians using recursive call.

// If median[] has only one element, then no need
// of recursive call
int medOfMed = (i == 1)? median[i-1]:
kthSmallest(median, 0, i-1, i/2);

int pos = partition(arr, l, r, medOfMed);
if (pos-l == k-1)
return arr[pos];
if (pos-l > k-1) // If position is more, recur for left

}

return INT_MAX;
}

{
int temp = *a;
*a = *b;
*b = temp;
}
// It searches for x in arr[l..r], and partitions the array

// around x.
int partition(int arr[], int l, int r, int x)
{
// Search for x in arr[l..r] and move it to end
int i;
for (i=l; i<r; i++)
if (arr[i] == x)
break;
// Standard partition algorithm

i = l;
for (int j = l; j <= r - 1; j++)
{
if (arr[j] <= x)
{
i++;
}
}
return i;
}
/* Function to print an array */

{
int i;
cout << arr[i] << " ";
cout << endl;
}

int main()
{
int arr[] = {1000, 10, 7, 8, 9, 30, 900, 1, 5, 6, 20};
quickSort(arr, 0, n-1);
cout << "Sorted array is\n";
printArray(arr, n);
return 0;
}

Output:

Sorted array is
1 5 6 7 8 9 10 20 30 900 1000

How is QuickSort implemented in practice – is above approach used?

Although worst case time complexity of the above approach is O(nLogn), it is never used in practical
implementations. The hidden constants in this approach are high compared to normal Quicksort. Following
are some techniques used in practical implementations of QuickSort.
1) Randomly picking up to make worst case less likely to occur (Randomized QuickSort)
2) Calling insertion sort for small sized arrays to reduce recursive calls.
3) QuickSort is tail recursive, so tail call optimizations is done.
So the approach discussed above is more of a theoretical approach with O(nLogn) worst case time
complexity.
This article is compiled by Shivam. Please write comments if you find anything incorrect, or you want to
Find sum of all left leaves in a given Binary Tree
Given a Binary Tree, find sum of all left leaves in it. For example, sum of all left leaves in below Binary Tree
is 5+23+50 = 78.
The idea is to traverse the tree, starting from root. For every node, check if its left subtree is a leaf. If it is,
then add it to the result.
// A C++ program to find sum of all left leaves

#include <iostream>
/* A binary tree Node has key, pointer to left and right

children */
struct Node
{
int key;
};

given data and NULL left and right pointer. */
{
node->key = k;
return node;
}
// A utility function to check if a given node is leaf or not

bool isLeaf(Node *node)
{
if (node == NULL)
return false;
if (node->left == NULL && node->right == NULL)
return true;
return false;
}
}
// This function returns sum of all left leaves in a given

// binary tree
int leftLeavesSum(Node *root)
{
int res = 0;
// Update result if root is not NULL

if (root != NULL)
{
// If left of root is NULL, then add key of
// left child
if (isLeaf(root->left))
res += root->left->key;
else // Else recur for left child of root
res += leftLeavesSum(root->left);
// Recur for right child of root and update res

res += leftLeavesSum(root->right);
}
// return result
return res;
}

int main()
{
// Let us construct the Binary Tree shown in the
// above figure
cout << "Sum of left leaves is "
<< leftLeavesSum(root);
return 0;
}

Output:

Sum of left leaves is 78

Time complexity of the above solution is O(n) where n is number of nodes in Binary Tree.
Following is Another Method to solve the above problem. This solution passes in a sum variable as an
accumulator. When a left leaf is encountered, the leaf’s data is added to sum. Time complexity of this
method is also O(n). Thanks to Xin Tong (geeksforgeeks userid trent.tong) for suggesting this method.

#include <iostream>
/* A binary tree Node has key, pointer to left and right

children */
struct Node
{
int key;
};

given data and NULL left and right pointer. */
{
node->key = k;
return node;
}
/* Pass in a sum variable as an accumulator */

void leftLeavesSumRec(Node *root, bool isleft, int *sum)
{
if (!root) return;
// Check whether this node is a leaf node and is left.

if (!root->left && !root->right && isleft)
*sum += root->key;
// Pass 1 for left and 0 for right

leftLeavesSumRec(root->left, 1, sum);
leftLeavesSumRec(root->right, 0, sum);
}
// A wrapper over above recursive function

int leftLeavesSum(Node *root)
{
int sum = 0; //Initialize result
// use the above recursive function to evaluate sum

leftLeavesSumRec(root, 0, &sum);
return sum;
}

int main()
{
// Let us construct the Binary Tree shown in the
// above figure
int sum = 0;
cout << "Sum of left leaves is " << leftLeavesSum(root) << endl;
return 0;
return 0;
}

Output:

Sum of left leaves is 78

This article is contributed by Manish. Please write comments if you find anything incorrect, or you want to
Find length of period in decimal value of 1/n
Given a positive integer n, find the period in decimal value of 1/n. Period in decimal value is number of digits
(somewhere after decimal point) that keep repeating.
Examples:
Input: n = 3
Output: 1
The value of 1/3 is 0.333333...
Input: n = 7
Output: 6
The value of 1/7 is 0.142857142857142857.....
Input: n = 210
Output: 6
The value of 1/210 is 0.0047619047619048.....

Let us first discuss a simpler problem of finding individual digits in value of 1/n.
How to find individual digits in value of 1/n?

Let us take an example to understand the process. For example for n = 7. The first digit can be obtained by
doing 10/7. Second digit can be obtained by 30/7 (3 is remainder in previous division). Third digit can be
obtained by 20/7 (2 is remainder of previous division). So the idea is to get the first digit, then keep taking
value of (remainder * 10)/n as next digit and keep updating remainder as (remainder * 10) % 10. The
complete program is discussed here.
How to find the period?

The period of 1/n is equal to the period in sequence of remainders used in the above process. This can be
easily proved from the fact that digits are directly derived from remainders.
One interesting fact about sequence of remainders is, all terns in period of this remainder sequence are
distinct. The reason for this is simple, if a remainder repeats, then it’s beginning of new period.

// C++ program to find length of period of 1/n

#include <iostream>
#include <map>
// Function to find length of period in 1/n

int getPeriod(int n)
{
// Create a map to store mapping from remainder
// its position
map<int, int> mymap;
map<int, int>::iterator it;
// Initialize remainder and position of remainder

int rem = 1, i = 1;
// Keep finding remainders till a repeating remainder

// is found
while (true)
{
// Find next remainder
rem = (10*rem) % n;
// If remainder exists in mymap, then the difference

// between current and previous position is length of
// period
it = mymap.find(rem);
if (it != mymap.end())
return (i - it->second);
// If doesn't exist, then add 'i' to mymap

mymap[rem] = i;
i++;
}
// This code should never be reached

return INT_MAX;
}

int main()
{
cout << getPeriod(3) << endl;
return 0;
}

Output:
1
6

We can avoid the use of map or hash using the following fact. For a number n, there can be at most n distinct
remainders. Also, the period may not begin from the first remainder as some initial remainders may be non-
repetitive (not part of any period). So to make sure that a remainder from a period is picked, start from the
(n+1)th remainder and keep looking for its next occurrence. The distance between (n+1)’th remainder and its
next occurrence is the length of the period.
// C++ program to find length of period of 1/n without

// using map or hash
#include <iostream>
// Function to find length of period in 1/n

int getPeriod(int n)
{
// Find the (n+1)th remainder after decimal point
// in value of 1/n
int rem = 1; // Initialize remainder
for (int i = 1; i <= n+1; i++)
rem = (10*rem) % n;
// Store (n+1)th remainder

int d = rem;
// Count the number of remainders before next

// occurrence of (n+1)'th remainder 'd'
int count = 0;
do {
rem = (10*rem) % n;
count++;
} while(rem != d);
return count;
}

int main()
{
return 0;
}

Output:
1
6

Reference:
Algorithms And Programming: Problems And Solutions by Alexander Shen
Greedy Algorithm for Egyptian Fraction
Every positive fraction can be represented as sum of unique unit fractions. A fraction is unit fraction if
numerator is 1 and denominator is a positive integer, for example 1/3 is a unit fraction. Such a
representation is called Egyptial Fraction as it was used by ancient Egyptians.
Following are few examples:
Egyptian Fraction Representation of 2/3 is 1/2 + 1/6

Egyptian Fraction Representation of 6/14 is 1/3 + 1/11 + 1/231
Egyptian Fraction Representation of 12/13 is 1/2 + 1/3 + 1/12 + 1/156

We can generate Egyptian Fractions using Greedy Algorithm. For a given number of the form ‘nr/dr’ where
dr > nr, first find the greatest possible unit fraction, then recur for the remaining part. For example, consider
6/14, we first find ceiling of 14/6, i.e., 3. So the first unit fraction becomes 1/3, then recur for (6/14 – 1/3)
i.e., 4/42.
Below is C++ implementation of above idea.

// C++ program to print a fraction in Egyptian Form using Greedy

// Algorithm
#include <iostream>
void printEgyptian(int nr, int dr)

{
// If either numerator or denominator is 0
if (dr == 0 || nr == 0)
return;
// If numerator divides denominator, then simple division

// makes the fraction in 1/n form
if (dr%nr == 0)
{
cout << "1/" << dr/nr;
return;
}
// If denominator divides numerator, then the given number

// is not fraction
if (nr%dr == 0)
{
cout << nr/dr;
return;
}
// If numerator is more than denominator

if (nr > dr)
{
cout << nr/dr << " + ";
printEgyptian(nr%dr, dr);
return;
}
// We reach here dr > nr and dr%nr is non-zero

// Find ceiling of dr/nr and print it as first
// fraction
int n = dr/nr + 1;
cout << "1/" << n << " + ";
// Recur for remaining part

printEgyptian(nr*n-dr, dr*n);
}
// Driver Program
int main()
{
int nr = 6, dr = 14;
cout << "Egyptian Fraction Representation of "
<< nr << "/" << dr << " is\n ";
printEgyptian(nr, dr);
return 0;
}

Output:

Egyptian Fraction Representation of 6/14 is
1/3 + 1/11 + 1/231

The Greedy algorithm works because a fraction is always reduced to a form where denominator is greater
than numerator and numerator doesn’t divide denominator. For such reduced forms, the highlighted
recursive call is made for reduced numerator. So the recursive calls keep on reducing the numerator till it
reaches 1.
References:
http://www.maths.surrey.ac.uk/hosted-sites/R.Knott/Fractions/egyptian.html
Check whether a binary tree is a full binary tree or not
A full binary tree is defined as a binary tree in which all nodes have either zero or two child nodes.
Conversely, there is no node in a full binary tree, which has one child node. More information about full
binary trees can be found here.
For Example:
To check whether a binary tree is a full binary tree we need to test the following cases:-
1) If a binary tree node is NULL then it is a full binary tree.

2) If a binary tree node does have empty left and right sub-trees, then it is a full binary tree by definition
3) If a binary tree node has left and right sub-trees, then it is a part of a full binary tree by definition. In this
case recursively check if the left and right sub-trees are also binary trees themselves.
4) In all other combinations of right and left sub-trees, the binary tree is not a full binary tree.
Following is the C code for checking if a binary tree is a full binary tree.
// C program to check whether a given Binary Tree is full or not

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
/* Tree node structure */

struct Node
{
int key;
};
given key and NULL left and right pointer. */
struct Node *newNode(char k)
{
struct Node *node = (struct Node*)malloc(sizeof(struct Node));
node->key = k;
return node;
}
/* This function tests if a binary tree is a full binary tree. */

bool isFullTree (struct Node* root)
{
// If empty tree
if (root == NULL)
return true;
// If leaf node
return true;
// If both left and right are not NULL, and left & right subtrees
// are full
if ((root->left) && (root->right))
return (isFullTree(root->left) && isFullTree(root->right));
// We reach here when none of the above if conditions work

return false;
}
// Driver Program
int main()
{
root = newNode(10);
if (isFullTree(root))
printf("The Binary Tree is full\n");
else
printf("The Binary Tree is not full\n");
return(0);
}

Output:

The Binary Tree is full

Time complexity of the above code is O(n) where n is number of nodes in given binary tree.
This article is contributed by Gaurav Gupta. Please write comments if you find anything incorrect, or you
An interesting time complexity question
What is the time complexity of following function fun()?
int fun(int n)
{
for (int i = 1; i <= n; i++)
{
for (int j = 1; j < n; j += i)
{
// Some O(1) task
}
}
}

For i = 1, the inner loop is executed n times.

For i = 2, the inner loop is executed approximately n/2 times.
…………………………………………………….
…………………………………………………….
For i = n, the inner loop is executed approximately n/n times.
So the total time complexity of the above algorithm is (n + n/2 + n/3 + … + n/n)
Which becomes n * (1/1 + 1/2 + 1/3 + … + 1/n)
The important thing about series (1/1 + 1/2 + 1/3 + … + 1/n) is, it is equal to Θ(Logn) (See
this for reference).
So the time complexity of the above code is Θ(nLogn).
As a side note, the sum of infinite harmonic series is counterintuitive as the series diverges. The value of
is ∞. This is unlike geometric series as geometric series with ratio less than 1 converges.
Reference:
http://en.wikipedia.org/wiki/Harmonic_series_%28mathematics%29#Rate_of_divergence
http://staff.ustc.edu.cn/~csli/graduate/algorithms/book6/chap03.htm
This article is contributed by Rahul. Please write comments if you find anything incorrect, or you want to
Find all distinct palindromic sub-strings of a given string
Given a string of lowercase ASCII characters, find all distinct continuous palindromic sub-strings of it.
Examples:
Input: str = "abaaa"

Output: Below are 5 palindrome sub-strings
a
aa
aaa
aba
b
Input: str = "geek"

Output: Below are 4 palindrome sub-strings
e
ee
g
k

Step 1: Finding all palindromes using modified Manacher’s algorithm:

Considering each character as a pivot, expand on both sides to find the length of both even and odd length
palindromes centered at the pivot character under consideration and store the length in the 2 arrays (odd &
even).
Time complexity for this step is O(n^2)
Step 2: Inserting all the found palindromes in a HashMap:

Insert all the palindromes found from the previous step into a HashMap. Also insert all the individual
characters from the string into the HashMap (to generate distinct single letter palindromic sub-strings).
Time complexity of this step is O(n^3) assuming that the hash insert search takes O(1) time. Note that there
can be at most O(n^2) palindrome sub-strings of a string. In below C++ code ordered hashmap is used
where the time complexity of insert and search is O(Logn). In C++, ordered hashmap is implemented using
Red Black Tree.
Step 3: Printing the distinct palindromes and number of such distinct palindromes:
The last step is to print all values stored in the HashMap (only distinct elements will be hashed due to the
property of HashMap). The size of the map gives the number of distinct palindromic continuous sub-strings.
// C++ program to find all distinct palindrome sub-strings

// of a given string
#include <iostream>
#include <map>
// Function to print all distinct palindrome sub-strings of s

void palindromeSubStrs(string s)
{
map<string, int> m;
int n = s.size();
// table for storing results (2 rows for odd-

// table for storing results (2 rows for odd-
// and even-length palindromes
int R[2][n+1];
// Find all sub-string palindromes from the given input

// string insert 'guards' to iterate easily over s
s = "@" + s + "#";
for (int j = 0; j <= 1; j++)

{
int rp = 0; // length of 'palindrome radius'
R[j][0] = 0;
int i = 1;
while (i <= n)
{
// Attempt to expand palindrome centered at i
while (s[i - rp - 1] == s[i + j + rp])
rp++; // Incrementing the length of palindromic
// radius as and when we find vaid palindrome
// Assigning the found palindromic length to odd/even

// length array
R[j][i] = rp;
int k = 1;
while ((R[j][i - k] != rp - k) && (k < rp))
{
R[j][i + k] = min(R[j][i - k],rp - k);
k++;
}
rp = max(rp - k,0);
i += k;
}
}
// remove 'guards'
s = s.substr(1, n);
// Put all obtained palindromes in a hash map to

// find only distinct palindromess
m[string(1, s[0])]=1;
for (int i = 1; i <= n; i++)
{
for (int j = 0; j <= 1; j++)
for (int rp = R[j][i]; rp > 0; rp--)
m[s.substr(i - rp - 1, 2 * rp + j)]=1;
m[string(1, s[i])]=1;
}
//printing all distinct palindromes from hash map

cout << "Below are " << m.size()-1
<< " palindrome sub-strings";
map<string, int>::iterator ii;
for (ii = m.begin(); ii!=m.end(); ++ii)
cout << (*ii).first << endl;
}
// Driver program
int main()
{
palindromeSubStrs("abaaa");
return 0;
}

Output:

Below are 5 palindrome sub-strings
a
aa
aaa
aba
b

This article is contributed by Vignesh Narayanan and Sowmya Sampath. Please write comments if you find
Find a common element in all rows of a given row-wise sorted matrix
Given a matrix where every row is sorted in increasing order. Write a function that finds and returns a
common element in all rows. If there is no common element, then returns -1.
Example:

Input: mat[4][5] = { {1, 2, 3, 4, 5},
{2, 4, 5, 8, 10},
{3, 5, 7, 9, 11},
{1, 3, 5, 7, 9},
};
Output: 5

A O(m*n*n) simple solution is to take every element of first row and search it in all other rows, till we
find a common element. Time complexity of this solution is O(m*n*n) where m is number of rows and n is
number of columns in given matrix. This can be improved to O(m*n*Logn) if we use Binary Search instead of
linear search.
We can solve this problem in O(mn) time using the approach similar to merge of Merge Sort. The idea is to
start from the last column of every row. If elements at all last columns are same, then we found the common
element. Otherwise we find the minimum of all last columns. Once we find a minimum element, we know
that all other elements in last columns cannot be a common element, so we reduce last column index for all
rows except for the row which has minimum value. We keep repeating these steps till either all elements at
current last column don’t become same, or a last column index reaches 0.
Below is C implementation of above idea.
// A C program to find a common element in all rows of a

// row wise sorted array
#include<stdio.h>
// Specify number of rows and columns

#define M 4
#define N 5
// Returns common element in all rows of mat[M][N]. If there is no

// common element, then -1 is returned
int findCommon(int mat[M][N])
{
// An array to store indexes of current last column
int column[M];
int min_row; // To store index of row whose current
// last element is minimum
// Initialize current last element of all rows

int i;
for (i=0; i<M; i++)
column[i] = N-1;
min_row = 0; // Initialize min_row as first row
// Keep finding min_row in current last column, till either

// all elements of last column become same or we hit first column.
while (column[min_row] >= 0)
{
{
// Find minimum in current last column
for (i=0; i<M; i++)
{
if (mat[i][column[i]] < mat[min_row][column[min_row]] )
min_row = i;
}
// eq_count is count of elements equal to minimum in current last

// column.
int eq_count = 0;
// Travers current last column elements again to update it

for (i=0; i<M; i++)
{
// Decrease last column index of a row whose value is more
// than minimum.
if (mat[i][column[i]] > mat[min_row][column[min_row]])
{
if (column[i] == 0)
return -1;
column[i] -= 1; // Reduce last column index by 1

}
else
eq_count++;
}
// If equal count becomes M, return the value

if (eq_count == M)
return mat[min_row][column[min_row]];
}
return -1;
}

int main()
{
int mat[M][N] = { {1, 2, 3, 4, 5},
{2, 4, 5, 8, 10},
{3, 5, 7, 9, 11},
{1, 3, 5, 7, 9},
};
int result = findCommon(mat);
if (result == -1)
printf("No common element");
else
printf("Common element is %d", result);
return 0;
}

Output:

Common element is 5

Explanation for working of above code

Let us understand working of above code for following example.
Initially entries in last column array are N-1, i.e., {4, 4, 4, 4}

{1, 2, 3, 4, 5},
{2, 4, 5, 8, 10},
{3, 5, 7, 9, 11},
{1, 3, 5, 7, 9},
The value of min_row is 0, so values of last column index for rows with value greater than 5 is reduced by
one. So column[] becomes {4, 3, 3, 3}.
{1, 2, 3, 4, 5},
{2, 4, 5, 8, 10},
{3, 5, 7, 9, 11},
{1, 3, 5, 7, 9},
The value of min_row remains 0 and and value of last column index for rows with value greater than 5 is
reduced by one. So column[] becomes {4, 2, 2, 2}.
{1, 2, 3, 4, 5},
{2, 4, 5, 8, 10},
{3, 5, 7, 9, 11},
{1, 3, 5, 7, 9},
The value of min_row remains 0 and value of last column index for rows with value greater than 5 is
reduced by one. So colomun[] becomes {4, 2, 1, 2}.
{1, 2, 3, 4, 5},
{2, 4, 5, 8, 10},
{3, 5, 7, 9, 11},
{1, 3, 5, 7, 9},
Now all values in current last columns of all rows is same, so 5 is returned.
A Hashing Based Solution

We can also use hashing. This solution works even if the rows are not sorted. It can be used to print all
common elements.
Step1: Create a Hash Table with all key as distinct elements

of row1. Value for all these will be 0.
Step2:
For i = 1 to M-1
For j = 0 to N-1
If (mat[i][j] is already present in Hash Table)
If (And this is not a repetition in current row.
This can be checked by comparing HashTable value with
row number)
Update the value of this key in HashTable with current
row number
Step3: Iterate over HashTable and print all those keys for
which value = M

Time complexity of the above hashing based solution is O(MN) under the assumption that search and insert
in HashTable take O(1) time. Thanks to Nishant for suggesting this solution in a comment below.
Exercise: Given n sorted arrays of size m each, find all common elements in all arrays in O(mn) time.
This article is contributed by Anand Agrawal. Please write comments if you find anything incorrect, or
Check whether a binary tree is a complete tree or not | Set 2 (Recursive
Solution)
A complete binary tree is a binary tree whose all levels except the last level are completely filled and all the
leaves in the last level are all to the left side. More information about complete binary trees can be found
here.
For Example:-
Below tree is a Complete Binary Tree (All nodes till the second last nodes are filled and all leaves are to the
left side)
Below tree is not a Complete Binary Tree (The second level is not completely filled)
Below tree is not a Complete Binary Tree (All the leaves are not aligned to the left. The left child node of
node with data 3 is empty while the right child node is non-empty).
An iterative solution for this problem is discussed in below post.

Check whether a given Binary Tree is Complete or not | Set 1 (Using Level Order Traversal)
In this post a recursive solution is discussed.
In the array representation of a binary tree, if the parent node is assigned an index of ‘i’ and left child gets
assigned an index of ‘2*i + 1’ while the right child is assigned an index of ‘2*i + 2’. If we represent the binary
tree below as an array with the respective indices assigned to the different nodes of the tree below are shown
below:-
As can be seen from the above figure, the assigned indices in case of a complete binary tree will strictly less
be than the number of nodes in the complete binary tree. Below is the example of non-complete binary tree
with the assigned array indices. As can be seen the assigned indices are equal to the number of nodes in the
binary tree. Hence this tree is not a complete binary tree.
Hence we proceed in the following manner in order to check if the binary tree is complete binary tree.
1. Calculate the number of nodes (count) in the binary tree.

2. Start recursion of the binary tree from the root node of the binary tree with index (i) being set as 0 and
the number of nodes in the binary (count).
3. If the current node under examination is NULL, then the tree is a complete binary tree. Return true.
4. If index (i) of the current node is greater than or equal to the number of nodes in the binary tree
(count) i.e. (i>= count), then the tree is not a complete binary. Return false.
5. Recursively check the left and right sub-trees of the binary tree for same condition. For the left sub-
tree use the index as (2*i + 1) while for the right sub-tree use the index as (2*i + 2).
The time complexity of the above algorithm is O(n). Following is C code for checking if a binary tree is a
complete binary tree.
/* C program to checks if a binary tree complete ot not */

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>

struct Node
{
int key;
};

given key and NULL left and right pointer. */
struct Node *newNode(char k)
{
node->key = k;
return node;
}
/* This function counts the number of nodes in a binary tree */

unsigned int countNodes(struct Node* root)
{
if (root == NULL)
return (0);
return (1 + countNodes(root->left) + countNodes(root->right));
}
/* This function checks if the binary tree is complete or not */

bool isComplete (struct Node* root, unsigned int index,
unsigned int number_nodes)
{
// An empty tree is complete
if (root == NULL)
return (true);
// If index assigned to current node is more than

// number of nodes in tree, then tree is not complete
if (index >= number_nodes)
return (false);

return (isComplete(root->left, 2*index + 1, number_nodes) &&
isComplete(root->right, 2*index + 2, number_nodes));
}
// Driver program
int main()
{
// Le us create tree in the last diagram above
root = newNode(1);
unsigned int node_count = countNodes(root);

unsigned int index = 0;
if (isComplete(root, index, node_count))
printf("The Binary Tree is complete\n");
else
printf("The Binary Tree is not complete\n");
return (0);
}

Output:
The Binary Tree is not complete

This article is contributed by Gaurav Gupta. Please write comments if you find anything incorrect, or you
Count number of ways to reach a given score in a game
Consider a game where a player can score 3 or 5 or 10 points in a move. Given a total score n, find number of
ways to reach the given score.
Examples:
Input: n = 20
Output: 4
There are following 4 ways to reach 20
(10, 10)
(5, 5, 10)
(5, 5, 5, 5)
(3, 3, 3, 3, 3, 5)
Input: n = 13
Output: 2
There are following 2 ways to reach 13
(3, 5, 5)
(3, 10)

This problem is a variation of coin change problem and can be solved in O(n) time and O(n) auxiliary space.
The idea is to create a table of size n+1 to store counts of all scores from 0 to n. For every possible move (3, 5
and 10), increment values in table.

// A C program to count number of possible ways to a given score

// can be reached in a game where a move can earn 3 or 5 or 10
#include <stdio.h>
// Returns number of ways to reach score n

int count(int n)
{
// table[i] will store count of solutions for
// value i.
int table[n+1], i;
// Initialize all table values as 0

// Base case (If given value is 0)

table[0] = 1;
// One by one consider given 3 moves and update the table[]

// values after the index greater than or equal to the
// value of the picked move
for (i=3; i<=n; i++)
table[i] += table[i-3];
for (i=5; i<=n; i++)
for (i=10; i<=n; i++)
return table[n];
}
// Driver program
int main(void)
{
int n = 20;
printf("Count for %d is %d\n", n, count(n));
n = 13;
printf("Count for %d is %d", n, count(n));
return 0;
}

Output:

Count for 20 is 4
Count for 13 is 2

Exercise: How to count score when (10, 5, 5), (5, 5, 10) and (5, 10, 5) are considered as different sequences
of moves. Similarly, (5, 3, 3), (3, 5, 3) and (3, 3, 5) are considered different.
This article is contributed by Rajeev Arora. Please write comments if you find anything incorrect, or you
Visa Interview Experience | Set 6 (On-Campus)
Written Round:
75 minutes Test on Mettle.
Assessment Composition:
1. Coding Skills: 2 Questions (One ques is from DP(easy one like 0-1 knapsack) and other is Activity
Selection Problem).
2. Programming: 10 Questions
3. Machine Learning Hadoop MCQ: 6 Questions
4. Networking MCQ: 6 Questions
5. Operating System: 6 Questions
6. Infrastructure: 6 Questions
7. Application Security: 6 Questions
(In coding round everyone had different questions but they mainly cover DP and simple array question).
First Round (35 min):
– First he told me about himself,then asked me “Tell me something interesing about yourself?”
– Then he asked me you have experience in android or iOs app development. Because i don’t have any
knowledge of about it i simply said no.
– Then he asked me what is your area of interest. (my area of interest : computer networking , ds and algo).
– Then asked me completely describe Tcp/Ip model and OSI layer model thoroughly and difference between
them.
– OOPS concepts all.
– PKI (public key infrastructure) and DDOS attack.
– Loadbalancing of servers.
– Complete working of Router .
– Write a code to delete node from singly linked list.
Second Round (1 Hour 10 min):
– First he told me about himself, then asked me about my project.

– Project was the main deciding factor that you will move to next round or not.
– Computer Network Topology,SDLC models, statistics (mean,median,mode,standard deviation formulae).
– What is api give examples also.
– He has given me a real time scenario and asked to develop stratedy for making a software.
You have been given unstructured data which is coming form facebook and twitter. Analyse these data
according to “TCS stocks in market and people’s view on this”.
Make a strategy to tell that your software will decide that any point of time you should “BUY” or “SELL” the
stock.
(A lot of discussion had been done there interviewer just want to know how you are approaching to
solution.)
– Testing (white box / black box testing mainly).
he asked one question based on this that if there is memory leakage in your program which testing you will
choose and why. (ans : white box tesing).
– Finally he asked “You have any question from me”.
Third Round (15 min):
– This round was tech and hr mixed.

– He asked me for which profile you want to go (Networking or Programming) .
– TCP congestion how to remove it.
– A simple 9 ball puzzle , one ball is light in weight . In how many minimum balance you can find out this
light weighted ball.
– Finally he asked “You have any question from me”.
Guys mainly focus on networking, information security and project and be confident. Thanks to
geeksforgeeks for helping a lot in preparing for placement.
Geeks.
Find position of an element in a sorted array of infinite numbers
Suppose you have a sorted array of infinite numbers, how would you search an element in the array?
Source: Amazon Interview Experience.
Since array is sorted, the first thing clicks into mind is binary search, but the problem here is that we don’t
know size of array.
If the array is infinite, that means we don’t have proper bounds to apply binary search. So in order to find
position of key, first we find bounds and then apply binary search algorithm.
Let low be pointing to 1st element and high pointing to 2nd element of array, Now compare key with high
index element,
->if it is greater than high index element then copy high index in low index and double the high index.
->if it is smaller, then apply binary search on high and low indices found.
Below is the C++ implementation of above algorithm
// C++ program to demonstrate working of an algorithm that finds

// an element in an array of infinite size
#include<iostream>
// Simple binary search algorithm

{
if (r>=l)
{
int mid = l + (r - l)/2;
if (arr[mid] == x)
return mid;
if (arr[mid] > x)
return binarySearch(arr, l, mid-1, x);
}
return -1;
}
// function takes an infinite size array and a key to be

// searched and returns its position if found else -1.
// We don't know size of arr[] and we can assume size to be
// infinite in this function.
// NOTE THAT THIS FUNCTION ASSUMES arr[] TO BE OF INFINITE SIZE
// THEREFORE, THERE IS NO INDEX OUT OF BOUND CHECKING
int findPos(int arr[], int key)
{
int l = 0, h = 1;
int val = arr[0];
// Find h to do binary search

while (val < key)
{
l = h; // store previous high
h = 2*h; // double high index
val = arr[h]; // update new val
}
// at this point we have updated low and high indices,

// thus use binary search between them
return binarySearch(arr, l, h, key);
}
}
// Driver program
int main()
{
int arr[] = {3, 5, 7, 9, 10, 90, 100, 130, 140, 160, 170};
int ans = findPos(arr, 10);
if (ans==-1)
cout << "Element not found";
else
cout << "Element found at index " << ans;
return 0;
}
// C++ program to demonstrate working of an algorithm that finds
// an element in an array of infinite size
#include<iostream>
// Simple binary search algorithm

{
if (r>=l)
{
int mid = l + (r - l)/2;
if (arr[mid] == x)
return mid;
if (arr[mid] > x)
return binarySearch(arr, l, mid-1, x);
}
return -1;
}
// function takes an infinite size array and a key to be

// searched and returns its position if found else -1.
// We don't know size of arr[] and we can assume size to be
// infinite in this function.
// NOTE THAT THIS FUNCTION ASSUMES arr[] TO BE OF INFINITE SIZE
int findPos(int arr[], int key)
{
int l = 0, h = 1;
int val = arr[0];
// Find h to do binary search

while (val < key)
{
l = h; // store previous high
h = 2*h; // double high index
val = arr[h]; // update new val
}
// at this point we have updated low and high indices,

// thus use binary search between them
return binarySearch(arr, l, h, key);
}
// Driver program
int main()
{
int arr[] = {3, 5, 7, 9, 10, 90, 100, 130, 140, 160, 170};
int ans = findPos(arr, 10);
if (ans==-1)
cout << "Element not found";
else
return 0;
}
Output:

Element found at index 4

Let p be the position of element to be searched. Number of steps for finding high index ‘h’ is O(Log p). The
value of ‘h’ must be less than 2*p. The number of elements between h/2 and h must be O(p). Therefore, time
complexity of Binary Search step is also O(Log p) and overall time complexity is 2*O(Log p) which is O(Log
p).
Rearrange an array such that ‘arr[j]’ becomes ‘i’ if ‘arr[i]’ is ‘j’
Given an array of size n where all elements are in range from 0 to n-1, change contents of arr[] so that arr[i]
= j is changed to arr[j] = i.
Examples:
Example 1:
Input: arr[] = {1, 3, 0, 2};
Output: arr[] = {2, 0, 3, 1};
Explanation for the above output.
Since arr[0] is 1, arr[1] is changed to 0
Example 2:
Input: arr[] = {2, 0, 1, 4, 5, 3};
Output: arr[] = {1, 2, 0, 5, 3, 4};
Example 3:
Input: arr[] = {0, 1, 2, 3};
Output: arr[] = {0, 1, 2, 3};
Example 4:
Input: arr[] = {3, 2, 1, 0};
Output: arr[] = {3, 2, 1, 0};

A Simple Solution is to create a temporary array and one by one copy ‘i’ to ‘temp[arr[i]]’ where i varies
from 0 to n-1.
Below is C implementation of the above idea.

// A simple C program to rearrange contents of arr[]

// such that arr[j] becomes j if arr[i] is j
#include<stdio.h>
// A simple method to rearrange 'arr[0..n-1]' so that 'arr[j]'

// becomes 'i' if 'arr[i]' is 'j'
void rearrangeNaive(int arr[], int n)
{
// Create an auxiliary array of same size
int temp[n], i;
// Store result in temp[]

for (i=0; i<n; i++)
temp[arr[i]] = i;
// Copy temp back to arr[]

for (i=0; i<n; i++)
arr[i] = temp[i];
}
// A utility function to print contents of arr[0..n-1]

{
int i;
for (i=0; i<n; i++)
printf("\n");
}
// Drive program
int main()
{
int arr[] = {1, 3, 0, 2};
printf("Given array is \n");

printArray(arr, n);
rearrangeNaive(arr, n);
printf("Modified array is \n");

printArray(arr, n);
return 0;
}

Output:

Given array is
1 3 0 2
Modified array is
2 0 3 1

Time complexity of the above solution is O(n) and auxiliary space needed is O(n).
Can we solve this in O(n) time and O(1) auxiliary space?

The idea is based on the fact that the modified array is basically a permutation of input array. We can find
the target permutation by storing the next item before updating it.
Let us consider array ‘{1, 3, 0, 2}’ for example. We start with i = 0, arr[i] is 1. So we go to arr[1] and change it
to 0 (because i is 0). Before we make the change, we store old value of arr[1] as the old value is going to be
our new index i. In next iteration, we have i = 3, arr[3] is 2, so we change arr[2] to 3. Before making the
change we store next i as old value of arr[2].
The below code gives idea about this approach.
// This function works only when output is a permutation

// with one cycle.
void rearrangeUtil(int arr[], int n)
{
// 'val' is the value to be stored at 'arr[i]'
int val = 0; // The next value is determined
// using current index
int i = arr[0]; // The next index is determined
// using current value
// While all elements in cycle are not processed

while (i != 0)
{
// Store value at index as it is going to be
// used as next index
int new_i = arr[i];
// Update arr[]
arr[i] = val;
// Update value and index for next iteration

val = i;
i = new_i;
}
arr[0] = val; // Update the value at arr[0]

}

The above function doesn’t work for inputs like {2, 0, 1, 4, 5, 3}; as there are two cycles. One cycle
is (2, 0, 1) and other cycle is (4, 5, 3).
How to handle multiple cycles with the O(1) space constraint?
The idea is to process all cycles one by one. To check whether an element is processed or not, we change the
value of processed items arr[i] as -arr[i]. Since 0 can not be made negative, we first change all arr[i] to arr[i]
+ 1. In the end, we make all values positive and subtract 1 to get old values back.
// A space efficient C program to rearrange contents of

// arr[] such that arr[j] becomes j if arr[i] is j
#include<stdio.h>
// A utility function to rearrange elements in the cycle

// starting at arr[i]. This function assumes values in
// arr[] be from 1 to n. It changes arr[j-1] to i+1
// if arr[i-1] is j+1
void rearrangeUtil(int arr[], int n, int i)
{
{
// 'val' is the value to be stored at 'arr[i]'
int val = -(i+1); // The next value is determined
// using current index
i = arr[i] - 1; // The next index is determined
// using current value
// While all elements in cycle are not processed

while (arr[i] > 0)
{
// Store value at index as it is going to be
// used as next index
int new_i = arr[i] - 1;
// Update arr[]
arr[i] = val;
// Update value and index for next iteration

val = -(i + 1);
i = new_i;
}
}
// A space efficient method to rearrange 'arr[0..n-1]'

// so that 'arr[j]' becomes 'i' if 'arr[i]' is 'j'
{
// Increment all values by 1, so that all elements
// can be made negative to mark them as visited
int i;
for (i=0; i<n; i++)
arr[i]++;
// Process all cycles

for (i=0; i<n; i++)
{
// Process cycle starting at arr[i] if this cycle is
// not already processed
if (arr[i] > 0)
rearrangeUtil(arr, n, i);
}
// Change sign and values of arr[] to get the original

// values back, i.e., values in range from 0 to n-1
for (i=0; i<n; i++)
arr[i] = (-arr[i]) - 1;
}
// A utility function to print contents of arr[0..n-1]

{
int i;
for (i=0; i<n; i++)
printf("\n");
}
// Drive program
int main()
{
int arr[] = {2, 0, 1, 4, 5, 3};

printArray(arr, n);
printArray(arr, n);
rearrange(arr, n);
printf("Modified array is \n");

printArray(arr, n);
return 0;
}

Output:

Given array is
2 0 1 4 5 3
Modified array is
1 2 0 5 3 4

The time complexity of this method seems to be more than O(n) at first look. If we take a closer look, we can
notice that no element is processed more than constant number of times.
This article is contributed by Arun Gupta. Please write comments if you find anything incorrect, or you
Find maximum depth of nested parenthesis in a string
We are given a string having parenthesis like below
“( ((X)) (((Y))) )”
We need to find the maximum depth of balanced parenthesis, like 4 in above example. Since ‘Y’ is
surrounded by 4 balanced parenthesis.
If parenthesis are unbalanced then return -1.
More examples:
S = "( a(b) (c) (d(e(f)g)h) I (j(k)l)m)";

Output : 4
S = "( p((q)) ((s)t) )";

Output : 3
S = "";
Output : 0
S = "b) (c) ()";

Output : -1
S = "(b) ((c) ()"

Output : -1

Source : Walmart Labs Interview Question
Method 1 (Uses Stack)

A simple solution is to use a stack that keeps track of current open brackets.
1) Create a stack.
2) Traverse the string, do following for every character
a) If current character is ‘(’ push it to the stack .
b) If character is ‘)’, pop an element.
c) Maintain maximum count during the traversal.

Time Complexity : O(n)

Auxiliary Space : O(n)
Method 2 ( O(1) auxiliary space )

This can also be done without using stack.

1) Take two variables max and current_max, initialize both of them as 0.

2) Traverse the string, do following for every character
a) If current character is ‘(’, increment current_max and
update max value if required.
b) If character is ‘)’. Check if current_max is positive or
not (this condition ensure that parenthesis are balanced).
If positive that means we previously had a ‘(’ character
so decrement current_max without worry.
If not positive then the parenthesis are not balanced.
Thus return -1.
3) If current_max is not 0, then return -1 to ensure that the parenthesis
are balanced. Else return max

Below is the C++ implementation of above algorithm.

// A C++ program to find the maximum depth of nested

// parenthesis in a given expression
#include <iostream>
// function takes a string and returns the

// maximum depth nested parenthesis
int maxDepth(string S)
{
int current_max = 0; // current count
int max = 0; // overall maximum count
int n = S.length();
// Traverse the input string

for (int i = 0; i< n; i++)
{
if (S[i] == '(')
{
current_max++;
// update max if required

if (current_max> max)
max = current_max;
}
else if (S[i] == ')')
{
if (current_max>0)
current_max--;
else
return -1;
}
}
// finally check for unbalanced string

if (current_max != 0)
return -1;
return max;
}
// Driver program
int main()
{
string s = "( ((X)) (((Y))) )";
cout << maxDepth(s);
return 0;
}

Output:
Time Complexity : O(n)

Auxiliary Space : O(1)
Count number of islands where every island is row-wise and column-wise
separated
Given a rectangular matrix which has only two possible values ‘X’ and ‘O’. The values ‘X’ always appear in
form of rectangular islands and these islands are always row-wise and column-wise separated by at least one
line of ‘O’s. Note that islands can only be diagonally adjacent. Count the number of islands in the given
matrix.
Examples:
mat[M][N] = {{'O', 'O', 'O'},

{'X', 'X', 'O'},
{'X', 'X', 'O'},
{'O', 'O', 'X'},
{'O', 'O', 'X'},
{'X', 'X', 'O'}
};
Output: Number of islands is 3
mat[M][N] = {{'X', 'O', 'O', 'O', 'O', 'O'},

{'X', 'O', 'X', 'X', 'X', 'X'},
{'O', 'O', 'O', 'O', 'O', 'O'},
{'X', 'X', 'X', 'O', 'X', 'X'},
{'X', 'X', 'X', 'O', 'X', 'X'},
{'O', 'O', 'O', 'O', 'X', 'X'},
};
Output: Number of islands is 4

The idea is to count all top-leftmost corners of given matrix. We can check if a ‘X’ is top left or not by
checking following conditions.
1) A ‘X’ is top of rectangle if the cell just above it is a ‘O’
2) A ‘X’ is leftmost of rectangle if the cell just left of it is a ‘O’
Note that we must check for both conditions as there may be more than one top cells and more than one
leftmost cells in a rectangular island. Below is C++ implementation of above idea.

// A C++ program to count the number of rectangular

// islands where every island is separated by a line
#include<iostream>
// Size of given matrix is M X N

#define M 6
#define N 3
// This function takes a matrix of 'X' and 'O'

// and returns the number of rectangular islands
// of 'X' where no two islands are row-wise or
// column-wise adjacent, the islands may be diagonaly
// adjacent
int countIslands(int mat[][N])
{
int count = 0; // Initialize result
// Traverse the input matrix

{
{
// If current cell is 'X', then check
// whether this is top-leftmost of a
// rectangle. If yes, then increment count
if (mat[i][j] == 'X')
{
if ((i == 0 || mat[i-1][j] == 'O') &&
(j == 0 || mat[i][j-1] == 'O'))
count++;
}
}
}
return count;
}

int main()
{
int mat[M][N] = {{'O', 'O', 'O'},
{'X', 'X', 'O'},
{'X', 'X', 'O'},
{'O', 'O', 'X'},
{'O', 'O', 'X'},
{'X', 'X', 'O'}
};
cout << "Number of rectangular islands is "
<< countIslands(mat);
return 0;
}

Output:

Number of rectangular islands is 3

Time complexity of this solution is O(MN).
This article is contributed by Udit Gupta. If you like GeeksforGeeks and would like to contribute, you can
GeeksforGeeks main page and help other Geeks.
Vertex Cover Problem | Set 2 (Dynamic Programming Solution for Tree)
A vertex cover of an undirected graph is a subset of its vertices such that for every edge (u, v) of the graph,
either ‘u’ or ‘v’ is in vertex cover. Although the name is Vertex Cover, the set covers all edges of the given
graph.
The problem to find minimum size vertex cover of a graph is NP complete. But it can be solved in polynomial
time for trees. In this post a solution for Binary Tree is discussed. The same solution can be extended for n-
ary trees.
For example, consider the following binary tree. The smallest vertex cover is {20, 50, 30} and size of the
vertex cover is 3.
The idea is to consider following two possibilities for root and recursively for all nodes down the root.
1) Root is part of vertex cover: In this case root covers all children edges. We recursively calculate size
of vertex covers for left and right subtrees and add 1 to the result (for root).
2) Root is not part of vertex cover: In this case, both children of root must be included in vertex cover
to cover all root to children edges. We recursively calculate size of vertex covers of all grandchildren and
number of children to the result (for two children of root).
Below is C implementation of above idea.
// A naive recursive C implementation for vertex cover problem for a tree

#include <stdio.h>
#include <stdlib.h>

right child */
struct node
{
int data;
};
// The function returns size of the minimum vertex cover

int vCover(struct node *root)
{
// The size of minimum vertex cover is zero if tree is empty or there
// is only one node
if (root == NULL)
return 0;
return 0;
// Calculate size of vertex cover when root is part of it

int size_incl = 1 + vCover(root->left) + vCover(root->right);
// Calculate size of vertex cover when root is not part of it

int size_excl = 0;
if (root->left)
size_excl += 1 + vCover(root->left->left) + vCover(root->left->right);
if (root->right)
size_excl += 1 + vCover(root->right->left) + vCover(root->right->right);
// Return the minimum of two sizes

return min(size_incl, size_excl);
}

{
temp->data = data;
return temp;
}

int main()
{
printf ("Size of the smallest vertex cover is %d ", vCover(root));
return 0;
}

Output:

Size of the smallest vertex cover is 3

function computes the same subproblems again and again. For example, vCover of node with value 50 is
evaluated twice as 50 is grandchild of 10 and child of 20.
Since same suproblems are called again, this problem has Overlapping Subprolems property. So Vertex
Cover problem has both properties (see this and this) of a dynamic programming problem. Like other typical
Dynamic Programming(DP) problems, re-computations of same subproblems can be avoided by storing the
solutions to subproblems and solving problems in bottom up manner.
Following is C implementation of Dynamic Programming based solution. In the following solution, an

additional field ‘vc’ is added to tree nodes. The initial value of ‘vc’ is set as 0 for all nodes. The recursive
function vCover() calculates ‘vc’ for a node only if it is not already set.
/* Dynamic programming based program for Vertex Cover problem for

a Binary Tree */
#include <stdio.h>
#include <stdlib.h>

right child */
struct node
{
int data;
int vc;
};
// A memoization based function that returns size of the minimum vertex cover.
int vCover(struct node *root)
{
// is only one node
if (root == NULL)
return 0;
return 0;
// If vertex cover for this node is already evaluated, then return it

// to save recomputation of same subproblem again.
if (root->vc != 0)
return root->vc;
// Calculate size of vertex cover when root is part of it

int size_incl = 1 + vCover(root->left) + vCover(root->right);
// Calculate size of vertex cover when root is not part of it

int size_excl = 0;
if (root->left)
size_excl += 1 + vCover(root->left->left) + vCover(root->left->right);
if (root->right)
size_excl += 1 + vCover(root->right->left) + vCover(root->right->right);
// Minimum of two values is vertex cover, store it before returning

root->vc = min(size_incl, size_excl);
return root->vc;
}

{
temp->data = data;
temp->vc = 0; // Set the vertex cover as 0
temp->vc = 0; // Set the vertex cover as 0
return temp;
}

int main()
{
printf ("Size of the smallest vertex cover is %d ", vCover(root));
return 0;
}

Output:

Size of the smallest vertex cover is 3

References:
Exercise:
Extend the above solution for n-ary trees.
This article is contributed by Udit Gupta. Please write comments if you find anything incorrect, or you
Write an iterative O(Log y) function for pow(x, y)
y
Given an integer x and a positive number y, write a function that computes x under following conditions.
a) Time complexity of the function should be O(Log y)
b) Extra Space is O(1)
Examples:
Input: x = 3, y = 5
Output: 243
Input: x = 2, y = 5
Output: 32

We have discussed recursive O(Log y) solution for power. The recursive solutions are generally not preferred
as they require space on call stack and they involve function call overhead.
Following is C function to compute xy.

#include <stdio.h>
/* Iterative Function to calculate x raised to the power y in O(logy) */

int power(int x, unsigned int y)
{
int res = 1;
while (y > 0)
{
// If y is even, simply do x square
if (y%2 == 0)
{
y = y/2;
x = x*x;
}

// Else multiply x with result. Note that this else
// is always executed in the end when y becomes 1
else
{
y--;
res = res*x;
}
}
return res;
}

int main()
{
int x = 3;
unsigned int y = 5;
printf("Power is %d", power(x, y));
return 0;
}

Output:

Power is 243

This article is contributed by Udit Gupta. Please write comments if you find anything incorrect, or you
Find the minimum cost to reach destination using a train
There are N stations on route of a train. The train goes from station 0 to N-1. The ticket cost for all pair of
stations (i, j) is given where j is greater than i. Find the minimum cost to reach the destination.
Consider the following example:
Input:
cost[N][N] = { {0, 15, 80, 90},
{INF, 0, 40, 50},
{INF, INF, 0, 70},
{INF, INF, INF, 0}
};
There are 4 stations and cost[i][j] indicates cost to reach j
from i. The entries where j
The minimum cost to reach N-1 from 0 can be recursively written as following:

minCost(0, N-1) = MIN { cost[0][n-1],
cost[0][1] + minCost(1, N-1),
minCost(0, 2) + minCost(2, N-1),
........,
minCost(0, N-2) + cost[N-2][n-1] }
The following is C++ implementation of above recursive formula.

// A naive recursive solution to find min cost path from station 0
// to station N-1
#include<iostream>
#include<climits>
// infinite value
#define INF INT_MAX
// Number of stations
#define N 4
// A recursive function to find the shortest path from

// source 's' to destination 'd'.
int minCostRec(int cost[][N], int s, int d)
{
// If source is same as destination
// or destination is next to source
if (s == d || s+1 == d)
return cost[s][d];
// Initialize min cost as direct ticket from

// source 's' to destination 'd'.
int min = cost[s][d];
// Try every intermediate vertex to find minimum

for (int i = s+1; i<d; i++)
{
{
int c = minCostRec(cost, s, i) +
minCostRec(cost, i, d);
if (c < min)
min = c;
}
return min;
}
// This function returns the smallest possible cost to

// reach station N-1 from station 0. This function mainly
// uses minCostRec().
int minCost(int cost[][N])
{
return minCostRec(cost, 0, N-1);
}

int main()
{
int cost[N][N] = { {0, 15, 80, 90},
{INF, 0, 40, 50},
{INF, INF, 0, 70},
{INF, INF, INF, 0}
};
cout << "The Minimum cost to reach station "
<< N << " is " << minCost(cost);
return 0;
}
Output:
The Minimum cost to reach station 4 is 65
Time complexity of the above implementation is exponential as it tries every possible pa

th from 0 to N-1. The above solution solves same subrpoblems multiple times (it can be
seen by drawing recursion tree for minCostPathRec(0, 5).
Since this problem has both properties of dynamic programming problems ((see this and th
is). Like other typical Dynamic Programming(DP) problems, re-computations of same subpro
blems can be avoided by storing the solutions to subproblems and solving problems in bot
tom up manner.
One dynamic programming solution is to create a 2D table and fill the table using above
given recursive formula. The extra space required in this solution would be O(N 2) and ti
me complexity would be O(N 3)
We can solve this problem using O(N) extra space and O(N2) time. The idea is based on th
e fact that given input matrix is a Directed Acyclic Graph (DAG). The shortest path in
DAG can be calculated using the approach discussed in below post.
Shortest Path in Directed Acyclic Graph
We need to do less work here compared to above mentioned post as we know topological sor
ting of the graph. The topological sorting of vertices here is 0, 1, ..., N-1. Followi
ng is the idea once topological sorting is known.
The idea in below code is to first calculate min cost for station 1, then for station 2,
and so on. These costs are stored in an array dist[0...N-1].
1) The min cost for station 0 is 0, i.e., dist[0] = 0
2) The min cost for station 1 is cost[0][1], i.e., dist[1] = cost[0][1]
3) The min cost for station 2 is minimum of following two.
a) dist[0] + cost[0][2]
b) dist[1] + cost[1][2]
3) The min cost for station 3 is minimum of following three.
a) dist[0] + cost[0][3]
b) dist[1] + cost[1][3]
c) dist[2] + cost[2][3]
Similarly, dist[4], dist[5], ... dist[N-1] are calculated.

// A Dynamic Programming based solution to find min cost
// to reach station N-1 from station 0.
#include<iostream>
#include<climits>
#define INF INT_MAX

#define N 4
// This function returns the smallest possible cost to

// reach station N-1 from station 0.
int minCost(int cost[][N])
{
// dist[i] stores minimum cost to reach station i
// from station 0.
int dist[N];
dist[i] = INF;
dist[0] = 0;
// Go through every station and check if using it

// as an intermediate station gives better path
for (int j=i+1; j<N; j++)
if (dist[j] > dist[i] + cost[i][j])
dist[j] = dist[i] + cost[i][j];
return dist[N-1];
}

int main()
{
int cost[N][N] = { {0, 15, 80, 90},
{INF, 0, 40, 50},
{INF, 0, 40, 50},
{INF, INF, 0, 70},
{INF, INF, INF, 0}
};
cout << "The Minimum cost to reach station "
<< N << " is " << minCost(cost);
return 0;
}

Output:
The Minimum cost to reach station 4 is 65
This article is contributed by Udit Gupta. Please write comments if you find anything in
correct, or you want to share more information about the topic discussed above.

Function to find Number of customers who could not get a computer
Write a function “runCustomerSimulation” that takes following two inputs
a) An integer ‘n': total number of computers in a cafe and a string:
b) A sequence of uppercase letters ‘seq': Letters in the sequence occur in pairs. The first occurrence indicates
the arrival of a customer; the second indicates the departure of that same customer.
A customer will be serviced if there is an unoccupied computer. No letter will occur more than two times.
Customers who leave without using a computer always depart before customers who are currently using the
computers. There are at most 20 computers per cafe.
For each set of input the function should output a number telling how many customers, if any walked away
without using a computer. Return 0 if all the customers were able to use a computer.
runCustomerSimulation (2, “ABBAJJKZKZ”) should return 0
runCustomerSimulation (3, “GACCBDDBAGEE”) should return 1 as ‘D’ was not able to get any computer
runCustomerSimulation (3, “GACCBGDDBAEE”) should return 0
runCustomerSimulation (1, “ABCBCA”) should return 2 as ‘B’ and ‘C’ were not able to get any computer.
runCustomerSimulation(1, “ABCBCADEED”) should return 3 as ‘B’, ‘C’ and ‘E’ were not able to get any
computer.
Source: Fiberlink (maas360) Interview
Below are simple steps to find number of customers who could not get any computer.
1) Initialize result as 0.
2) Traverse the given sequence. While traversing, keep track of occupied computers (this can be done by
keeping track of characters which have appeared only once and a computer was available when they
appeared). At any point, if count of occupied computers is equal to ‘n’, and there is a new customer,
increment result by 1.
The important thing is to keep track of existing customers in cafe in a way that can indicate whether the
customer has got a computer or not. Note that in sequence “ABCBCADEED”, customer ‘B’ did not get a seat,
but still in cafe as a new customer ‘C’ is next in sequence.
// C++ program to find number of customers who couldn't get a resource.

#include<iostream>
#include<cstring>
#define MAX_CHAR 26
// n is number of computers in cafe.

// 'seq' is given sequence of customer entry, exit events
int runCustomerSimulation(int n, const char *seq)
{
// seen[i] = 0, indicates that customer 'i' is not in cafe
// seen[1] = 1, indicates that customer 'i' is in cafe but
// computer is not assigned yet.
// seen[2] = 2, indicates that customer 'i' is in cafe and
// has occupied a computer.
// has occupied a computer.
char seen[MAX_CHAR] = {0};
// Initialize result which is number of customers who could

// not get any computer.
int res = 0;
int occupied = 0; // To keep track of occupied computers
// Travers the input sequence

for (int i=0; seq[i]; i++)
{
// Find index of current character in seen[0...25]
int ind = seq[i] - 'A';
// If First occurrence of 'seq[i]'

if (seen[ind] == 0)
{
// set the current character as seen
seen[ind] = 1;
// If number of occupied computers is less than

// n, then assign a computer to new customer
if (occupied < n)
{
occupied++;
// Set the current character as occupying a computer

seen[ind] = 2;
}
// Else this customer cannot get a computer,

// increment result
else
res++;
}
// If this is second occurrence of 'seq[i]'

else
{
// Decrement occupied only if this customer
// was using a computer
if (seen[ind] == 2)
occupied--;
seen[ind] = 0;
}
}
return res;
}
// Driver program
int main()
{
cout << runCustomerSimulation(2, "ABBAJJKZKZ") << endl;
cout << runCustomerSimulation(3, "GACCBDDBAGEE") << endl;
cout << runCustomerSimulation(3, "GACCBGDDBAEE") << endl;
cout << runCustomerSimulation(1, "ABCBCA") << endl;
cout << runCustomerSimulation(1, "ABCBCADEED") << endl;
return 0;
}

Output:

0
1
0
2
3

Time complexity of above solution is O(n) and extra space required is O(CHAR_MAX) where CHAR_MAX
is total number of possible characters in given sequence.
This article is contributed by Lokesh. Please write comments if you find anything incorrect, or you want to
Divide and Conquer | Set 6 (Tiling Problem)
k
Given a n by n board where n is of form 2 where k >= 1 (Basically n is a power of 2 with minimum value as
2). The board has one missing cell (of size 1 x 1). Fill the board using L shaped tiles. A L shaped tile is a 2 x 2
square with one cell of size 1×1 missing.
Figure 1: An example input
This problem can be solved using Divide and Conquer. Below is the recursive algorithm.
// n is size of given square, p is location of missing cell

Tile(int n, Point p)
1) Base case: n = 2, A 2 x 2 square with one cell missing is nothing

but a tile and can be filled with a single tile.
2) Place a L shaped tile at the center such that it does not cover
the n/2 * n/2 subsquare that has a missing square. Now all four
subsquares of size n/2 x n/2 have a missing cell (a cell that doesn't
need to be filled). See figure 2 below.
3) Solve the problem recursively for following four. Let p1, p2, p3 and
p4 be positions of the 4 missing cells in 4 squares.
a) Tile(n/2, p1)
b) Tile(n/2, p2)
c) Tile(n/2, p3)
d) Tile(n/2, p3)

The below diagrams show working of above algorithm

Figure 2: After placing first tile
Figure 3: Recurring for first subsquare.

Figure 4: Shows first step in all four subsquares.
Time Complexity:
Recurrence relation for above recursive algorithm can be written as below. C is a constant.
T(n) = 4T(n/2) + C
The above recursion can be solved using Master Method and time complexity is O(n2)
How does this work?

The working of Divide and Conquer algorithm can be proved using Mathematical Induction. Let the input
square be of size 2 k x 2k where k >=1.
Base Case: We know that the problem can be solved for k = 1. We have a 2 x 2 square with one cell missing.
Induction Hypothesis: Let the problem can be solved for k-1.
Now we need to prove to prove that the problem can be solved for k if it can be solved for k-1. For k, we put a
L shaped tile in middle and we have four subsqures with dimension 2k-1 x 2k-1 as shown in figure 2 above. So
if we can solve 4 subsquares, we can solve the complete square.
References:
http://www.comp.nus.edu.sg/~sanjay/cs3230/dandc.pdf
How to print maximum number of A’s using given four keys
This is a famous interview question asked in Google, Paytm and many other company interviews.
Below is the problem statement.
Imagine you have a special keyboard with the following keys:

Key 1: Prints 'A' on screen
Key 2: (Ctrl-A): Select screen
Key 3: (Ctrl-C): Copy selection to buffer
Key 4: (Ctrl-V): Print buffer on screen appending it
after what has already been printed.
If you can only press the keyboard for N times (with the above four
keys), write a program to produce maximum numbers of A's. That is to
say, the input parameter is N (No. of keys that you can press), the
output is M (No. of As that you can produce).

Examples:
Input: N = 3
Output: 3
We can at most get 3 A's on screen by pressing
following key sequence.
A, A, A
Input: N = 7
Output: 9
A, A, A, Ctrl A, Ctrl C, Ctrl V, Ctrl V
Input: N = 11
Output: 27
A, A, A, Ctrl A, Ctrl C, Ctrl V, Ctrl V, Ctrl A,
Ctrl C, Ctrl V, Ctrl V

Below are few important points to note.

a) For N 6).
The task is to find out the break=point after which we get the above suffix of keystrokes. Definition of a
breakpoint is that instance after which we need to only press Ctrl-A, Ctrl-C once and the only Ctrl-V’s
afterwards to generate the optimal length. If we loop from N-3 to 1 and choose each of these values for the
break-point, and compute that optimal string they would produce. Once the loop ends, we will have the
maximum of the optimal lengths for various breakpoints, thereby giving us the optimal length for N
keystrokes.
Below is C implementation based on above idea.

/* A recursive C program to print maximum number of A's using

following four keys */
#include<stdio.h>
// A recursive function that returns the optimal length string

// for N keystrokes
int findoptimal(int N)
{
// The optimal string length is N when N is smaller than 7
if (N <= 6)
return N;
int max = 0;
// TRY ALL POSSIBLE BREAK-POINTS

// For any keystroke N, we need to loop from N-3 keystrokes
// back to 1 keystroke to find a breakpoint 'b' after which we
// will have Ctrl-A, Ctrl-C and then only Ctrl-V all the way.
int b;
for (b=N-3; b>=1; b--)
{
// If the breakpoint is s at b'th keystroke then
// the optimal string would have length
// (n-b-1)*screen[b-1];
int curr = (N-b-1)*findoptimal(b);
if (curr > max)
max = curr;
}
return max;
}
// Driver program
int main()
{
int N;
// for the rest of the array we will rely on the previous

// entries to compute new ones
for (N=1; N<=20; N++)
printf("Maximum Number of A's with %d keystrokes is %d\n",
N, findoptimal(N));
}

Output:

Maximum Number of A's with 1 keystrokes is 1

The above function computes the same subproblems again and again. Recomputations of same subproblems
can be avoided by storing the solutions to subproblems and solving problems in bottom up manner.
Below is Dynamic Programming based C implementation where an auxiliary array screen[N] is used to store
result of subproblems.

/* A Dynamic Programming based C program to find maximum number of A's

that can be printed using four keys */
#include<stdio.h>
// this function returns the optimal length string for N keystrokes

int findoptimal(int N)
{
// The optimal string length is N when N is smaller than 7
if (N <= 6)
return N;
// An array to store result of subproblems

int screen[N];
int b; // To pick a breakpoint
// Initializing the optimal lengths array for uptil 6 input

// strokes.
int n;
for (n=1; n<=6; n++)
screen[n-1] = n;
// Solve all subproblems in bottom manner

for (n=7; n<=N; n++)
{
// Initialize length of optimal string for n keystrokes
screen[n-1] = 0;
// For any keystroke n, we need to loop from n-3 keystrokes

// back to 1 keystroke to find a breakpoint 'b' after which we
// will have ctrl-a, ctrl-c and then only ctrl-v all the way.
for (b=n-3; b>=1; b--)
{
// if the breakpoint is at b'th keystroke then
// the optimal string would have length
// (n-b-1)*screen[b-1];
int curr = (n-b-1)*screen[b-1];
if (curr > screen[n-1])
screen[n-1] = curr;
}
}
return screen[N-1];
}
// Driver program
int main()
{
int N;
// for the rest of the array we will rely on the previous

// entries to compute new ones
for (N=1; N<=20; N++)
printf("Maximum Number of A's with %d keystrokes is %d\n",
N, findoptimal(N));
}

Output:



Thanks to Gaurav Saxena for providing the above approach to solve this problem.
discussed above
Divide and Conquer | Set 7 (The Skyline Problem)
Given n rectangular buildings in a 2-dimensional city, computes the skyline of these buildings, eliminating
hidden lines. The main task is to view buildings from a side and remove all sections that are not visible.
All buildings share common bottom and every building is represented by triplet (left, ht, right)
‘left': is x coordinated of left side (or wall).

‘right': is x coordinate of right side
‘ht': is height of building.
For example, the building on right side (the figure is taken from here) is represented as (1, 11, 5)
A skyline is a collection of rectangular strips. A rectangular strip is represented as a pair (left, ht) where left
is x coordinate of left side of strip and ht is height of strip.
Examples:
Input: Array of buildings

{ (1,11,5), (2,6,7), (3,13,9), (12,7,16), (14,3,25),
(19,18,22), (23,13,29), (24,4,28) }
Output: Skyline (an array of rectangular strips)
A strip has x coordinate of left side and height
(1, 11), (3, 13), (9, 0), (12, 7), (16, 3), (19, 18),
(22, 3), (25, 0)
The below figure (taken from here) demonstrates input and output.
The left side shows buildings and right side shows skyline.
Consider following as another example when there is only one

building
Input: {(1, 11, 5)}
Output: (1, 11), (5, 0)

A Simple Solution is to initialize skyline or result as empty, then one by one add buildings to skyline. A
building is added by first finding the overlapping strip(s). If there are no overlapping strips, the new building
adds new strip(s). If overlapping strip is found, then height of the existing strip may increase. Time
2
complexity of this solution is O(n2)
We can find Skyline in Θ(nLogn) time using Divide and Conquer. The idea is similar to Merge Sort, divide
the given set of buildings in two subsets. Recursively construct skyline for two halves and finally merge the
two skylines.
How to Merge two Skylines?

The idea is similar to merge of merge sort, start from first strips of two skylines, compare x coordinates. Pick
the strip with smaller x coordinate and add it to result. The height of added strip is considered as maximum
of current heights from skyline1 and skyline2.
Example to show working of merge:

Height of new Strip is always obtained by takin maximum of following

(a) Current height from skyline1, say 'h1'.
(b) Current height from skyline2, say 'h2'
h1 and h2 are initialized as 0. h1 is updated when a strip from
SkyLine1 is added to result and h2 is updated when a strip from
SkyLine2 is added.

Skyline1 = {(1, 11), (3, 13), (9, 0), (12, 7), (16, 0)}
Skyline2 = {(14, 3), (19, 18), (22, 3), (23, 13), (29, 0)}
Result = {}
h1 = 0, h2 = 0

Compare (1, 11) and (14, 3). Since first strip has smaller left x,
add it to result and increment index for Skyline1.
h1 = 11, New Height = max(11, 0)
Result = {(1, 11)}
add it to result and increment index for Skyline1
h1 = 13, New Height = max(13, 0)
Result = {(1, 11), (3, 13)}

Similarly (9, 0) and (12, 7) are added.
h1 = 7, New Height = max(7, 0) = 7
Result = {(1, 11), (3, 13), (9, 0), (12, 7)}
Compare (16, 0) and (14, 3). Since second strip has smaller left x,
it is added to result.
h2 = 3, New Height = max(7, 3) = 7
Result = {(1, 11), (3, 13), (9, 0), (12, 7), (14, 7)}
it is added to result.
h1 = 0, New Height = max(0, 3) = 3
Result = {(1, 11), (3, 13), (9, 0), (12, 7), (14, 3), (16, 3)}
Since Skyline1 has no more items, all remaining items of Skyline2

are added
Result = {(1, 11), (3, 13), (9, 0), (12, 7), (14, 3), (16, 3),
(19, 18), (22, 3), (23, 13), (29, 0)}
One observation about above output is, the strip (16, 3) is redundant
(There is already an strip of same height). We remove all redundant
strips.
Result = {(1, 11), (3, 13), (9, 0), (12, 7), (14, 3), (19, 18),
(22, 3), (23, 13), (29, 0)}
In below code, redundancy is handled by not appending a strip if the

previous strip in result has same height.

// A divide and conquer based C++ program to find skyline of given

// buildings
#include<iostream>
// A structure for building
struct Building
{
int left; // x coordinate of left side
int ht; // height
int right; // x coordinate of right side
};
// A strip in skyline
class Strip
{
int left; // x coordinate of left side
int ht; // height
public:
Strip(int l=0, int h=0)
{
left = l;
ht = h;
}
friend class SkyLine;
};
// Skyline: To represent Output (An array of strips)

class SkyLine
{
Strip *arr; // Array of strips
int capacity; // Capacity of strip array
int n; // Actual number of strips in array
public:
~SkyLine() { delete[] arr; }
int count() { return n; }
// A function to merge another skyline

// to this skyline
SkyLine* Merge(SkyLine *other);
// Constructor
SkyLine(int cap)
{
capacity = cap;
arr = new Strip[cap];
n = 0;
}
// Function to add a strip 'st' to array

void append(Strip *st)
{
// Check for redundant strip, a strip is
// redundant if it has same height or left as previous
if (n>0 && arr[n-1].ht == st->ht)
return;
if (n>0 && arr[n-1].left == st->left)
{
arr[n-1].ht = max(arr[n-1].ht, st->ht);
return;
}
arr[n] = *st;
n++;
}
// A utility function to print all strips of

// skyline
void print()
void print()
{
{
cout << " (" << arr[i].left << ", "
<< arr[i].ht << "), ";
}
}
};
// This function returns skyline for a given array of buildings

// arr[l..h]. This function is similar to mergeSort().
SkyLine *findSkyline(Building arr[], int l, int h)
{
if (l == h)
{
SkyLine *res = new SkyLine(2);
res->append(new Strip(arr[l].left, arr[l].ht));
res->append(new Strip(arr[l].right, 0));
return res;
}
int mid = (l + h)/2;
// Recur for left and right halves and merge the two results
SkyLine *sl = findSkyline(arr, l, mid);
SkyLine *sr = findSkyline(arr, mid+1, h);
SkyLine *res = sl->Merge(sr);
// To avoid memory leak

delete sl;
delete sr;
// Return merged skyline

return res;
}
// Similar to merge() in MergeSort

// This function merges another skyline 'other' to the skyline
// for which it is called. The function returns pointer to
// the resultant skyline
SkyLine *SkyLine::Merge(SkyLine *other)
{
// Create a resultant skyline with capacity as sum of two
// skylines
SkyLine *res = new SkyLine(this->n + other->n);
// To store current heights of two skylines

int h1 = 0, h2 = 0;
// Indexes of strips in two skylines

int i = 0, j = 0;
while (i < this->n && j < other->n)
{
// Compare x coordinates of left sides of two
// skylines and put the smaller one in result
if (this->arr[i].left < other->arr[j].left)
{
int x1 = this->arr[i].left;
h1 = this->arr[i].ht;
// Choose height as max of two heights

int maxh = max(h1, h2);
res->append(new Strip(x1, maxh));

i++;
}
else
{
int x2 = other->arr[j].left;
h2 = other->arr[j].ht;
int maxh = max(h1, h2);
j++;
}
}
// If there are strips left in this skyline or other

// skyline
while (i < this->n)
{
res->append(&arr[i]);
i++;
}
while (j < other->n)
{
res->append(&other->arr[j]);
j++;
}
return res;
}
// drive program
int main()
{
Building arr[] = {{1, 11, 5}, {2, 6, 7}, {3, 13, 9},
{12, 7, 16}, {14, 3, 25}, {19, 18, 22},
{23, 13, 29}, {24, 4, 28}};
// Find skyline for given buildings and print the skyline

SkyLine *ptr = findSkyline(arr, 0, n-1);
cout << " Skyline for given buildings is \n";
ptr->print();
return 0;
}

Skyline for given buildings is

(1, 11), (3, 13), (9, 0), (12, 7), (16, 3), (19, 18),
(22, 3), (23, 13), (29, 0),

Time complexity of above recursive implementation is same as Merge Sort.
T(n) = T(n/2) + Θ(n)
Solution of above recurrence is Θ(nLogn)
References:
http://faculty.kfupm.edu.sa/ics/darwish/stuff/ics353handouts/Ch4Ch5.pdf
www.cs.ucf.edu/~sarahb/COP3503/Lectures/DivideAndConquer.ppt
This article is contributed Abhay Rathi. Please write comments if you find anything incorrect, or you want
Calculate square of a number without using *, / and pow()
Given an integer n, calculate square of a number without using *, / and pow().
Examples:
Input: n = 5
Output: 25
Input: 7
Output: 49
Input: n = 12
Output: 144

A Simple Solution is to repeatedly add n to result. Below is C++ implementation of this idea.
// Simple solution to calculate square without

// using * and pow()
#include<iostream>
int square(int n)
{
// handle negative input
if (n<0) n = -n;
int res = n;
// Add n to res n-1 times

res += n;
return res;
}
// drive program
int main()
{
for (int n = 1; n<=5; n++)
cout << "n = " << n << ", n^2 = "
<< square(n) << endl;
return 0;
}

Output

n = 1, n^2 = 1
n = 2, n^2 = 4
n = 3, n^2 = 9
n = 4, n^2 = 16
n = 5, n^2 = 25

Time complexity of above solution is O(n). We can do it in O(Logn) time using bitwise operators . The
idea is based on the following fact.
square(n) = 0 if n == 0
if n is even
square(n) = 4*square(n/2)
if n is odd
square(n) = 4*square(floor(n/2)) + 4*floor(n/2) + 1
Examples
square(6) = 4*square(3)
square(3) = 4*(square(1)) + 4*1 + 1 = 9
square(7) = 4*square(3) + 4*3 + 1 = 4*9 + 4*3 + 1 = 49

How does this work?
If n is even, it can be written as

n = 2*x
n 2 = (2*x) 2 = 4*x2
If n is odd, it can be written as
n = 2*x + 1
n 2 = (2*x + 1)2 = 4*x2 + 4*x + 1

floor(n/2) can be calculated using bitwise right shift operator. 2*x and 4*x can be calculated
Below is C++ implementation based on above idea.

// Square of a number using bitwise operators

#include<iostream>
int square(int n)
{
// Base case
if (n==0) return 0;
// Handle negative number

if (n < 0) n = -n;
// Get floor(n/2) using right shift

int x = n>>1;
// If n is odd
if (n&1)
return ((square(x)<<2) + (x<<2) + 1);
else // If n is even
return (square(x)<<2);
}
// drive program
int main()
{
for (int n = 1; n<=5; n++)
cout << "n = " << n << ", n^2 = " << square(n) << endl;
return 0;
}

Output

n = 1, n^2 = 1
n = 2, n^2 = 4
n = 3, n^2 = 9
n = 4, n^2 = 16
n = 5, n^2 = 25

Time complexity of the above solution is O(Logn).
This article is contributed by Ujjwal Jain. Please write comments if you find anything incorrect, or you
Find number of days between two given dates
Given two dates, find total number of days between them. The count of days must be calculated in O(1) time
and O(1) auxiliary space.
Examples:
Input: dt1 = {10, 2, 2014}

dt2 = {10, 3, 2015}
Output: 393
dt1 represents "10-Feb-2014" and dt2 represents "10-Mar-2015"
The difference is 365 + 28
Input: dt1 = {10, 2, 2000}

dt2 = {10, 3, 2000}
Output: 29
Note that 2000 is a leap year
Input: dt1 = {10, 2, 2000}

dt2 = {10, 2, 2000}
Output: 0
Both dates are same
Input: dt1 = {1, 2, 2000};

dt2 = {1, 2, 2004};
Output: 1461
Number of days is 365*4 + 1

One Naive Solution is to start from dt1 and keep counting days till dt2 is reached. This solution requires
more than O(1) time.
A Better and Simple solution is to count total number of days before dt1 from i.e., total days from
00/00/0000 to dt1, then count total number of days before dt2. Finally return the difference between two
counts.
Let the given two dates be "1-Feb-2000" and "1-Feb-2004"

dt1 = {1, 2, 2000};
dt2 = {1, 2, 2004};
Count number of days before dt1. Let this count be n1.

Every leap year adds one extra day (29 Feb) to total days.
n1 = 2000*365 + 31 + 1 + Number of leap years
Count of leap years for a date 'd/m/y' can be calculated

using following formula:
Number leap years
= y/4 - y/100 + y/400 if m > 2
= (y-1)/4 - (y-1)/100 + (y-1)/400 if m

// C++ program two find number of days between two given dates
#include<iostream>
// A date has day 'd', month 'm' and year 'y'

struct Date
{
int d, m, y;
};
// To store number of days in all months from January to Dec.

const int monthDays[12] = {31, 28, 31, 30, 31, 30,
31, 31, 30, 31, 30, 31};
// This function counts number of leap years before the

// given date
int countLeapYears(Date d)
{
int years = d.y;
// Check if the current year needs to be considered

// for the count of leap years or not
if (d.m <= 2)
years--;
// An year is a leap year if it is a multiple of 4,

// multiple of 400 and not a multiple of 100.
return years / 4 - years / 100 + years / 400;
}
// This function returns number of days between two given

// dates
int getDifference(Date dt1, Date dt2)
{
// COUNT TOTAL NUMBER OF DAYS BEFORE FIRST DATE 'dt1'
// initialize count using years and day

long int n1 = dt1.y*365 + dt1.d;
// Add days for months in given date

for (int i=0; i<dt1.m - 1; i++)
n1 += monthDays[i];
// Since every leap year is of 366 days,

// Add a day for every leap year
n1 += countLeapYears(dt1);
// SIMILARLY, COUNT TOTAL NUMBER OF DAYS BEFORE 'dt2'
long int n2 = dt2.y*365 + dt2.d;

for (int i=0; i<dt2.m - 1; i++)
n2 += monthDays[i];
n2 += countLeapYears(dt2);
// return difference between two counts

return (n2 - n1);
}
// Driver program
int main()
{
Date dt1 = {1, 2, 2000};
Date dt2 = {1, 2, 2004};
cout << "Difference between two dates is " << getDifference(dt1, dt2);

return 0;
}

Output:
Difference between two dates is 1461
This article is contributed by Abhay Rathi. Please write comments if you find anything i
ncorrect, or you want to share more information about the topic discussed above

Find the longest substring with k unique characters in a given string
Given a string you need to print longest possible substring that has exactly M unique characters. If there are
more than one substring of longest possible length, then print any one of them.
Examples:
"aabbcc", k = 1
Max substring can be any one from {"aa" , "bb" , "cc"}.
"aabbcc", k = 2
Max substring can be any one from {"aabb" , "bbcc"}.
"aabbcc", k = 3
There are substrings with exactly 3 unique characters
{"aabbcc" , "abbcc" , "aabbc" , "abbc" }
Max is "aabbcc" with length 6.
"aaabbb", k = 3
There are only two unique characters, thus show error message.

Method 1 (Brute Force)

If the length of string is n, then there can be n*(n+1)/2 possible substrings. A simple way is to generate all
the substring and check each one whether it has exactly k unique characters or not. If we apply this brute
force, it would take O(n2) to generate all substrings and O(n) to do a check on each one. Thus overall it would
go O(n3).
We can further improve this solution by creating a hash table and while generating the substrings, check the
number of unique characters using that hash table. Thus it would improve up to O(n2).
Method 2 (Linear Time)

The problem can be solved in O(n). Idea is to maintain a window and add elements to the window till it
contains less or equal k, update our result if required while doing so. If unique elements exceeds than
required in window, start removing the elements from left side.
C++ implementation of above. The implementation assumes that the input string alphabet contains only 26
characters (from ‘a’ to ‘z’). The code can be easily extended to 256 characters.
// C++ program to find the longest substring with k unique

// characters in a given string
#include <iostream>
#include <cstring>
#define MAX_CHARS 26
// This function calculates number of unique characters

// using a associative array count[]. Returns true if
// no. of characters are less than required else returns
// false.
bool isValid(int count[], int k)
{
int val = 0;
for (int i=0; i<MAX_CHARS; i++)
for (int i=0; i<MAX_CHARS; i++)
if (count[i] > 0)
val++;
// Return true if k is greater than or equal to val

return (k >= val);
}
// Finds the maximum substring with exactly k unique chars

void kUniques(string s, int k)
{
int u = 0; // number of unique characters
int n = s.length();
// Associative array to store the count of characters

int count[MAX_CHARS];
// Traverse the string, Fills the associative array

// count[] and count number of unique characters
{
if (count[s[i]-'a']==0)
u++;
count[s[i]-'a']++;
}
// If there are not enough unique characters, show

// an error message.
if (u < k)
{
cout << "Not enough unique characters";
return;
}
// Otherwise take a window with first element in it.

// start and end variables.
int curr_start = 0, curr_end = 0;
// Also initialize values for result longest window

int max_window_size = 1, max_window_start = 0;
// Initialize associative array count[] with zero

count[s[0]-'a']++; // put the first character
// Start from the second character and add

// characters in window according to above
// explanation
{
// Add the character 's[i]' to current window
count[s[i]-'a']++;
curr_end++;
// If there are more than k unique characters in

// current window, remove from left side
while (!isValid(count, k))
{
count[s[curr_start]-'a']--;
curr_start++;
}
// Update the max window size if required

// Update the max window size if required
if (curr_end-curr_start+1 > max_window_size)
{
max_window_size = curr_end-curr_start+1;
max_window_start = curr_start;
}
}
cout << "Max sustring is : "

<< s.substr(max_window_start, max_window_size)
<< " with length " << max_window_size << endl;
}
// Driver function
int main()
{
string s = "aabacbebebe";
int k = 3;
kUniques(s, k);
return 0;
}

Output:
Max sustring is : cbebebe with length 7

Time Complexity: Considering function “isValid()” takes constant time, time complexity of above solution
is O(n).
This article is contributed by Gaurav Sharma. Please write comments if you find anything incorrect, or you
K’th Largest Element in BST when modification to BST is not allowed
Given a Binary Search Tree (BST) and a positive integer k, find the k’th largest element in the Binary Search
Tree.
We have discussed two methods in this post. The method 1 requires O(n) time. The method 2 takes O(h) time
where h is height of BST, but requires augmenting the BST (storing count of nodes in left subtree with every
node).
Can we find k’th largest element in better than O(n) time and no augmentation?
In this post, a method is discussed that takes O(h + k) time. This method doesn’t require any change to BST.
The idea is to do reverse inorder traversal of BST. The reverse inorder traversal traverses all nodes in
decreasing order. While doing the traversal, we keep track of count of nodes visited so far. When the count
becomes equal to k, we stop the traversal and print the key.
// C++ program to find k'th largest element in BST

#include<iostream>
struct Node
{
int key;
Node *left, *right;
};

{
temp->key = item;
return temp;
}
// A function to find k'th largest element in a given tree.

void kthLargestUtil(Node *root, int k, int &c)
{
// Base cases, the second condition is important to
// avoid unnecessary recursive calls
if (root == NULL || c >= k)
return;
// Follow reverse inorder traversal so that the
// largest element is visited first
kthLargestUtil(root->right, k, c);
// Increment count of visited nodes

c++;
// If c becomes k now, then this is the k'th largest

if (c == k)
{
cout << "K'th largest element is "
<< root->key << endl;
return;
}

kthLargestUtil(root->left, k, c);
}
// Function to find k'th largest element

void kthLargest(Node *root, int k)
{
// Initialize count of nodes visited as 0
int c = 0;
// Note that c is passed by reference

kthLargestUtil(root, k, c);
}

{

else if (key > node->key)

return node;
}

int main()
{
50
/ \
30 70
/ \ / \
20 40 60 80 */
Node *root = NULL;
insert(root, 30);
insert(root, 20);
insert(root, 40);
insert(root, 70);
insert(root, 60);
insert(root, 80);
int c = 0;
for (int k=1; k<=7; k++)
kthLargest(root, k);
return 0;
}

K'th largest element is 80


Time complexity: The code first traverses down to the rightmost node which takes O(h) time, then traverses
k elements in O(k) time. Therefore overall time complexity is O(h + k).
This article is contributed by Chirag Sharma. Please write comments if you find anything incorrect, or you
Given a binary tree, how do you remove all the half nodes?
Given A binary Tree, how do you remove all the half nodes (which has only one child)? Note leaves should
not be touched as they have both children as NULL.
For example consider the below tree.
Nodes 7, 5 and 9 are half nodes as one of their child is Null. We need to remove all such half nodes and
return the root pointer of following new tree.
The idea is to use post-order traversal to solve this problem efficiently. We first process the left children,
then right children, and finally the node itself. So we form the new tree bottom up, starting from the leaves
towards the root. By the time we process the current node, both its left and right subtrees were already
processed. Below is C implementation of this idea.
// C program to remove all half nodes

#include <stdio.h>
#include <stdlib.h>
struct node
{
int data;
};

{
node->data = data;
return(node);
}
void printInoder(struct node*root)

{
if (root != NULL)
{
printInoder(root->left);
printInoder(root->right);
}
}
// Removes all nodes with only one child and returns

// new root (note that root may change)
struct node* RemoveHalfNodes(struct node* root)
{
if (root==NULL)
return NULL;
root->left = RemoveHalfNodes(root->left);
root->right = RemoveHalfNodes(root->right);

return root;
/* if current nodes is a half node with left

child NULL left, then it's right child is
returned and replaces it in the given tree */
if (root->left==NULL)
{
struct node *new_root = root->right;
free(root); // To avoid memory leak
return new_root;
}
/* if current nodes is a half node with right

child NULL right, then it's right child is
returned and replaces it in the given tree */
if (root->right==NULL)
{
struct node *new_root = root->left;
free(root); // To avoid memory leak
return new_root;
}
return root;
}
// Driver program
int main(void)
{
struct node*NewRoot=NULL;
root->left->right->left=newNode(1);
root->left->right->right=newNode(11);
root->right->right=newNode(9);
root->right->right->left=newNode(4);
printf("Inorder traversal of given tree \n");

printInoder(root);
NewRoot = RemoveHalfNodes(root);
printf("\nInorder traversal of the modified tree \n");

printf("\nInorder traversal of the modified tree \n");
printInoder(NewRoot);
return 0;
}

Output:

Inorder traversal of given tree
7 1 6 11 2 5 4 9
1 6 11 2 4

Time complexity of the above solution is O(n) as it does a simple traversal of binary tree.
This article is contributed by Jyoti Saini. Please write comments if you find anything incorrect, or you want
Check if a given sequence of moves for a robot is circular or not
Given a sequence of moves for a robot, check if the sequence is circular or not. A sequence of moves is
circular if first and last positions of robot are same. A move can be on of the following.
G - Go one unit
L - Turn left
R - Turn right

Examples:
Input: path[] = "GLGLGLG"

Output: Given sequence of moves is circular
Input: path[] = "GLLG"

Output: Given sequence of moves is circular

The idea is to consider the starting position as (0, 0) and direction as East (We can pick any values for these).
If after the given sequence of moves, we come back to (0, 0), then given sequence is circular, otherwise not.
N
|
|
W -------------- E
|
|
S

The move ‘G’ changes either x or y according to following rules.

a) If current direction is North, then ‘G’ increments y and doesn’t change x.
b) If current direction is East, then ‘G’ increments x and doesn’t change y.
c) If current direction is South, then ‘G’ decrements y and doesn’t change x.
d) If current direction is West, then ‘G’ decrements x and doesn’t change y.
The moves ‘L’ and ‘R’, do not change x and y coordinates, they only change direction according to following
rule.
a) If current direction is North, then ‘L’ changes direction to West and ‘R’ changes to East
b) If current direction is East, then ‘L’ changes direction to North and ‘R’ changes to South
c) If current direction is South, then ‘L’ changes direction to East and ‘R’ changes to West
d) If current direction is West, then ‘L’ changes direction to South and ‘R’ changes to North.

// A c++ program to check if the given path for a robot is circular or not
#include<iostream>
// Macros for East, North, South and West

#define N 0
#define E 1
#define S 2
#define W 3
// This function returns true if the given path is circular, else false
bool isCircular(char path[])
{
// Initialize starting point for robot as (0, 0) and starting
// direction as N North
int x = 0, y = 0;
int dir = N;
// Travers the path given for robot

for (int i=0; path[i]; i++)
{
// Find current move
char move = path[i];
// If move is left or right, then change direction

if (move == 'R')
dir = (dir + 1)%4;
else if (move == 'L')
dir = (4 + dir - 1)%4;
// If move is Go, then change x or y according to

// current direction
else // if (move == 'G')
{
if (dir == N)
y++;
else if (dir == E)
x++;
else if (dir == S)
y--;
else // dir == W
x--;
}
}
// If robot comes back to (0, 0), then path is cyclic

return (x == 0 && y == 0);
}
// Driver program
int main()
{
char path[] = "GLGLGLG";
if (isCircular(path))
cout << "Given sequence of moves is circular";
else
cout << "Given sequence of moves is NOT circular";
}

Output:

Given sequence of moves is circular

Time Complexity: O(n) where n is number of moves in given sequence.
This article is contributed Kaustubh Deshmukh. Please write comments if you find anything incorrect, or
K Centers Problem | Set 1 (Greedy Approximate Algorithm)
Given n cities and distances between every pair of cities, select k cities to place warehouses (or ATMs) such
that the maximum distance of a city to a warehouse (or ATM) is minimized.
For example consider the following four cities, 0, 1, 2 and 3 and distances between them, how do place 2
ATMs among these 4 cities so that the maximum distance of a city to an ATM is minimized.
There is no polynomial time solution available for this problem as the problem is a known NP-Hard
problem. There is a polynomial time Greedy approximate algorithm, the greedy algorithm provides a
solution which is never worse that twice the optimal solution. The greedy solution works only if the
distances between cities follow Triangular Inequality (Distance between two points is always smaller than
sum of distances through a third point).
The 2-Approximate Greedy Algorithm:

1) Choose the first center arbitrarily.
2) Choose remaining k-1 centers using the following criteria.

Let c1, c2, c3, … ci be the already chosen centers. Choose
(i+1)’th center by picking the city which is farthest from already
selected centers, i.e, the point p which has following value as maximum
Min[dist(p, c1), dist(p, c2), dist(p, c3), …. dist(p, ci)]
The following diagram taken from here illustrates above algorithm.
Example (k = 3 in the above shown Graph)

a) Let the first arbitrarily picked vertex be 0.
b) The next vertex is 1 because 1 is the farthest vertex from 0.
c) Remaining cities are 2 and 3. Calculate their distances from already selected centers (0 and 1). The greedy
algorithm basically calculates following values.
Minimum of all distanced from 2 to already considered centers

Min[dist(2, 0), dist(2, 1)] = Min[7, 8] = 7
Minimum of all distanced from 3 to already considered centers

Min[dist(3, 0), dist(3, 1)] = Min[6, 5] = 5
After computing the above values, the city 2 is picked as the value corresponding to 2 is maximum.
Note that the greedy algorithm doesn’t give best solution for k = 2 as this is just an approximate algorithm
with bound as twice of optimal.
Proof that the above greedy algorithm is 2 approximate.

Let OPT be the maximum distance of a city from a center in the Optimal solution. We need to show that the
maximum distance obtained from Greedy algorithm is 2*OPT.
The proof can be done using contradiction.
a) Assume that the distance from the furthest point to all centers is > 2·OPT.
b) This means that distances between all centers are also > 2·OPT.
c) We have k + 1 points with distances > 2·OPT between every pair.
d) Each point has a center of the optimal solution with distance ? OPT to it.
e) There exists a pair of points with the same center X in the optimal solution (pigeonhole principle: k
optimal centers, k+1 points)
f) The distance between them is at most 2·OPT (triangle inequality) which is a contradiction.
Source:
http://algo2.iti.kit.edu/vanstee/courses/kcenter.pdf
This article is contributed by Harshit. Please write comments if you find anything incorrect, or you want to
Set Cover Problem | Set 1 (Greedy Approximate Algorithm)
Given a universe U of n elements, a collection of subsets of U say S = {S, S
1 2…,Sm } where every subset Si has
an associated cost. Find a minimum cost subcollection of S that covers all elements of U.
Example:
U = {1,2,3,4,5}
S = {S1,S2,S3}

S1 = {4,1,3}, Cost(S 1) = 5
S2 = {2,5}, Cost(S 2) = 10
S3 = {1,4,3,2}, Cost(S 3) = 3
Output: Minimum cost of set cover is 13 and

set cover is {S2, S3}
There are two possible set covers {S1, S 2} with cost 15

and {S 2, S 3} with cost 13.

Why is it useful?
It was one of Karp’s NP-complete problems, shown to be so in 1972. Other applications: edge covering,
vertex cover
Interesting example: IBM finds computer viruses (wikipedia)
Elements- 5000 known viruses
Sets- 9000 substrings of 20 or more consecutive bytes from viruses, not found in ‘good’ code.
A set cover of 180 was found. It suffices to search for these 180 substrings to verify the existence of known
computer viruses.
Another example: Consider General Motors needs to buy a certain amount of varied supplies and there are
suppliers that offer various deals for different combinations of materials (Supplier A: 2 tons of steel + 500
tiles for $x; Supplier B: 1 ton of steel + 2000 tiles for $y; etc.). You could use set covering to find the best way
to get all the materials while minimizing cost
Source: http://math.mit.edu/~goemans/18434S06/setcover-tamara.pdf
Set Cover is NP-Hard:

There is no polynomial time solution available for this problem as the problem is a known NP-Hard
problem. There is a polynomial time Greedy approximate algorithm, the greedy algorithm provides a Logn
approximate algorithm.
2-Approximate Greedy Algorithm:

Let U be the universe of elements, {S1, S2, … Sm} be collection of subsets of U and Cost(S1), C(S2), …
Cost(S m) be costs of subsets.

1) Let I represents set of elements included so far. Initialize I = {}
2) Do following while I is not same as U.

a) Find the set Si in {S 1, S 2, ... S m} whose cost effectiveness is
smallest, i.e., the ratio of cost C(Si) and number of newly added
elements is minimum.
Basically we pick the set for which following value is minimum.
Cost(Si) / |Si - I|
b) Add elements of above picked Si to I, i.e., I = I U Si

Example:
Let us consider the above example to understand Greedy Algorithm.
First Iteration:
I = {}
The per new element cost for S1 = Cost(S1)/|S1 – I| = 5/3
Since S3 has minimum value S3 is added, I becomes {1,4,3,2}.
Second Iteration:
I = {1,4,3,2}

Note that S1 doesn’t add any new element to I.

Note that S2 adds only 5 to I.
The greedy algorithm provides the optimal solution for above example, but it may not provide optimal
solution all the time. Consider the following example.
S1 = {1, 2}
S2 = {2, 3, 4, 5}
S3 = {6, 7, 8, 9, 10, 11, 12, 13}
S4 = {1, 3, 5, 7, 9, 11, 13}
S5 = {2, 4, 6, 8, 10, 12, 13}
Let the cost of every set be same.
The greedy algorithm produces result as {S3, S 2, S 1}
The optimal solution is {S 4, S 5}

Proof that the above greedy algorithm is Logn approximate.

Let OPT be the cost of optimal solution. Say (k-1) elements are covered before an iteration of above greedy
algorithm. The cost of the k’th element i that has not been covered before the current step of greedy
algorithm and it is there in OPT. Since greedy algorithm picks the most cost effective Si, per element cost in
the picked set in Greedy must be smaller than OPT divided by remaining elements. Therefore cost of k’th
element Cost of Greedy Algorithm = Sum of costs of n elements [putting k = 1, 2..n in above formula]
Source:
http://math.mit.edu/~goemans/18434S06/setcover-tamara.pdf
This article is contributed by Harshit. Please write comments if you find anything incorrect, or you want to
Subtract two numbers without using arithmetic operators
Write a function subtract(x, y) that returns x-y where x and y are integers. The function should not use any of
the arithmetic operators (+, ++, –, -, .. etc).
The idea is to use bitwise operators. Addition of two numbers has been discussed using Bitwise operators.
Like addition, the idea is to use subtractor logic.
The truth table for the half subtractor is given below.
X Y Diff Borrow
0 0 0 0
0 1 1 1
1 0 1 0
1 1 0 0

From the above table one can draw the Karnaugh map for “difference” and “borrow”.
So, Logic equations are:
Diff = y ⊕ x
Borrow = x' . y

Source: Wikipedia page for subtractor
Following is C implementation based on above equations.

#include<stdio.h>
int subtract(int x, int y)

{
// Iterate till there is no carry
while (y != 0)
{
// borrow contains common set bits of y and unset
// bits of x
int borrow = (~x) & y;
// Subtraction of bits of x and y where at least

// one of the bits is not set
x = x ^ y;
// Borrow is shifted by one so that subtracting it from

// x gives the required sum
y = borrow << 1;
}
return x;
}
// Driver program
int main()
{
int x = 29, y = 13;
printf("x - y is %d", subtract(x, y));
return 0;
}

Output:

x - y is 16

Following is recursive implementation for the same approach.

#include<stdio.h>
int subtract(int x, int y)

{
if (y == 0)
return x;
return subtract(x ^ y, (~x & y) << 1);
}
// Driver program
int main()
{
int x = 29, y = 13;
printf("x - y is %d", subtract(x, y));
return 0;
}

Output:

x - y is 16

This article is contributed Dheeraj. Please write comments if you find anything incorrect, or you want to
Given a sorted and rotated array, find if there is a pair with a given sum
Given an array that is sorted and then rotated around an unknown point. Find if array has a pair with given
sum ‘x’. It may be assumed that all elements in array are distinct.
Examples:
Input: arr[] = {11, 15, 6, 8, 9, 10}, x = 16

Output: true
There is a pair (6, 10) with sum 16
Input: arr[] = {11, 15, 26, 38, 9, 10}, x = 35

Output: true
There is a pair (26, 9) with sum 35
Input: arr[] = {11, 15, 26, 38, 9, 10}, x = 45

Output: false
There is no pair with sum 45.

We have discussed a O(n) solution for a sorted array (See steps 2, 3 and 4 of Method 1). We can extend this
solution for rotated array as well. The idea is to first find the maximum element in array which is the pivot
point also and the element just before maximum is the minimum element. Once we have indexes maximum
and minimum elements, we use similar meet in middle algorithm (as discussed here in method 1) to find if
there is a pair. The only thing new here is indexes are incremented and decremented in rotational manner
using modular arithmetic.

// C++ program to find a pair with a given sum in a sorted and

// rotated array
#include<iostream>
// This function returns true if arr[0..n-1] has a pair

// with sum equals to x.
bool pairInSortedRotated(int arr[], int n, int x)
{
// Find the pivot element
int i;
for (i=0; i<n-1; i++)
break;
int l = (i+1)%n; // l is now index of minimum element
int r = i; // r is now index of maximum element
// Keep moving either l or r till they meet

while (l != r)
{
// If we find a pair with sum x, we return true
if (arr[l] + arr[r] == x)
return true;
// If current pair sum is less, move to the higher sum

if (arr[l] + arr[r] < x)
l = (l + 1)%n;
else // Move to the lower sum side
r = (n + r - 1)%n;
}
return false;
}

int main()
{
int arr[] = {11, 15, 6, 8, 9, 10};
int sum = 16;
if (pairInSortedRotated(arr, n, sum))
cout << "Array has two elements with sum 16";
else
cout << "Array doesn't have two elements with sum 16 ";
return 0;
}

Output:

Array has two elements with sum 16

Time complexity of the above solution is O(n). The step to find the pivot can be optimized to O(Logn) using
the Binary Search approach discussed here.
Exercise:
1) Extend the above solution to work for arrays with duplicates allowed.
2) Extend the above solution to find all pairs.
Build Lowest Number by Removing n digits from a given number
Given a string ‘str’ of digits and an integer ‘n’, build the lowest possible number by removing ‘n’ digits from
the string and not changing the order of input digits.
Examples:
Input: str = "4325043", n = 3

Output: "2043"
Input: str = "765028321", n = 5

Output: "0221"
Input: str = "121198", n = 2

Output: "1118"

The idea is based on the fact that a character among first (n+1) characters must be there in resultant
number. So we pick the smallest of first (n+1) digits and put it in result, and recur for remaining characters.
Below is complete algorithm.
Initialize result as empty string

res = ""
buildLowestNumber(str, n, res)
1) If n == 0, then there is nothing to remove.
Append the whole 'str' to 'res' and return
2) Let 'len' be length of 'str'. If 'len' is smaller or equal

to n, then everything can be removed
Append nothing to 'res' and return
3) Find the smallest character among first (n+1) characters

of 'str'. Let the index of smallest character be minIndex.
Append 'str[minIndex]' to 'res' and recur for substring after
minIndex and for n = n-minIndex
buildLowestNumber(str[minIndex+1..len-1], n-minIndex).

// C++ program to build the smallest number by removing n digits from

// a given number
#include<iostream>
// A recursive function that removes 'n' characters from 'str'

// to store the smallest possible number in 'res'
void buildLowestNumberRec(string str, int n, string &res)
{
// If there are 0 characters to remove from str,
// append everything to result
if (n == 0)
if (n == 0)
{
res.append(str);
return;
}
int len = str.length();
// If there are more characters to remove than string

// length, then append nothing to result
if (len <= n)
return;
// Find the smallest character among first (n+1) characters

// of str.
int minIndex = 0;
for (int i = 1; i<=n ; i++)
if (str[i] < str[minIndex])
minIndex = i;
// Append the smallest character to result

res.push_back(str[minIndex]);
// substring starting from minIndex+1 to str.length() - 1.

string new_str = str.substr(minIndex+1, len-minIndex);
// Recur for the above substring and n equals to n-minIndex

buildLowestNumberRec(new_str, n-minIndex, res);
}
// A wrapper over buildLowestNumberRec()

string buildLowestNumber(string str, int n)
{
string res = "";
// Note that result is passed by reference

buildLowestNumberRec(str, n, res);
return res;
}

int main()
{
int n = 2;
cout << buildLowestNumber(str, n);
return 0;
}

Output:

1118>

This article is contributed by Pallav Gurha. Please write comments if you find anything incorrect, or you
Group multiple occurrence of array elements ordered by first occurrence
Given an unsorted array with repetitions, the task is to group multiple occurrence of individual elements.
The grouping should happen in a way that the order of first occurrences of all elements is maintained.
Examples:
Input: arr[] = {5, 3, 5, 1, 3, 3}

Output: {5, 5, 3, 3, 3, 1}
Input: arr[] = {4, 6, 9, 2, 3, 4, 9, 6, 10, 4}

Output: {4, 4, 4, 6, 6, 9, 9, 2, 3, 10}

Simple Solution is to use nested loops. The outer loop traverses array elements one by one. The inner loop
checks if this is first occurrence, if yes, then the inner loop prints it and all other occurrences.

// A simple C++ program to group multiple occurrences of individual

// array elements
#include<iostream>
// A simple method to group all occurrences of individual elements

void groupElements(int arr[], int n)
{
// Initialize all elements as not visited
bool *visited = new bool[n];
visited[i] = false;
// Traverse all elements

{
// Check if this is first occurrence
if (!visited[i])
{
// If yes, print it and all subsequent occurrences
cout << arr[i] << " ";
{
if (arr[i] == arr[j])
{
cout << arr[i] << " ";
visited[j] = true;
}
}
}
}
delete [] visited;
}

int main()
{
int arr[] = {4, 6, 9, 2, 3, 4, 9, 6, 10, 4};
groupElements(arr, n);
return 0;
}

Output:

4 4 4 6 6 9 9 2 3 10

Time complexity of the above method is O(n2).
Binary Search Tree based Method: The time complexity can be improved to O(nLogn) using self-
balancing binary search tree like Red-Black Tree or AVL tree. Following is complete algorithm.
1) Create an empty Binary Search Tree (BST). Every BST node is going to contain an array element and its
count.
2) Traverse the input array and do following for every element.
……..a) If element is not present in BST, then insert it with count as 0.
……..b) If element is present, then increment count in corresponding BST node.
3) Traverse the array again and do following for every element.
…….. If element is present in BST, then do following
……….a) Get its count and print the element ‘count’ times.
……….b) Delete the element from BST.
Time Complexity of the above solution is O(nLogn).
Hashing based Method: We can also use hashing. The idea is to replace Binary Search Tree with a Hash
Map in above algorithm.
Below is Java Implementation of hashing based solution.

/* Java program to group multiple occurrences of individual array elements */

class Main
{
// A hashing based method to group all occurrences of individual elements
static void orderedGroup(int arr[])
{
// Creates an empty hashmap
// Traverse the array elements, and store count for every element
// in HashMap
{
// Check if element is already in HashMap
Integer prevCount = hM.get(arr[i]);
if (prevCount == null)
prevCount = 0;

// Increment count of element element in HashMap
hM.put(arr[i], prevCount + 1);
}
// Traverse array again

{
// Check if this is first occurrence
Integer count = hM.get(arr[i]);
if (count != null)
{
// If yes, then print the element 'count' times
for (int j=0; j<count; j++)
System.out.print(arr[i] + " ");

// And remove the element from HashMap.
hM.remove(arr[i]);
}
}
}

{
int arr[] = {10, 5, 3, 10, 10, 4, 1, 3};
orderedGroup(arr);
}
}

Output:

10 10 10 5 3 3 4 1

Time Complexity of the above hashing based solution is Θ(n) under the assumption that insert, search and
delete operations on HashMap take O(1) time.
Advantages of BST over Hash Table
Hash Table supports following operations in Θ(1) time.
1) Search
2) Insert
3) Delete
The time complexity of above operations in a self-balancing Binary Search Tree (BST) (like Red-Black Tree,
AVL Tree, Splay Tree, etc) is O(Logn).
So Hash Table seems to beating BST in all common operations. When should we prefer BST over Hash
Tables, what are advantages. Following are some important points in favor of BSTs.
1. We can get all keys in sorted order by just doing Inorder Traversal of BST. This is not a natural
operation in Hash Tables and requires extra efforts.
2. Doing order statistics, finding closest lower and greater elements, doing range queries are easy to do
with BSTs. Like sorting, these operations are not a natural operation with Hash Tables.
3. BSTs are easy to implement compared to hashing, we can easily implement our own customized BST.
To implement Hashing, we generally rely on libraries provided by programming languages.
4. With BSTs, all operations are guaranteed to work in O(Logn) time. But with Hashing, Θ(1) is average
time and some particular operations may be costly, especially when table resizing happens.
Iterative Merge Sort
Following is a typical recursive implementation of Merge Sort that uses last element as pivot.
/* Recursive C program for merge sort */

#include<stdlib.h>
#include<stdio.h>
/* Function to merge the two haves arr[l..m] and arr[m+1..r] of array arr[] */
void merge(int arr[], int l, int m, int r);
/* l is for left index and r is right index of the sub-array

of arr to be sorted */
void mergeSort(int arr[], int l, int r)
{
if (l < r)
{
int m = l+(r-l)/2; //Same as (l+r)/2 but avoids overflow for large l & h
mergeSort(arr, l, m);
mergeSort(arr, m+1, r);
merge(arr, l, m, r);
}
}
void merge(int arr[], int l, int m, int r)
{
int i, j, k;
int n1 = m - l + 1;
int n2 = r - m;
/* create temp arrays */

int L[n1], R[n2];
/* Copy data to temp arrays L[] and R[] */

for (i = 0; i < n1; i++)
L[i] = arr[l + i];
for (j = 0; j < n2; j++)
R[j] = arr[m + 1+ j];
/* Merge the temp arrays back into arr[l..r]*/

i = 0;
j = 0;
k = l;
while (i < n1 && j < n2)
{
if (L[i] <= R[j])
{
arr[k] = L[i];
i++;
}
else
{
arr[k] = R[j];
j++;
}
k++;
}
/* Copy the remaining elements of L[], if there are any */

while (i < n1)
{
arr[k] = L[i];
i++;
k++;
}
/* Copy the remaining elements of R[], if there are any */

while (j < n2)
{
arr[k] = R[j];
j++;
k++;
}
}

void printArray(int A[], int size)
{
int i;
printf("%d ", A[i]);
printf("\n");
}

int main()
{
int arr[] = {12, 11, 13, 5, 6, 7};

mergeSort(arr, 0, arr_size - 1);
printf("\nSorted array is \n");

return 0;
}

Output:

Given array is
12 11 13 5 6 7
Sorted array is
5 6 7 11 12 13

Iterative Merge Sort:

The above function is recursive, so uses function call stack to store intermediate values of l and h. The
function call stack stores other bookkeeping information together with parameters. Also, function calls
involve overheads like storing activation record of the caller function and then resuming execution. Unlike
Iterative QuickSort, the iterative MergeSort doesn’t require explicit auxiliary stack.
The above function can be easily converted to iterative version. Following is iterative Merge Sort.

/* Iterative C program for merge sort */
#include<stdlib.h>
#include<stdio.h>
void merge(int arr[], int l, int m, int r);
// Utility function to find minimum of two integers

int min(int x, int y) { return (x<y)? x :y; }
/* Iterative mergesort function to sort arr[0...n-1] */

void mergeSort(int arr[], int n)
{
int curr_size; // For current size of subarrays to be merged
// curr_size varies from 1 to n/2
int left_start; // For picking starting index of left subarray
// to be merged
// Merge subarrays in bottom up manner. First merge subarrays of

// size 1 to create sorted subarrays of size 2, then merge subarrays
// of size 2 to create sorted subarrays of size 4, and so on.
for (curr_size=1; curr_size<=n-1; curr_size = 2*curr_size)
{
// Pick starting point of different subarrays of current size
for (left_start=0; left_start<n-1; left_start += 2*curr_size)
{
// Find ending point of left subarray. mid+1 is starting
// point of right
int mid = left_start + curr_size - 1;
int right_end = min(left_start + 2*curr_size - 1, n-1);
// Merge Subarrays arr[left_start...mid] & arr[mid+1...right_end]

merge(arr, left_start, mid, right_end);
}
}
}
void merge(int arr[], int l, int m, int r)
{
int i, j, k;
int n1 = m - l + 1;
int n2 = r - m;
/* create temp arrays */

int L[n1], R[n2];
/* Copy data to temp arrays L[] and R[] */

for (i = 0; i < n1; i++)
L[i] = arr[l + i];
for (j = 0; j < n2; j++)
R[j] = arr[m + 1+ j];
/* Merge the temp arrays back into arr[l..r]*/

i = 0;
j = 0;
k = l;
while (i < n1 && j < n2)
{
if (L[i] <= R[j])
{
arr[k] = L[i];
arr[k] = L[i];
i++;
}
else
{
arr[k] = R[j];
j++;
}
k++;
}
/* Copy the remaining elements of L[], if there are any */

while (i < n1)
{
arr[k] = L[i];
i++;
k++;
}
/* Copy the remaining elements of R[], if there are any */

while (j < n2)
{
arr[k] = R[j];
j++;
k++;
}
}

void printArray(int A[], int size)
{
int i;
printf("%d ", A[i]);
printf("\n");
}

int main()
{
int arr[] = {12, 11, 13, 5, 6, 7};

printArray(arr, n);
mergeSort(arr, n);
printf("\nSorted array is \n");

printArray(arr, n);
return 0;
}

Output:

Given array is
12 11 13 5 6 7
Sorted array is
5 6 7 11 12 13

Time complexity of above iterative function is same as recursive, i.e., Θ(nLogn).
References:
http://csg.sph.umich.edu/abecasis/class/2006/615.09.pdf
This article is contributed by Shivam Agrawal. Please write comments if you find anything incorrect, or
Swap nodes in a linked list without swapping data
Given a linked list and two keys in it, swap nodes for two given keys. Nodes should be swapped by changing
links. Swapping data of nodes may be expensive in many situations when data contains many fields.
It may be assumed that all keys in linked list are distinct.
Examples:
Input: 10->15->12->13->20->14, x = 12, y = 20

Output: 10->15->20->13->12->14
Input: 10->15->12->13->20->14, x = 10, y = 20

Output: 20->15->12->13->10->14
Input: 10->15->12->13->20->14, x = 12, y = 13

Output: 10->15->13->12->20->14

This may look a simple problem, but is interesting question as it has following cases to be handled.
1) x and y may or may not be adjacent.
2) Either x or y may be a head node.
3) Either x or y may be last node.
4) x and/or y may not be present in linked list.
How to write a clean working code that handles all of the above possibilities.
The idea it to first search x and y in given linked list. If any of them is not present, then return. While
searching for x and y, keep track of current and previous pointers. First change next of previous pointers,
then change next of current pointers. Following is C implementation of this approach.
/* This program swaps the nodes of linked list rather

than swapping the field from the nodes.*/
#include<stdio.h>
#include<stdlib.h>

struct node
{
int data;
struct node *next;
};
/* Function to swap nodes x and y in linked list by

changing links */
void swapNodes(struct node **head_ref, int x, int y)
{
// Nothing to do if x and y are same
if (x == y) return;
// Search for x (keep track of prevX and CurrX

struct node *prevX = NULL, *currX = *head_ref;
while (currX && currX->data != x)
{
{
prevX = currX;
currX = currX->next;
}
// Search for y (keep track of prevY and CurrY

struct node *prevY = NULL, *currY = *head_ref;
while (currY && currY->data != y)
{
prevY = currY;
currY = currY->next;
}
// If either x or y is not present, nothing to do

if (currX == NULL || currY == NULL)
return;
// If x is not head of linked list

if (prevX != NULL)
prevX->next = currY;
else // Else make y as new head
*head_ref = currY;
// If y is not head of linked list

if (prevY != NULL)
prevY->next = currX;
else // Else make x as new head
*head_ref = currX;
// Swap next pointers

struct node *temp = currY->next;
currY->next = currX->next;
currX->next = temp;
}
/* Function to add a node at the begining of List */

{
/* allocate node */



}

{
while(node != NULL)
{
node = node->next;
}
}

int main()
{
{

1->2->3->4->5->6->7 */
push(&start, 7);
push(&start, 6);
push(&start, 5);
push(&start, 4);
push(&start, 3);
push(&start, 2);
push(&start, 1);
printf("\n Linked list before calling swapNodes() ");

printList(start);
swapNodes(&start, 4, 3);
printf("\n Linked list after calling swapNodes() ");

printList(start);
return 0;
}

Output:
Linked list before calling swapNodes() 1 2 3 4 5 6 7

Linked list after calling swapNodes() 1 2 4 3 5 6 7

Optimizations: The above code can be optimized to search x and y in single traversal. Two loops are used
to keep program simple.
This article is contributed by Gautam. Please write comments if you find anything incorrect, or you want to
Print missing elements that lie in range 0 – 99
Given an array of integers print the missing elements that lie in range 0-99. If there are more than one
missing, collate them, otherwise just print the number.
Note that the input array may not be sorted and may contain numbers outside the range [0-99], but only this
range is to be considered for printing missing elements.
Examples
Input: {88, 105, 3, 2, 200, 0, 10}

Output: 1
4-9
11-87
89-99
Input: {9, 6, 900, 850, 5, 90, 100, 99}

Output: 0-4
7-8
10-89
91-98

Expected time complexity O(n), where n is the size of the input array.
The idea is to use a boolean array of size 100 to keep track of array elements that lie in range 0 to 99. We first
traverse input array and mark such present elements in the boolean array. Once all present elements are
marked, the boolean array is used to print missing elements.

// C program for print missing elements

#include<stdio.h>
#define LIMIT 100
// A O(n) function to print missing elements in an array

void printMissing(int arr[], int n)
{
// Initialize all number from 0 to 99 as NOT seen
bool seen[LIMIT] = {false};
// Mark present elements in range [0-99] as seen

if (arr[i] < LIMIT)
seen[arr[i]] = true;
// Print missing element

int i = 0;
while (i < LIMIT)
{
// If i is missing
if (seen[i] == false)
{
// Find if there are more missing elements after i
int j = i+1;
while (j < LIMIT && seen[j] == false)
j++;
// Print missing single or range

(i+1 == j)? printf("%d\n", i): printf("%d-%d\n", i, j-1);
// Update u
i = j;
}
else
i++;
}
}
// Driver program
int main()
{
int arr[] = {88, 105, 3, 2, 200, 0, 10};
printMissing(arr, n);
return 0;
}

Output:

1
4-9
11-87
89-99

Time complexity of the above program is O(n).

This article is contributed by Vignesh Narayanan and Sowmya Sampath. Please write comments if you find
Design a data structure that supports insert, delete, search and getRandom
in constant time
Design a data structure that supports following operations in Θ(1) time.
insert(x): Inserts an item x to the data structure if not already present.
remove(x): Removes an item x from the data structure if present.
search(x): Searches an item x in the data structure.
getRandom(): Returns a random element from current set of elements
We can use hashing to support first 3 operations in Θ(1) time. How to do the 4th operation? The idea is to
use a resizable array (ArrayList in Java, vector in C) together with hashing. Resizable arrays support insert
in Θ(1) amortized time complexity. To implement getRandom(), we can simply pick a random number from
0 to size-1 (size is number of current elements) and return the element at that index. The hash map stores
array values as keys and array indexes as values.
Following are detailed operations.
insert(x)
1) Check if x is already present by doing a hash map lookup.
2) If not present, then insert it at the end of the array.
3) Add in hash table also, x is added as key and last array index as index.
remove(x)
1) Check if x is present by doing a hash map lookup.
2) If present, then find its index and remove it from hash map.
3) Swap the last element with this element in array and remove the last element.
Swapping is done because the last element can be removed in O(1) time.
4) Update index of last element in hash map.
getRandom()
1) Generate a random number from 0 to last index.
2) Return the array element at the randomly generated index.
search(x)
Do a lookup for x in hash map.
Below is Java implementation of the data structure.
/* Java program to design a data structure that support folloiwng operations

in Theta(n) time
a) Insert
b) Delete
c) Search
d) getRandom */
import java.util.*;
// class to represent the required data structure

class MyDS
{
ArrayList<Integer> arr; // A resizable array
// A hash where keys are array elements and vlaues are

// indexes in arr[]
// indexes in arr[]
HashMap<Integer, Integer> hash;
// Constructor (creates arr[] and hash)

public MyDS()
{
arr = new ArrayList<Integer>();
hash = new HashMap<Integer, Integer>();
}
// A Theta(1) function to add an element to MyDS

// data structure
void add(int x)
{
// If ekement is already present, then noting to do
if (hash.get(x) != null)
return;
// Else put element at the end of arr[]

int s = arr.size();
arr.add(x);
// And put in hash also

hash.put(x, s);
}
// A Theta(1) function to remove an element from MyDS

// data structure
void remove(int x)
{
// Check if element is present
Integer index = hash.get(x);
if (index == null)
return;
// If present, then remove element from hash

hash.remove(x);
// Swap element with last element so that remove from

// arr[] can be done in O(1) time
int size = arr.size();
Integer last = arr.get(size-1);
Collections.swap(arr, index, size-1);
// Remove last element (This is O(1))

arr.remove(size-1);
// Update hash table for new index of last element

hash.put(last, index);
}
// Returns a random element from MyDS

int getRandom()
{
// Find a random index from 0 to size - 1
Random rand = new Random(); // Choose a different seed
int index = rand.nextInt(arr.size());
// Return element at randomly picked index

return arr.get(index);
}
// Returns index of element if element is present, otherwise null

Integer search(int x)
{
{
return hash.get(x);
}
}
// Driver class
class Main
{
{
MyDS ds = new MyDS();
ds.add(10);
ds.add(20);
ds.add(30);
ds.add(40);
System.out.println(ds.search(30));
ds.remove(20);
ds.add(50);
System.out.println(ds.search(50));
System.out.println(ds.getRandom());
}
}

Output:
2
3
40

This article is contributed by Manish Gupta. Please write comments if you find anything incorrect, or you
Recursively print all sentences that can be formed from list of word lists
Given a list of word lists How to print all sentences possible taking one word from a list at a time via
recursion?
Example:
Input: {{"you", "we"},

{"have", "are"},
{"sleep", "eat", "drink"}}
Output:
you have sleep
you have eat
you have drink
you are sleep
you are eat
you are drink
we have sleep
we have eat
we have drink
we are sleep
we are eat
we are drink

The idea is based on simple depth first traversal. We start from every word of first list as first word of an
output sentence, then recur for the remaining lists.
Below is C++ implementation of above idea. In the below implementation, input list of list is considered as a
2D array. If we take a closer look, we can observe that the code is very close to DFS of graph.

// C++ program to print all possible sentences from a list of word list
#include <iostream>
#include <string>
#define R 3
#define C 3
// A recursive function to print all possible sentences that can be formed

// from a list of word list
void printUtil(string arr[R][C], int m, int n, string output[R])
{
// Add current word to output array
output[m] = arr[m][n];
// If this is last word of current output sentence, then print

// the output sentence
if (m==R-1)
{
for (int i=0; i<R; i++)
cout << output[i] << " ";
cout << endl;
return;
}
// Recur for next row

for (int i=0; i<C; i++)
if (arr[m+1][i] != "")
printUtil(arr, m+1, i, output);
}
// A wrapper over printUtil()

void print(string arr[R][C])
{
// Create an array to store sentence
string output[R];
// Consider all words for first row as starting points and

// print all sentences
if (arr[0][i] != "")
printUtil(arr, 0, i, output);
}

int main()
{
string arr[R][C] = {{"you", "we"},
{"have", "are"},
{"sleep", "eat", "drink"}};
print(arr);
return 0;
}

Output:

you have sleep
you have eat
you have drink
you are sleep
you are eat
you are drink
we have sleep
we have eat
we have drink
we are sleep
we are eat
we are drink

Assign directions to edges so that the directed graph remains acyclic
Given a graph with both directed and undirected edges. It is given that the directed edges don’t form cycle.
How to assign directions to undirected edges so that the graph (with all directed edges) remains acyclic even
after the assignment?
For example, in the below graph, blue edges don’t have directions.
The idea is to use Topological Sorting. Following are two steps used in the algorithm.
1) Consider the subgraph with directed edges only and find topological sorting of the subgraph. In the above
example, topological sorting is {0, 5, 1, 2, 3, 4}. Below diagram shows topological sorting for the above
example graph.
2) Use above topological sorting to assign directions to undirected edges. For every undirected edge (u, v),
assign it direction from u to v if u comes before v in topological sorting, else assign it direction from v to u.
Below diagram shows assigned directions in the example graph.
Source: http://courses.csail.mit.edu/6.006/oldquizzes/solutions/q2-f2009-sol.pdf
This article is contributed by Aditya Agrawal. Please write comments if you find anything incorrect, or you
Handshaking Lemma and Interesting Tree Properties
What is Handshaking Lemma?
Handshaking lemma is about undirected graph. In every finite undirected graph number of vertices with odd
degree is always even. The handshaking lemma is a consequence of the degree sum formula (also sometimes
called the handshaking lemma)
How is Handshaking Lemma useful in Tree Data structure?

Following are some interesting facts that can be proved using Handshaking lemma.
1) In a k-ary tree where every node has either 0 or k children, following property is always
true.
L = (k - 1)*I + 1
Where L = Number of leaf nodes
I = Number of internal nodes

Proof:
Proof can be divided in two cases.
Case 1 (Root is Leaf):There is only one node in tree. The above formula is true for single node as L = 1, I =
0.
Case 2 (Root is Internal Node): For trees with more than 1 nodes, root is always internal node. The above
formula can be proved using Handshaking Lemma for this case. A tree is an undirected acyclic graph.
Total number of edges in Tree is number of nodes minus 1, i.e., |E| = L + I – 1.
All internal nodes except root in the given type of tree have degree k + 1. Root has degree k. All leaves have
degree 1. Applying the Handshaking lemma to such trees, we get following relation.
Sum of all degrees = 2 * (Sum of Edges)
Sum of degrees of leaves +

Sum of degrees for Internal Node except root +
Root's degree = 2 * (No. of nodes - 1)
Putting values of above terms,

L + (I-1)*(k+1) + k = 2 * (L + I - 1)
L + k*I - k + I -1 + k = 2*L + 2I - 2
L + K*I + I - 1 = 2*L + 2*I - 2
K*I + 1 - I = L
(K-1)*I + 1 = L

So the above property is proved using Handshaking Lemma, let us discuss one more interesting property.

2) In Binary tree, number of leaf nodes is always one more than nodes with two children.
L = T + 1
Where L = Number of leaf nodes
T = Number of internal nodes with two children

Proof:
Let number of nodes with 2 children be T. Proof can be divided in three cases.

Case 1: There is only one node, the relationship holds
as T = 0, L = 1.

Case 2: Root has two children, i.e., degree of root is 2.

Sum of degrees of nodes with two children except root +
Sum of degrees of nodes with one child +
Sum of degrees of leaves + Root's degree = 2 * (No. of Nodes - 1)

(T-1)*3 + S*2 + L + 2 = (S + T + L - 1)*2
Cancelling 2S from both sides.

(T-1)*3 + L + 2 = (S + L - 1)*2
T - 1 = L - 2
T = L - 1

Case 3: Root has one child, i.e., degree of root is 1.

Sum of degrees of nodes with two children +
Sum of degrees of nodes with one child except root +
Sum of degrees of leaves + Root's degree = 2 * (No. of Nodes - 1)

T*3 + (S-1)*2 + L + 1 = (S + T + L - 1)*2
Cancelling 2S from both sides.

3*T + L -1 = 2*T + 2*L - 2
T - 1 = L - 2
T = L - 1

Therefore, in all three cases, we get T = L-1.
We have discussed proof of two important properties of Trees using Handshaking Lemma. Many GATE
questions have been asked on these properties, following are few links.
GATE-CS-2015 (Set 3) | Question 35

GATE-CS-2015 (Set 2) | Question 20
GATE-CS-2005 | Question 36
discussed above
Maximum profit by buying and selling a share at most twice
In a daily share trading, a buyer buys shares in the morning and sells it on same day. If the trader is allowed
to make at most 2 transactions in a day, where as second transaction can only start after first one is complete
(Sell->buy->sell->buy). Given stock prices throughout day, find out maximum profit that a share trader
could have made.
Examples:
Input: price[] = {10, 22, 5, 75, 65, 80}

Output: 87
Trader earns 87 as sum of 12 and 75
Buy at price 10, sell at 22, buy at 5 and sell at 80
Input: price[] = {2, 30, 15, 10, 8, 25, 80}

Output: 100
Trader earns 100 as sum of 28 and 72
Buy at price 2, sell at 30, buy at 8 and sell at 80
Input: price[] = {100, 30, 15, 10, 8, 25, 80};

Output: 72
Buy at price 8 and sell at 80.
Input: price[] = {90, 80, 70, 60, 50}

Output: 0
Not possible to earn.

A Simple Solution is to to consider every index ‘i’ and do following
Max profit with at most two transactions =

MAX {max profit with one transaction and subarray price[0..i] +
max profit with one transaction and aubarray price[i+1..n-1] }
i varies from 0 to n-1.

Maximum possible using one transaction can be calculated using following O(n) algorithm
Maximum difference between two elements such that larger element appears after the smaller number
Time complexity of above simple solution is O(n2).
We can do this O(n) using following Efficient Solution. The idea is to store maximum possible profit of
every subarray and solve the problem in following two phases.
1) Create a table profit[0..n-1] and initialize all values in it 0.
2) Traverse price[] from right to left and update profit[i] such that profit[i] stores maximum profit
achievable from one transaction in subarray price[i..n-1]
3) Traverse price[] from left to right and update profit[i] such that profit[i] stores maximum profit such that
profit[i] contains maximum achievable profit from two transactions in subarray price[0..i].
4) Return profit[n-1]
To do step 1, we need to keep track of maximum price from right to left side and to do step 2, we need to
keep track of minimum price from left to right. Why we traverse in reverse directions? The idea is to save
space, in second step, we use same array for both purposes, maximum with 1 transaction and maximum with
2 transactions. After an iteration i, the array profit[0..i] contains maximum profit with 2 transactions and
profit[i+1..n-1] contains profit with two transactions.
// C++ program to find maximum possible profit with at most

// two transactions
#include<iostream>
// Returns maximum profit with two transactions on a given

// list of stock prices, price[0..n-1]
int maxProfit(int price[], int n)
{
// Create profit array and initialize it as 0
int *profit = new int[n];
profit[i] = 0;
/* Get the maximum profit with only one transaction

allowed. After this loop, profit[i] contains maximum
profit from price[i..n-1] using at most one trans. */
int max_price = price[n-1];
for (int i=n-2;i>=0;i--)
{
// max_price has maximum of price[i..n-1]
if (price[i] > max_price)
max_price = price[i];
// we can get profit[i] by taking maximum of:

// a) previous maximum, i.e., profit[i+1]
// b) profit by buying at price[i] and selling at
// max_price
profit[i] = max(profit[i+1], max_price-price[i]);
}
/* Get the maximum profit with two transactions allowed

After this loop, profit[n-1] contains the result */
int min_price = price[0];
{
// min_price is minimum price in price[0..i]
if (price[i] < min_price)
min_price = price[i];
// Maximum profit is maximum of:

// a) previous maximum, i.e., profit[i-1]
// b) (Buy, Sell) at (min_price, price[i]) and add
// profit of other trans. stored in profit[i]
profit[i] = max(profit[i-1], profit[i] +
(price[i]-min_price) );
}
int result = profit[n-1];
delete [] profit; // To avoid memory leak
return result;
return result;
}
// Drive program
int main()
{
int price[] = {2, 30, 15, 10, 8, 25, 80};
cout << "Maximum Profit = " << maxProfit(price, n);
return 0;
}

Output:

Maximum Profit = 100

Time complexity of the above solution is O(n).
This article is contributed by Amit Jaiswal. Please write comments if you find anything incorrect, or you
Pythagorean Triplet in an array
2
Given an array of integers, write a function that returns true if there is a triplet (a, b, c) that satisfies a + b2 =
2
c .
Example:
Input: arr[] = {3, 1, 4, 6, 5}

Output: True
There is a Pythagorean triplet (3, 4, 5).
Input: arr[] = {10, 4, 6, 12, 5}

Output: False
There is no Pythagorean triplet.

Method 1 (Naive)
A simple solution is to run three loops, three loops pick three array elements and check if current three
elements form a Pythagorean Triplet.
Below is C++ implementation of simple solution.

// A C++ program that returns true if there is a Pythagorean

// Triplet in a given aray.
#include <iostream>
// Returns true if there is Pythagorean triplet in ar[0..n-1]

bool isTriplet(int ar[], int n)
{
{
{
for (int k=j+1; k<n; k++)
{
// Calculate square of array elements
int x = ar[i]*ar[i], y = ar[j]*ar[j], z = ar[k]*ar[k];
if (x == y + z || y == x + z || z == x + y)
return true;
}
}
}
// If we reach here, no triplet found

return false;
}

int main()
{
int ar[] = {3, 1, 4, 6, 5};
int ar_size = sizeof(ar)/sizeof(ar[0]);
isTriplet(ar, ar_size)? cout << "Yes": cout << "No";
return 0;
}

Output:

Yes

Time Complexity of the above solution is O(n3).

We can solve this in O(n 2) time by sorting the array first.
1) Do square of every element in input array. This step takes O(n) time.
2) Sort the squared array in increasing order. This step takes O(nLogn) time.
3) To find a triplet (a, b, c) such that a = b + c, do following.
a. Fix ‘a’ as last element of sorted array.

b. Now search for pair (b, c) in subarray between first element and ‘a’. A pair (b, c) with given sum can
be found in O(n) time using meet in middle algorithm discussed in method 1 of this post.
c. If no pair found for current ‘a’, then move ‘a’ one position back and repeat step 3.b.
// A C++ program that returns true if there is a Pythagorean

// Triplet in a given array.
#include <iostream>
// Returns true if there is a triplet with following property

// A[i]*A[i] = A[j]*A[j] + A[k]*[k]
// Note that this function modifies given array
bool isTriplet(int arr[], int n)
{
// Square array elements
arr[i] = arr[i]*arr[i];
// Sort array elements

sort(arr, arr + n);
// Now fix one element one by one and find the other two
// elements
for (int i = n-1; i >= 2; i--)
{
// To find the other two elements, start two index
// variables from two corners of the array and move
// them toward each other
int l = 0; // index of the first element in arr[0..i-1]
int r = i-1; // index of the last element in arr[0..i-1]
while (l < r)
{
// A triplet found
if (arr[l] + arr[r] == arr[i])
return true;
// Else either move 'l' or 'r'

(arr[l] + arr[r] < arr[i])? l++: r--;
}
}
// If we reach here, then no triplet found

return false;
}

int main()
{
int arr[] = {3, 1, 4, 6, 5};
isTriplet(arr, arr_size)? cout << "Yes": cout << "No";
return 0;
}

Output:

Yes

Time complexity of this method is O(n2).
This article is contributed by Harshit Gupta. Please write comments if you find anything incorrect, or you
Point to next higher value node in a linked list with an arbitrary pointer
Given singly linked list with every node having an additional “arbitrary” pointer that currently points to
NULL. Need to make the “arbitrary” pointer point to the next higher value node.
A Simple Solution is to traverse all nodes one by one, for every node, find the node which has next greater
value of current node and change the next pointer. Time Complexity of this solution is O(n2.
An Efficient Solution works in O(nLogn) time. The idea is to use Merge Sort for linked list.
1) Traverse input list and copy next pointer to arbit pointer for every node.
2) Do Merge Sort for the linked list formed by arbit pointers.
Below is C implementation of above idea. All of the merger sort functions are taken from here. The taken
functions are modified here so that they work on arbit pointers instead of next pointers.
// C program to populate arbit pointers to next higher value

// using merge sort
#include<stdio.h>
#include<stdlib.h>

struct node
{
int data;
struct node* next, *arbit;
};
/* function prototypes */
struct node* SortedMerge(struct node* a, struct node* b);
struct node** frontRef, struct node** backRef);
/* sorts the linked list formed by arbit pointers

(does not change next pointer or data) */
void MergeSort(struct node** headRef)
{
struct node* head = *headRef;
struct node* a, *b;
/* Base case -- length 0 or 1 */

if ((head == NULL) || (head->arbit == NULL))
return;
/* Split head into 'a' and 'b' sublists */

/* Recursively sort the sublists */

MergeSort(&a);
MergeSort(&b);
/* answer = merge the two sorted lists together */

}
/* See http://geeksforgeeks.org/?p=3622 for details of this

function */
{
/* Base cases */
if (a == NULL)
return (b);
else if (b==NULL)
return (a);

{
result = a;
result->arbit = SortedMerge(a->arbit, b);
}
else
{
result = b;
result->arbit = SortedMerge(a, b->arbit);
}
return (result);
}
/* Split the nodes of the given list into front and back halves,
and return the two lists using the reference parameters.
If the length is odd, the extra node should go in the front list.
Uses the fast/slow pointer strategy. */
struct node** frontRef, struct node** backRef)
{
struct node* fast, *slow;
if (source==NULL || source->arbit==NULL)
{
/* length < 2 cases */
*frontRef = source;
*backRef = NULL;
return;
}
slow = source, fast = source->arbit;
/* Advance 'fast' two nodes, and advance 'slow' one node */

while (fast != NULL)
{
fast = fast->arbit;
if (fast != NULL)
{
slow = slow->arbit;
fast = fast->arbit;
}
}
/* 'slow' is before the midpoint in the list, so split it in two

at that point. */
*frontRef = source;
*backRef = slow->arbit;
slow->arbit = NULL;
}

{
/* allocate node */


new_node->arbit = NULL;

}
// Utility function to print result linked list

void printListafter(struct node *node, struct node *anode)
{
printf("Traversal using Next Pointer\n");
while (node!=NULL)
{
printf("%d, ", node->data);
node = node->next;
}
printf("\nTraversal using Arbit Pointer\n");

while (anode!=NULL)
{
printf("%d, ", anode->data);
anode = anode->arbit;
}
}
// This function populates arbit pointer in every node to the

// next higher value. And returns pointer to the node with
// minimum value
struct node* populateArbit(struct node *head)
{
// Copy next pointers to arbit pointers
{
temp->arbit = temp->next;
temp = temp->next;
}
// Do merge sort for arbitrary pointers

MergeSort(&head);
// Return head of arbitrary pointer linked list

return head;
}

int main()
{
/* Let us create the list shown above */

push(&head, 3);
push(&head, 2);
push(&head, 10);
push(&head, 5);
/* Sort the above created Linked List */

struct node *ahead = populateArbit(head);
printf("\nResult Linked List is: \n");

printListafter(head, ahead);
getchar();
return 0;
}

Output:
Result Linked List is:

Traversal using Next Pointer
5, 10, 2, 3,
Traversal using Arbit Pointer
2, 3, 5, 10,

This article is contributed by Saurabh Bansal. Please write comments if you find anything incorrect, or
Count possible ways to construct buildings
Given an input number of sections and each section has 2 plots on either sides of the road. Find all possible
ways to construct buildings in the plots such that there is a space between any 2 buildings.
Example:
N = 1
Output = 4
Place a building on one side.
Place a building on other side
Do not place any building.
Place a building on both sides.
N = 3
Output = 25
3 sections, which means possible ways for one side are
BSS, BSB, SSS, SBS, SSB where B represents a building
and S represents an empty space
Total possible ways are 25, because a way to place on
one side can correspond to any of 5 ways on other side.
N = 4
Output = 64

We can simplify the problem to first calculate for one side only. If we know the result for one side, we can
always do square of the result and get result for two sides.
A new building can be placed on a section if section just before it has space. A space can be placed anywhere
(it doesn’t matter whether the previous section has a building or not).
Let countB(i) be count of possible ways with i sections

ending with a building.
countS(i) be count of possible ways with i sections
ending with a space.
// A space can be added after a building or after a space.

countS(N) = countB(N-1) + countS(N-1)
// A building can only be added after a space.

countB[N] = countS(N-1)
// Result for one side is sum of the above two counts.

result1(N) = countS(N) + countB(N)
// Result for two sides is square of result1(N)

result2(N) = result1(N) * result1(N)


// C++ program to count all possible way to construct buildings

#include<iostream>
// Returns count of possible ways for N sections

int countWays(int N)
{
// Base case
if (N == 1)
return 4; // 2 for one side and 4 for two sides
// countB is count of ways with a building at the end

// countS is count of ways with a space at the end
// prev_countB and prev_countS are previous values of
// countB and countS respectively.
// Initialize countB and countS for one side

int countB=1, countS=1, prev_countB, prev_countS;
// Use the above recursive formula for calculating

// countB and countS using previous values
for (int i=2; i<=N; i++)
{
prev_countB = countB;
prev_countS = countS;
countS = prev_countB + prev_countS;

countB = prev_countS;
}
// Result for one side is sum of ways ending with building

// and ending with space
int result = countS + countB;
// Result for 2 sides is square of result for one side

return (result*result);
}
// Driver program
int main()
{
int N = 3;
cout << "Count of ways for " << N
<< " sections is " << countWays(N);
return 0;
}

Output:

25

Time complexity: O(N)

Optimized Solution:
Note that the above solution can be further optimized. If we take closer look at the results, for different
values, we can notice that the results for two sides are squares of Fibonacci Numbers.
N = 1, result = 4 [result for one side = 2]

…………………….
…………………….
In general, we can say
result(N) = fib(N+2)2

fib(N) is a function that returns N'th
Fibonacci Number.

Therefore, we can use O(LogN) implementation of Fibonacci Numbers to find number of ways in O(logN)
time.
This article is contributed by GOPINATH. Please write comments if you find anything incorrect, or you
Iterative Tower of Hanoi
Tower of Hanoi is a mathematical puzzle. It consists of three poles and a number of disks of different sizes
which can slide onto any poles. The puzzle starts with the disk in a neat stack in ascending order of size in
one pole, the smallest at the top thus making a conical shape. The objective of the puzzle is to move all the
disks from one pole (say ‘source pole’) to another pole (say ‘destination pole’) with the help of third pole (say
auxiliary pole).
The puzzle has the following two rules:
1. You can’t place a larger disk onto smaller disk

2. Only one disk can be moved at a time
We’ve already discussed recursive solution for Tower of Hanoi. We have also seen that, for n disks, total 2n –
1 moves are required.
Iterative Algorithm:
1. Calculate the total number of moves required i.e. "pow(2, n)

- 1" here n is number of disks.
2. If number of disks (i.e. n) is even then interchange destination
pole and auxiliary pole.
3. for i = 1 to total number of moves:
if i%3 == 1:
legal movement of top disk between source pole and
destination pole
if i%3 == 2:
legal movement top disk between source pole and
auxiliary pole
if i%3 == 0:
legal movement top disk between auxiliary pole
and destination pole

Example:
Let us understand with a simple example with 3 disks:

So, total number of moves required = 7
S A D
When i= 1, (i % 3 == 1) legal movement between‘S’ and ‘D’
When i = 2, (i % 3 == 2) legal movement between ‘S’ and ‘A’

When i = 3, (i % 3 == 0) legal movement between ‘A’ and ‘D’ ’
When i = 4, (i % 4 == 1) legal movement between ‘S’ and ‘D’
When i = 5, (i % 5 == 2) legal movement between ‘S’ and ‘A’
When i = 6, (i % 6 == 0) legal movement between ‘A’ and ‘D’
When i = 7, (i % 7 == 1) legal movement between ‘S’ and ‘D’
So, after all these destination pole contains all the in order of size.
After observing above iterations, we can think thatafter a disk other than the smallest disk is moved, the next
disk to be moved must be the smallest disk because it is the top disk resting on the spare pole and there are
no other choices to move a disk.

// C Program for Iterative Tower of Hanoi
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
// A structure to represent a stack

struct Stack
{
unsigned capacity;
int top;
int *array;
};
// function to create a stack of given capacity.

struct Stack* createStack(unsigned capacity)
{
stack -> capacity = capacity;
stack -> top = -1;
stack -> array =
(int*) malloc(stack -> capacity * sizeof(int));
return stack;
}
// Stack is full when top is equal to the last index

{
return (stack->top == stack->capacity - 1);
}
// Stack is empty when top is equal to -1

{
return (stack->top == -1);
}
// Function to add an item to stack. It increases

// top by 1
void push(struct Stack *stack, int item)
{
if (isFull(stack))
return;
stack -> array[++stack -> top] = item;
}
// Function to remove an item from stack. It

// decreases top by 1
int pop(struct Stack* stack)
{
if (isEmpty(stack))
return INT_MIN;
return stack -> array[stack -> top--];
}
// Function to implement legal movement between

// two poles
void moveDisksBetweenTwoPoles(struct Stack *src,
struct Stack *dest, char s, char d)
{
int pole1TopDisk = pop(src);
int pole2TopDisk = pop(dest);
// When pole 1 is empty
if (pole1TopDisk == INT_MIN)
{
push(src, pole2TopDisk);
moveDisk(d, s, pole2TopDisk);
}
// When pole2 pole is empty

else if (pole2TopDisk == INT_MIN)
{
push(dest, pole1TopDisk);
moveDisk(s, d, pole1TopDisk);
}
// When top disk of pole1 > top disk of pole2

else if (pole1TopDisk > pole2TopDisk)
{
moveDisk(d, s, pole2TopDisk);
}
// When top disk of pole1 < top disk of pole2

else
{
moveDisk(s, d, pole1TopDisk);
}
}
//Function to show the movement of disks

void moveDisk(char fromPeg, char toPeg, int disk)
{
printf("Move the disk %d from \'%c\' to \'%c\'\n",
disk, fromPeg, toPeg);
}
//Function to implement TOH puzzle

void tohIterative(int num_of_disks, struct Stack
*src, struct Stack *aux,
struct Stack *dest)
{
int i, total_num_of_moves;
char s = 'S', d = 'D', a = 'A';
//If number of disks is even, then interchange

//destination pole and auxiliary pole
if (num_of_disks % 2 == 0)
{
char temp = d;
d = a;
a = temp;
}
total_num_of_moves = pow(2, num_of_disks) - 1;
//Larger disks will be pushed first

for (i = num_of_disks; i >= 1; i--)
push(src, i);
for (i = 1; i <= total_num_of_moves; i++)

{
if (i % 3 == 1)
moveDisksBetweenTwoPoles(src, dest, s, d);
else if (i % 3 == 2)
moveDisksBetweenTwoPoles(src, aux, s, a);
else if (i % 3 == 0)
moveDisksBetweenTwoPoles(aux, dest, a, d);
}
}
// Driver Program
int main()
{
// Input: number of disks
unsigned num_of_disks = 3;
struct Stack *src, *dest, *aux;
// Create three stacks of size 'num_of_disks'

// to hold the disks
src = createStack(num_of_disks);
aux = createStack(num_of_disks);
dest = createStack(num_of_disks);
tohIterative(num_of_disks, src, aux, dest);

return 0;
}

Output:

Move the disk 1 from 'S' to 'D'
Move the disk 2 from 'S' to 'A'
Move the disk 1 from 'D' to 'A'
Move the disk 1 from 'A' to 'S'
Move the disk 2 from 'A' to 'D'

References:
http://en.wikipedia.org/wiki/Tower_of_Hanoi#Iterative_solution
This article is contributed by Anand Barnwal. Please write comments if you find anything incorrect, or
Linearity of Expectation
This post is about a mathematical concept, but it covers one of the required topics to understand
Randomized Algorithms.
Let us consider the following simple problem.
Given a fair dice with 6 faces, the dice is thrown n times, find expected value of sum of all results.
For example, if n = 2, there are total 36 possible outcomes.
(1, 1), (1, 2), .... (1, 6)

(2, 1), (2, 2), .... (2, 6)
................
................
(6, 1), (6, 2), ..... (6, 6)

Expected value of a discrete random variable is R defined as following. Suppose R can take value r with
1
probability p1, value r2 with probability p2, and so on, up to value rk with probability pk. Then the
expectation of this random variable R is defined as
E[R] = r 1*p1 + r2*p2 + ... rk*pk

Let us calculate expected value for the above example.
Expected Value of sum = 2*1/36 + 3*1/6 + .... + 7*1/36 +

3*1/36 + 4*1/6 + .... + 8*1/36 +
........................
.........................
7*1/36 + 8*1/6 + .... + 12*1/36

= 7

The above way to solve the problem becomes difficult when there are more dice throws.
If we know about linearity of expectation, then we can quickly solve the above problem for any number of
throws.
Linearity of Expectation: Let R1 and R2 be two discrete random variables on some probability space,
then
E[R1 + R2] = E[R 1] + E[R 2]

Using the above formula, we can quickly solve the dice problem.
Expected Value of sum of 2 dice throws = 2*(Expected value of one dice throw)
= 2*(1/6 + 2/6 + .... 6/6)
= 2*7/2
= 7
Expected value of sum for n dice throws is = n * 7/2 = 3.5 * n

Some interesting facts about Linearly of Expectation:

1) Linearity of expectation holds for both dependent and independent events. On the other hand the rule
E[R1R2] = E[R1]*E[R2] is true only for independent events.
2) Linearity of expectation holds for any number of random variables on some probability space. Let R1, R2,
R3, … Rk be k random variables, then
E[R1 + R2 + R3 + … + Rk] = E[R1] + E[R2] + E[R3] + … + E[Rk]
Another example that can be easily solved with linearity of expectation:

Hat-Check Problem: Let there be group of n men where every man has one hat. The hats are redistributed
and every man gets a random hat back. What is the expected number of men that get their original hat back.
Solution: Let Ri be a random variable, the value of random variable is 1 if i’th man gets the same hat back,
otherwise 0.
So the expected number of men to get the right hat back is

= E[R 1] + E[R 2] + .. + E[Rn]
= P(R 1 = 1) + P(R 2 = 1) + .... + P(Rn = 1)
[Here P(Ri = 1) indicates probability that R i is 1]
= 1/n + 1/n + ... + 1/n
= 1

So on average 1 person gets the right hat back.
Exercise:
1) Given a fair coin, what is the expected number of heads when coin is tossed n times.
2) Balls and Bins: Suppose we have m balls, labeled i = 1, … , m and n bins, labeled j = 1, .. ,n. Each ball is
thrown into one of the bin independently and uniformly at random.
a) What is the expected number of balls in every bin
b) What is the expected number of empty bins.
3) Coupon Collector: Suppose there are n types of coupons in a lottery and each lot contains one coupon
(with probability 1 = n each). How many lots have to be bought (in expectation) until we have at least one
coupon of each type.
See following for solution of Coupon Collector.

Expected Number of Trials until Success
Linearity of expectation is useful in algorithms. For example, expected time complexity of random
algorithms like randomized quick sort is evaluated using linearity of expectation (See this for reference).
References:
http://www.cse.iitd.ac.in/~mohanty/col106/Resources/linearity_expectation.pdf
http://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-042j-mathematics-for-
computer-science-fall-2010/video-lectures/lecture-22-expectation-i/
This article is contributed by Shubham Gupta. Please write comments if you find anything incorrect, or
Find Union and Intersection of two unsorted arrays
Given two unsorted arrays that represent two sets (elements in every array are distinct), find union and
intersection of two arrays.
For example, if the input arrays are:

arr1[] = {7, 1, 5, 2, 3, 6}
arr2[] = {3, 8, 6, 20, 7}
Then your program should print Union as {1, 2, 3, 5, 6, 7, 8, 20} and Intersection as {3, 6}. Note that the
elements of union and intersection can be printed in any order.
Method 1 (Naive)
Union:
1) Initialize union U as empty.
2) Copy all elements of first array to U.
3) Do following for every element x of second array:
…..a) If x is not present in first array, then copy x to U.
4) Return U.
Intersection:
1) Initialize intersection I as empty.
2) Do following for every element x of first array
…..a) If x is present in second array, then copy x to I.
4) Return I.
Time complexity of this method is O(mn) for both operations. Here m and n are number of elements in
arr1[] and arr2[] respectively.

1) Sort arr1[] and arr2[]. This step takes O(mLogm + nLogn) time.
2) Use O(m + n) algorithms to find union and intersection of two sorted arrays.
Overall time complexity of this method is O(mLogm + nLogn).
Method 3 (Use Sorting and Searching)

Union:
2) Find smaller of m and n and sort the smaller array.
3) Copy the smaller array to U.
4) For every element x of larger array, do following
…….b) Binary Search x in smaller array. If x is not present, then copy it to U.
5) Return U.
Intersection:
2) Find smaller of m and n and sort the smaller array.
3) For every element x of larger array, do following
…….b) Binary Search x in smaller array. If x is present, then copy it to I.
4) Return I.
Time complexity of this method is min(mLogm + nLogm, mLogn + nLogn) which can also be written as
O((m+n)Logm, (m+n)Logn). This approach works much better than the previous approach when difference
between sizes of two arrays is significant.
Thanks to use_the_force for suggesting this method in a comment here.

// A C++ program to print union and intersection of two unsorted arrays

#include <iostream>
int binarySearch(int arr[], int l, int r, int x);
// Prints union of arr1[0..m-1] and arr2[0..n-1]

void printUnion(int arr1[], int arr2[], int m, int n)
{
// Before finding union, make sure arr1[0..m-1] is smaller
if (m > n)
{
int *tempp = arr1;
arr1 = arr2;
arr2 = tempp;
int temp = m;
m = n;
n = temp;
}
// Now arr1[] is smaller
// Sort the first array and print its elements (these two
// steps can be swapped as order in output is not important)
sort(arr1, arr1 + m);
cout << arr1[i] << " ";
// Search every element of bigger array in smaller array

// and print the element if not found
if (binarySearch(arr1, 0, m-1, arr2[i]) == -1)
cout << arr2[i] << " ";
}
// Prints intersection of arr1[0..m-1] and arr2[0..n-1]

void printIntersection(int arr1[], int arr2[], int m, int n)
{
// Before finding intersection, make sure arr1[0..m-1] is smaller
if (m > n)
{
int *tempp = arr1;
arr1 = arr2;
arr2 = tempp;
int temp = m;
m = n;
n = temp;
}
// Now arr1[] is smaller
// Sort smaller array arr1[0..m-1]

sort(arr1, arr1 + m);
// Search every element of bigger array in smaller array

// and print the element if found
if (binarySearch(arr1, 0, m-1, arr2[i]) != -1)
cout << arr2[i] << " ";
}
// A recursive binary search function. It returns location of x in

{
if (r >= l)
{
int mid = l + (r - l)/2;
// If the element is present at the middle itself


// in left subarray

}

return -1;
}

int main()
{
int arr1[] = {7, 1, 5, 2, 3, 6};
int arr2[] = {3, 8, 6, 20, 7};
cout << "Union of two arrays is \n";
printUnion(arr1, arr2, m, n);
cout << "\nIntersection of two arrays is \n";
printIntersection(arr1, arr2, m, n);
return 0;
}

Output:

Union of two arrays is
3 6 7 8 20 1 5 2
Intersection of two arrays is
7 3 6


Union:
1) Initialize an empty hash table.
2) Iterate through first array and put every element of first array in the hash table, and in U.
4) For every element x of second array, do following
…….a) Search x in the hash table. If x is not present, then copy it to U.
5) Return U.
Intersection:
2) In initialize an empty hash table.
3) Iterate through first array and put every element of first array in the hash table.
4) For every element x of second array, do following
…….a) Search x in the hash table. If x is present, then copy it to I.
5) Return I.
Time complexity of this method is Θ(m+n) under the assumption that hash table search and insert
operations take Θ(1) time.
problem.
Merge Sort for Doubly Linked List
Given a doubly linked list, write a function to sort the doubly linked list in increasing order using merge sort.
For example, the following doubly linked list should be changed to 24810
Merge sort for singly linked list is already discussed. The important change here is to modify the previous
pointers also when merging two lists.
Below is C implementation of merge sort for doubly linked list.
// C program for merge sort on doubly linked list

#include<stdio.h>
#include<stdlib.h>
struct node
{
int data;
struct node *next, *prev;
};
struct node *split(struct node *head);
// Function to merge two linked lists

struct node *merge(struct node *first, struct node *second)
{
// If first linked list is empty
if (!first)
return second;
// If second linked list is empty

if (!second)
return first;
// Pick the smaller value

if (first->data < second->data)
{
first->next = merge(first->next,second);
first->next->prev = first;
first->prev = NULL;
return first;
}
else
{
second->next = merge(first,second->next);
second->next->prev = second;
second->prev = NULL;
return second;
}
}
// Function to do merge sort

struct node *mergeSort(struct node *head)
{
if (!head || !head->next)
if (!head || !head->next)
return head;
struct node *second = split(head);
// Recur for left and right halves

head = mergeSort(head);
second = mergeSort(second);
// Merge the two sorted halves

return merge(head,second);
}
// A utility function to insert a new node at the

// beginning of doubly linked list
void insert(struct node **head, int data)
{
struct node *temp =
temp->data = data;
temp->next = temp->prev = NULL;
if (!(*head))
(*head) = temp;
else
{
temp->next = *head;
(*head)->prev = temp;
(*head) = temp;
}
}
// A utility function to print a doubly linked list in

// both forward and backward directions
void print(struct node *head)
{
printf("Forward Traversal using next poitner\n");
while (head)
{
temp = head;
head = head->next;
}
printf("\nBackword Traversal using prev pointer\n");
while (temp)
{
temp = temp->prev;
}
}
// Utility function to swap two integers

void swap(int *A, int *B)
{
int temp = *A;
*A = *B;
*B = temp;
}
// Split a doubly linked list (DLL) into 2 DLLs of

// half sizes
struct node *split(struct node *head)
{
struct node *fast = head,*slow = head;
while (fast->next && fast->next->next)
{
{
fast = fast->next->next;
slow = slow->next;
}
struct node *temp = slow->next;
slow->next = NULL;
return temp;
}
// Driver program
int main(void)
{
insert(&head,5);
insert(&head,20);
insert(&head,4);
insert(&head,3);
insert(&head,30);
insert(&head,10);
printf("Linked List before sorting\n");
print(head);
head = mergeSort(head);
printf("\n\nLinked List after sorting\n");
print(head);
return 0;
}

Output:

Forward Traversal using next pointer
10 30 3 4 20 5
Backward Traversal using prev pointer
5 20 4 3 30 10

Forward Traversal using next pointer
3 4 5 10 20 30
Backward Traversal using prev pointer
30 20 10 5 4 3

Thanks to Goku for providing above implementation in a comment here.
Time Complexity: Time complexity of the above implementation is same as time complexity of MergeSort
for arrays. It takes Θ(nLogn) time.
You may also like to see QuickSort for doubly linked list
discussed above
Expected Number of Trials until Success
Consider the following famous puzzle.
In a country, all families want a boy. They keep having babies till a boy is born. What is the expected ratio
of boys and girls in the country?
This puzzle can be easily solved if we know following interesting result in probability and expectation.
If probability of success is p in every trial, then expected number of trials until success is 1/p
Proof: Let R be a random variable that indicates number of trials until success.
The expected value of R is sum of following infinite series

E[R] = 1*p + 2*(1-p)*p + 3*(1-p) 2*p + 4*(1-p) 3*p + ........
Taking 'p' out

E[R] = p[1 + 2*(1-p) + 3*(1-p) 2 + 4*(1-p) 3 + .......] ---->(1)
Multiplying both sides with '(1-p)' and subtracting

(1-p)*E[R] = p[1*(1-p) + 2*(1-p) 2 + 3*(1-p) 3 + .......] --->(2)
Subtracting (2) from (1), we get
p*E[R] = p[1 + (1-p) + (1-p) 2 + (1-p) 3 + ........]
Canceling p from both sides

E[R] = [1 + (1-p) + (1-p) 2 + (1-p) 3 + ........]
Above is an infinite geometric progression with ratio (1-p).

Since (1-p) is less than, we can apply sum formula.
E[R] = 1/[1 - (1-p)]
= 1/p

Solution of Boys/Girls ratio puzzle:

Let us use the above result to solve the puzzle. In the given puzzle, probability of success in every trial is 1/2
(assuming that girls and boys are equally likely).
Let p be probability of having a baby boy.

Number of kids until a baby boy is born = 1/p
= 1/(1/2)
= 2
Since expected number of kids in a family is 2,
ratio of boys and girls is 50:50.

Let us discuss another problem that uses above result.
Coupon Collector Problem:

Suppose there are n types of coupons in a lottery and each lot contains one coupon (with probability 1 = n
each). How many lots have to be bought (in expectation) until we have at least one coupon of each type.
The solution of this problem is also based on above result.
Let Xi be the number of lots bought before i’th new coupon is collected.
Note that X1 is 1 as the first coupon is always a new coupon (not collected before).
Let ‘p’ be probability that 2nd coupon is collected in next buy. The value of p is (n-1)/n. So the number of
trials needed before 2nd new coupon is picked is 1/p which means n/(n-1). [This is where we use above
result]
Similarly, the number of trials needed before 3rd new coupon is collected is n/(n-2)
Using Linearity of expectation,

we can say that the total number of expected trials =
1 + n/(n-1) + n/(n-2) + n/(n-3) + .... + n/2 + n/1
= n[1/n + 1/(n-1) + 1/(n-2) + 1/(n-3) + ....+ 1/2 + 1/1]
= n * Hn
Here Hn is n-th Harmonic number
Since Logn n
Exercise:
1) A 6 faced fair dice is thrown until a '5' is seen as result of dice throw. What is the
expected number of throws?
2) What is the ratio of boys and girls in above puzzle if probability of a baby boy is 1/
3?
Reference:
http://www.cse.iitd.ac.in/~mohanty/col106/Resources/linearity_expectation.pdf
http://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-042j-
mathematics-for-computer-science-fall-2010/video-lectures/lecture-22-expectation-i/

Find number of Employees Under every Employee
Given a dictionary that contains mapping of employee and his manager as a number of (employee, manager)
pairs like below.
{ "A", "C" },
{ "B", "C" },
{ "C", "F" },
{ "D", "E" },
{ "E", "F" },
{ "F", "F" }
In this example C is manager of A,

C is also manager of B, F is manager
of C and so on.

Write a function to get no of employees under each manager in the hierarchy not just their direct reports. It
may be assumed that an employee directly reports to only one manager. In the above dictionary the root
node/ceo is listed as reporting to himself.
Output should be a Dictionary that contains following.
A - 0
B - 0
C - 2
D - 0
E - 1
F - 5

Source: Microsoft Interview
This question might be solved differently but i followed this and found interesting, so sharing:

1. Create a reverse map with Manager->DirectReportingEmployee

combination. Off-course employee will be multiple so Value
in Map is List of Strings.
"C" --> "A", "B",
"E" --> "D"
"F" --> "C", "E", "F"

2. Now use the given employee-manager map to iterate and at
the same time use newly reverse map to find the count of
employees under manager.

Let the map created in step 2 be 'mngrEmpMap'
Do following for every employee 'emp'.
a) If 'emp' is not present in 'mngrEmpMap'
Count under 'emp' is 0 [Nobody reports to 'emp']
b) If 'emp' is present in 'mngrEmpMap'
Use the list of direct reports from map 'mngrEmpMap'
and recursively calculate number of total employees
under 'emp'.

A trick in step 2.b is to use memorization(Dynamic programming) while finding number of employees under
a manager so that we don’t need to find number of employees again for any of the employees. In the below
code populateResultUtil() is the recursive function that uses memoization to avoid re-computation of same
results.
Below is Java implementation of above ides
// Java program to find number of persons under every employee

import java.util.ArrayList;
import java.util.List;
public class NumberEmployeeUnderManager

{
// A hashmap to store result. It stores count of employees
// under every employee, the count may by 0 also
static Map<String,Integer> result =
new HashMap<String, Integer>();
// Driver function
{
Map<String, String> dataSet = new HashMap<String, String>();
dataSet.put("A", "C");
dataSet.put("B", "C");
dataSet.put("C", "F");
dataSet.put("D", "E");
dataSet.put("E", "F");
dataSet.put("F", "F");
populateResult(dataSet);
System.out.println("result = " + result);
}
// This function populates 'result' for given input 'dataset'
private static void populateResult(Map<String, String> dataSet)
{
// To store reverse of original map, each key will have 0
// to multiple values
Map<String, List<String>> mngrEmpMap =
new HashMap<String, List<String>>();
// To fill mngrEmpMap, iterate through the given map

for (Map.Entry<String,String> entry: dataSet.entrySet())
{
String emp = entry.getKey();
String mngr = entry.getValue();
if (!emp.equals(mngr)) // excluding emp-emp entry
{
// Get the previous list of direct reports under
// current 'mgr' and add the current 'emp' to the list
List<String> directReportList = mngrEmpMap.get(mngr);
// If 'emp' is the first employee under 'mgr'

if (directReportList == null)
directReportList = new ArrayList<String>();
directReportList.add(emp);

// Replace old value for 'mgr' with new
// directReportList
mngrEmpMap.put(mngr, directReportList);
}
}
// Now use manager-Emp map built above to populate result

// with use of populateResultUtil()
// note- we are iterating over original emp-manager map and

// will use mngr-emp map in helper to get the count
for (String mngr: dataSet.keySet())
populateResultUtil(mngr, mngrEmpMap);
}
// This is a recursive function to fill count for 'mgr' using

// mngrEmpMap. This function uses memoization to avoid re-
// computations of subproblems.
private static int populateResultUtil(String mngr,
Map<String, List<String>> mngrEmpMap)
{
int count = 0;
// means employee is not a manager of any other employee

if (!mngrEmpMap.containsKey(mngr))
{
result.put(mngr, 0);
return 0;
}
// this employee count has already been done by this

// method, so avoid re-computation
else if (result.containsKey(mngr))
count = result.get(mngr);
else
{
List<String> directReportEmpList = mngrEmpMap.get(mngr);
count = directReportEmpList.size();
count = directReportEmpList.size();
for (String directReportEmp: directReportEmpList)
count += populateResultUtil(directReportEmp, mngrEmpMap);
result.put(mngr, count);
}
return count;
}
}

Output:

result = {D=0, E=1, F=5, A=0, B=0, C=2}

This article is contributed by Chandan Prakash. Please write comments if you find anything incorrect, or
How to handle duplicates in Binary Search Tree?
In a Binary Search Tree (BST), all keys in left subtree of a key must be smaller and all keys in right subtree
must be greater. So a Binary Search Tree by definition has distinct keys.
How to allow duplicates where every insertion inserts one more key with a value and every deletion deletes
one occurrence?
A Simple Solution is to allow same keys on right side (we could also choose left side). For example
consider insertion of keys 12, 10, 20, 9, 11, 10, 12, 12 in an empty Binary Search Tree
12
/ \
10 20
/ \ /
9 11 12
/ \
10 12

A Better Solution is to augment every tree node to store count together with regular fields like key, left
and right pointers.
Insertion of keys 12, 10, 20, 9, 11, 10, 12, 12 in an empty Binary Search Tree would create following.
12(3)
/ \
10(2) 20(1)
/ \
9(1) 11(1)
Count of a key is shown in bracket

This approach has following advantages over above simple approach.
1) Height of tree is small irrespective of number of duplicates. Note that most of the BST operations (search,
insert and delete) have time complexity as O(h) where h is height of BST. So if we are able to keep the height
small, we get advantage of less number of key comparisons.
2) Search, Insert and Delete become easier to do. We can use same insert, search and delete algorithms with
small modifications (see below code).
3) This approach is suited for self-balancing BSTs (AVL Tree, Red-Black Tree, etc) also. These trees involve
rotations, and a rotation may violate BST property of simple solution as a same key can be in either left side
or right side after rotation.
Below is C implementation of normal Binary Search Tree with count with every key. This code basically is
taken from code for insert and delete in BST. The changes made for handling duplicates are highlighted, rest
of the code is same.
// C program to implement basic operations (search, insert and delete)

// on a BST that handles duplicates by storing count with every node
#include<stdio.h>
#include<stdlib.h>
struct node
{
int key;
int count;
};

{
temp->key = item;
temp->count = 1;
return temp;
}
// A utility function to do inorder traversal of BST

{
if (root != NULL)
{
printf("%d(%d) ", root->key, root->count);
}
}

{
// If key already exists in BST, icnrement count and return

if (key == node->key)
{
(node->count)++;
return node;
}

else

return node;
}
/* Given a non-empty binary search tree, return the node with

minimum key value found in that tree. Note that the entire
tree does not need to be searched. */
struct node * minValueNode(struct node* node)
{

while (current->left != NULL)
return current;
}
/* Given a binary search tree and a key, this function

deletes a given key and returns root of modified tree */
struct node* deleteNode(struct node* root, int key)
{
// base case
if (root == NULL) return root;
// If the key to be deleted is smaller than the

// root's key, then it lies in left subtree
if (key < root->key)
// If the key to be deleted is greater than the root's key,

// then it lies in right subtree
else if (key > root->key)
// if key is same as root's key

else
{
// If key is present more than once, simply decrement
// count and return
if (root->count > 1)
{
(root->count)--;
return root;
}
// ElSE, delete the node
// node with only one child or no child

{
struct node *temp = root->right;
free(root);
return temp;
}
else if (root->right == NULL)
{
struct node *temp = root->left;
free(root);
return temp;
}
// node with two children: Get the inorder successor (smallest

// in the right subtree)
struct node* temp = minValueNode(root->right);
// Copy the inorder successor's content to this node

root->key = temp->key;
// Delete the inorder successor

root->right = deleteNode(root->right, temp->key);
}
return root;
}

int main()
{
{
12(3)
/ \
10(2) 20(1)
/ \
9(1) 11(1) */
printf("Inorder traversal of the given tree \n");

inorder(root);
printf("\nDelete 20\n");
printf("Inorder traversal of the modified tree \n");
inorder(root);
inorder(root);
inorder(root);
return 0;
}

Output:

9(1) 10(2) 11(1) 12(3) 20(1)
Delete 20
9(1) 10(2) 11(1) 12(3)
Delete 12
9(1) 10(2) 11(1) 12(2)
Delete 9
10(2) 11(1) 12(2)

We will soon be discussing AVL and Red Black Trees with duplicates allowed.
This article is contributed by Chirag. Please write comments if you find anything incorrect, or you want to
Online algorithm for checking palindrome in a stream
Given a stream of characters (characters are received one by one), write a function that prints ‘Yes’ if a
character makes the complete string palindrome, else prints ‘No’.
Examples:
Input: str[] = "abcba"

Output: a Yes // "a" is palindrome
b No // "ab" is not palindrome
c No // "abc" is palindrome
b No // "abcb" is not palindrome
a Yes // "abcba" is palindrome
Input: str[] = "aabaacaabaa"

Output: a Yes // "a" is palindrome
a Yes // "aa" is palindrome
b No // "aab" is not palindrome
a No // "aaba" is not palindrome
a Yes // "aabaa" is palindrome
c No // "aabaac" is not palindrome
a No // "aabaaca" is not palindrome
a No // "aabaacaa" is not palindrome
b No // "aabaacaab" is not palindrome
a No // "aabaacaaba" is not palindrome
a Yes // "aabaacaabaa" is palindrome

Let input string be str[0..n-1]. A Simple Solution is to do following for every character str[i] in input
string. Check if substring str[0…i] is palindrome, then print yes, else print no.
A Better Solution is to use the idea of Rolling Hash used in Rabin Karp algorithm. The idea is to keep track
of reverse of first half and second half (we also use first half and reverse of second half) for every index.

1) The first character is always a palindrome, so print yes for

first character.
2) Initialize reverse of first half as "a" and second half as "b".

Let the hash value of first half reverse be 'firstr' and that of
second half be 'second'.
3) Iterate through string starting from second character, do following

for every character str[i], i.e., i varies from 1 to n-1.
a) If 'firstr' and 'second' are same, then character by character
check the substring ending with current character and print
"Yes" if palindrome.
Note that if hash values match, then strings need not be same.
For example, hash values of "ab" and "ba" are same, but strings
are different. That is why we check complete string after hash.
b) Update 'firstr' and 'second' for next iteration.

If 'i' is even, then add next character to the beginning of
'firstr' and end of second half and update
hash values.
If 'i' is odd, then keep 'firstr' as it is, remove leading
character from second and append a next
character at end.

Let us see all steps for example string “abcba”
Initial values of ‘firstr’ and ‘second’

firstr’ = hash(“a”), ‘second’ = hash(“b”)
Start from second character, i.e.,

i = 1
a) Compare ‘firstr’ and ‘second’, they don’t match, so print no.
b) Calculate hash values for next iteration, i.e., i = 2
Since i is odd, ‘firstr’ is not changed and ‘second’ becomes hash(“c”)
i = 2
a) Compare ‘firstr’ and ‘second’, they don’t match, so print no.
Since i is even, ‘firstr’ becomes hash(“ba”) and ‘second’ becomes hash(“cb”)
i = 3
a) Compare ‘first’ and ‘second’, they don’t match, so print no.
Since i is odd, ‘firstr’ is not changed and ‘second’ becomes hash(“ba”)
i = 4
a) ‘firstr’ and ‘second’ match, compare the whole strings, they match, so print yes
b) We don’t need to calculate next hash values as this is last index
The idea of using rolling hashes is, next hash value can be calculated from previous in O(1) time by just doing
some constant number of arithmetic operations.
Below is C implementation of above approach.

// C program for online algorithm for palindrome checking
#include<stdio.h>
#include<string.h>
// d is the number of characters in input alphabet

#define d 256
// q is a prime number used for evaluating Rabin Karp's Rolling hash

#define q 103
void checkPalindromes(char str[])

{
// Length of input string
int N = strlen(str);
// A single character is always a palindrome

printf("%c Yes\n", str[0]);
// Return if string has only one character

if (N == 1) return;
// Initialize first half reverse and second half for

// as firstr and second characters
int firstr = str[0] % q;
int second = str[1] % q;
int h = 1, i, j;
// Now check for palindromes from second character

// onward
for (i=1; i<N; i++)
{
// If the hash values of 'firstr' and 'second'
// match, then only check individual characters
if (firstr == second)
{
/* Check if str[0..i] is palindrome using
simple character by character match */
for (j = 0; j < i/2; j++)
{
if (str[j] != str[i-j])
break;
}
(j == i/2)? printf("%c Yes\n", str[i]):
printf("%c No\n", str[i]);
}
else printf("%c No\n", str[i]);
// Calculate hash values for next iteration.

// Don't calculate hash for next characters if
// this is the last character of string
if (i != N-1)
{
// If i is even (next i is odd)
if (i%2 == 0)
{
// Add next character after first half at beginning
// of 'firstr'
h = (h*d) % q;
firstr = (firstr + h*str[i/2])%q;

// Add next character after second half at the end
// of second half.
second = (second*d + str[i+1])%q;
second = (second*d + str[i+1])%q;
}
else
{
// If next i is odd (next i is even) then we
// need not to change firstr, we need to remove
// first character of second and append a
// character to it.
second = (d*(second + q - str[(i+1)/2]*h)%q
+ str[i+1])%q;
}
}
}
}

int main()
{
char *txt = "aabaacaabaa";
checkPalindromes(txt);
getchar();
return 0;
}

Output:
a Yes
a Yes
b No
a No
a Yes
c No
a No
a No
b No
a No
a Yes

The worst case time complexity of the above solution remains O(n*n), but in general, it works much better
than simple approach as we avoid complete substring comparison most of the time by first comparing hash
values. The worst case occurs for input strings with all same characters like “aaaaaa”.
This article is contributed by Ajay. Please write comments if you find anything incorrect, or you want to
Why Quick Sort preferred for Arrays and Merge Sort for Linked Lists?
Why is Quick Sort preferred for arrays?
Below are recursive and iterative implementations of Quick Sort and Merge Sort for arrays.
Recursive Quick Sort for array.

Iterative Quick Sort for arrays.
Recursive Merge Sort for arrays
Iterative Merge Sort for arrays
Quick Sort in its general form is an in-place sort (i.e. it doesn’t require any extra storage) whereas merge sort
requires O(N) extra storage, N denoting the array size which may be quite expensive. Allocating and de-
allocating the extra space used for merge sort increases the running time of the algorithm. Comparing
average complexity we find that both type of sorts have O(NlogN) average complexity but the constants
differ. For arrays, merge sort loses due to the use of extra O(N) storage space.
Most practical implementations of Quick Sort use randomized version. The randomized version has
expected time complexity of O(nLogn). The worst case is possible in randomized version also, but worst case
doesn’t occur for a particular pattern (like sorted array) and randomized Quick Sort works well in practice.
Quick Sort is also a cache friendly sorting algorithm as it has good locality of reference when used for arrays.
Quick Sort is also tail recursive, therefore tail call optimizations is done.
Why is Merge Sort preferred for Linked Lists?

Below are implementations of Quicksort and Mergesort for singly and doubly linked lists.
Quick Sort for Doubly Linked List

Quick Sort for Singly Linked List
Merge Sort for Singly Linked List
Merge Sort for Doubly Linked List
In case of linked lists the case is different mainly due to difference in memory allocation of arrays and linked
lists. Unlike arrays, linked list nodes may not be adjacent in memory. Unlike array, in linked list, we can
insert items in the middle in O(1) extra space and O(1) time. Therefore merge operation of merge sort can be
implemented without extra space for linked lists.
In arrays, we can do random access as elements are continuous in memory. Let us say we have an integer (4-
byte) array A and let the address of A[0] be x then to access A[i], we can directly access the memory at (x +
i*4). Unlike arrays, we can not do random access in linked list. Quick Sort requires a lot of this kind of
access. In linked list to access i’th index, we have to travel each and every node from the head to i’th node as
we don’t have continuous block of memory. Therefore, the overhead increases for quick sort. Merge sort
accesses data sequentially and the need of random access is low.
Thanks to Sayan Mukhopadhyay for providing initial draft for above article. Please write comments if
Load Balancing on Servers (Random Algorithm)
Consider a high traffic website that receives millions of requests (of different types) per five minutes, the site
has k (for example n = 1000) servers to process the requests. How should the load be balanced among
servers?
The solutions that we generally think of are

a) Round Robin
b) Assign new request to a server that has minimum load.
Both of the above approaches look good, but they require additional state information to be maintained for
load balancing. Following is a simple approach that works better than above approaches.
Do following whenever a new request comes in,

Pick a random server and assign the request to a random server

The above approach is simpler, lightweight and surprisingly effective. This approach doesn’t calculate
existing load on server and doesn’t need time management.
Analysis of above Random Approach

Let us analyze the average load on a server when above approach of randomly picking server is used.
Let there be k request (or jobs) J1, J2, … Jk
Let there be n servers be S1, S2, … Sk.
Let time taken by i’th job be Ti
Let Rij be load on server Si from Job Jj.
Rij is Tj if j’th job (or J) is assigned to S, otherwise 0. Therefore, value of R

j i ij is Tj with probability 1/n and
value is 0 with probability (1-1/n)
Let Ri be load on i’th server
Average Load on i'th server 'Ex(Ri)'

[Applying Linearity of Expectation]
=
= (Total Load)/n

So average load on a server is total load divided by n which is a perfect result.
What is the possibility of deviation from average (A particular server gets too much load)?
The average load from above random assignment approach looks good, but there may be possibility that a
particular server becomes too loaded (even if the average is ok).
It turns out that the probability of deviation from average is also very low (can be proved using Chernoff
bound). Readers can refer below reference links for proves of deviations. For example, in MIT video lecture,
it is shown that if there are 2500 requests per unit time and there are 10 servers, then the probability that
any particular server gets 10% more load is at most 1/16000. Similar results are shown at the end of second
reference also.
So above simple load balancing scheme works perfect. In-fact this scheme is used in load balancers.
References:
http://www.cs.princeton.edu/courses/archive/fall09/cos521/Handouts/probabilityandcomputing.pdf
MIT Video Lecture
Find Itinerary from a given list of tickets
Given a list of tickets, find itinerary in order using the given list.
Example:
Input:
"Chennai" -> "Banglore"
"Bombay" -> "Delhi"
"Goa" -> "Chennai"
"Delhi" -> "Goa"
Output:
Bombay->Delhi, Delhi->Goa, Goa->Chennai, Chennai->Banglore,

It may be assumed that the input list of tickets is not cyclic and there is one ticket from every city except
final destination.
One Solution is to build a graph and do Topological Sorting of the graph. Time complexity of this solution is
O(n).
We can also use hashing to avoid building a graph. The idea is to first find the starting point. A starting point
would never be on ‘to’ side of a ticket. Once we find the starting point, we can simply traverse the given map
to print itinerary in order. Following are steps.
1) Create a HashMap of given pair of tickets. Let the created

HashMap be 'dataset'. Every entry of 'dataset' is of the form
"from->to" like "Chennai" -> "Banglore"
2) Find the starting point of itinerary.

a) Create a reverse HashMap. Let the reverse be 'reverseMap'
Entries of 'reverseMap' are of the form "to->form".
Following is 'reverseMap' for above example.
"Banglore"-> "Chennai"
"Delhi" -> "Bombay"
"Chennai" -> "Goa"
"Goa" -> "Delhi"

b) Traverse 'dataset'. For every key of dataset, check if it
is there in 'reverseMap'. If a key is not present, then we
found the starting point. In the above example, "Bombay" is
starting point.
3) Start from above found starting point and traverse the 'dataset'
to print itinerary.

All of the above steps require O(n) time so overall time complexity is O(n).
Below is Java implementation of above idea.

// Java program to print itinerary in order

public class printItinerary

{
// Driver function
{
Map<String, String> dataSet = new HashMap<String, String>();
dataSet.put("Chennai", "Banglore");
dataSet.put("Bombay", "Delhi");
dataSet.put("Goa", "Chennai");
dataSet.put("Delhi", "Goa");
printResult(dataSet);
}
// This function populates 'result' for given input 'dataset'

private static void printResult(Map<String, String> dataSet)
{
// To store reverse of given map
Map<String, String> reverseMap = new HashMap<String, String>();
// To fill reverse map, iterate through the given map

reverseMap.put(entry.getValue(), entry.getKey());
// Find the starting point of itinerary

String start = null;
{
if (!reverseMap.containsKey(entry.getKey()))
{
start = entry.getKey();
break;
}
}
// If we could not find a starting point, then something wrong

// with input
if (start == null)
{
System.out.println("Invalid Input");
return;
}
// Once we have starting point, we simple need to go next, next

// of next using given hash map
String to = dataSet.get(start);
while (to != null)
{
System.out.print(start + "->" + to + ", ");
start = to;
to = dataSet.get(to);
}
}
}

Output:
Bombay->Delhi, Delhi->Goa, Goa->Chennai, Chennai->Banglore,

This article is compiled by Rahul Jain. Please write comments if you find anything incorrect, or you want
Greedy Algorithms | Set 9 (Boruvka’s algorithm)
We have discussed following topics on Minimum Spanning Tree.
Applications of Minimum Spanning Tree Problem

Kruskal’s Minimum Spanning Tree Algorithm
Prim’s Minimum Spanning Tree Algorithm
In this post, Boruvka’s algorithm is discussed. Like Prim’s and Kruskal’s, Boruvka’s algorithm is also a
Greedy algorithm. Below is complete algorithm.
1) Input is a connected, weighted and directed graph.

2) Initialize all vertices as individual components (or sets).
3) Initialize MST as empty.
4) While there are more than one components, do following
for each component.
a) Find the closest weight edge that connects this
component to any other component.
b) Add this closest edge to MST if not already added.
5) Return MST.

Below is the idea behind above algorithm (The idea is same as Prim’s MST algorithm).
A spanning tree means all vertices must be connected. So the two disjoint subsets (discussed above) of
vertices must be connected to make a Spanning Tree. And they must be connected with the minimum
weight edge to make it a Minimum Spanning Tree.
Let us understand the algorithm with below example.
Initially MST is empty. Every vertex is singe component as highlighted in blue color in below diagram.

For every component, find the cheapest edge that connects it to some other component.

Component Cheapest Edge that connects

it to some other component
{0} 0-1
{1} 0-1
{2} 2-8
{3} 2-3
{4} 3-4
{5} 5-6
{6} 6-7
{7} 6-7
{8} 2-8

The cheapest edges are highlighted with green color. Now MST becomes {0-1, 2-8, 2-3, 3-4, 5-6, 6-7}.
After above step, components are {{0,1}, {2,3,4,8}, {5,6,7}}. The components are encircled with blue color.

We again repeat the step, i.e., for every component, find the cheapest edge that connects it to some other
component.
Component Cheapest Edge that connects

it to some other component
{0,1} 1-2 (or 0-7)
{2,3,4,8} 2-5
{5,6,7} 2-5

The cheapest edges are highlighted with green color. Now MST becomes {0-1, 2-8, 2-3, 3-4, 5-6, 6-7, 1-2, 2-
5}
At this stage, there is only one component {0, 1, 2, 3, 4, 5, 6, 7, 8} which has all edges. Since there is only one
component left, we stop and return MST.
Implementation:
Below is C++ implementation of above algorithm. The input graph is represented as a collection of edges
and union-find data structure is used to keep track of components.
// Boruvka's algorithm to find Minimum Spanning

// Tree of a given connected, undirected and
// weighted graph
#include <stdio.h>

struct Edge
{
};
// a structure to represent a connected, undirected

// and weighted graph as a collection of edges.
struct Graph
{
int V, E;

// Since the graph is undirected, the edge
// from src to dest is also edge from dest
Edge* edge;
};

struct subset
{
int parent;
int rank;
};
// Function prototypes for union-find (These functions are defined

// after boruvkaMST() )
int find(struct subset subsets[], int i);
void Union(struct subset subsets[], int x, int y);
// The main function for MST using Boruvka's algorithm

void boruvkaMST(struct Graph* graph)
{
// Get data of given graph
int V = graph->V, E = graph->E;
Edge *edge = graph->edge;
// Allocate memory for creating V subsets.

struct subset *subsets = new subset[V];
// An array to store index of the cheapest edge of

// subset. The stored index for indexing array 'edge[]'
int *cheapest = new int[V];

for (int v = 0; v < V; ++v)
{
cheapest[v] = -1;
}
// Initially there are V different trees.

// Finally there will be one tree that will be MST
int numTrees = V;
int MSTweight = 0;
// Keep combining components (or sets) until all

// compnentes are not combined into single MST.
while (numTrees > 1)
{
// Traverse through all edges and update
// cheapest of every component
for (int i=0; i<E; i++)
{
// Find components (or sets) of two corners
// of current edge
int set1 = find(subsets, edge[i].src);
int set2 = find(subsets, edge[i].dest);
// If two corners of current edge belong to

// same set, ignore current edge
if (set1 == set2)
continue;
// Else check if current edge is closer to previous

// cheapest edges of set1 and set2
else
{
if (cheapest[set1] == -1 ||
edge[cheapest[set1]].weight > edge[i].weight)
cheapest[set1] = i;
if (cheapest[set1] == -1 ||
edge[cheapest[set2]].weight > edge[i].weight)
cheapest[set2] = i;
}
}
// Consider the above picked cheapest edges and add them

// to MST
{
// Check if cheapest for current set exists
if (cheapest[i] != -1)
{
int set1 = find(subsets, edge[cheapest[i]].src);
int set2 = find(subsets, edge[cheapest[i]].dest);
if (set1 == set2)
continue;
MSTweight += edge[cheapest[i]].weight;
printf("Edge %d-%d included in MST\n",
edge[cheapest[i]].src, edge[cheapest[i]].dest,
edge[cheapest[i]].weight);
// Do a union of set1 and set2 and decrease number

// of trees
Union(subsets, set1, set2);
numTrees--;
}
}
}
printf("Weight of MST is %d\n", MSTweight);

return;
}

{
Graph* graph = new Graph;
graph->V = V;
graph->E = E;
graph->edge = new Edge[E];
return graph;
}

{
// find root and make root as parent of i
// (path compression)
subsets[i].parent =
find(subsets, subsets[i].parent);
}

{
// Attach smaller rank tree under root of high

// rank tree (Union by Rank)
// If ranks are same, then make one as root and

// increment its rank by one
else
{
}
}

int main()
{
/* Let us create following weighted graph
10
0--------1
| \ |
6| 5\ |15
| \ |
2--------3
4 */
// add edge 0-1

// add edge 0-2

// add edge 0-3

// add edge 1-3

// add edge 2-3

boruvkaMST(graph);
return 0;
}

Output:

Edge 0-3 included in MST
Weight of MST is 19

Interesting Facts about Boruvka’s algorithm:

1) Time Complexity of Boruvka’s algorithm is O(E log V) which is same as Kruskal’s and Prim’s algorithms.
2) Boruvka’s algorithm is used as a step in a faster randomized algorithm that works in linear time O(E).
3) Boruvka’s algorithm is the oldest minimum spanning tree algorithm was discovered by Boruuvka in 1926,
long before computers even existed. The algorithm was published as a method of constructing an efficient
electricity network.
Exercise:
The above code assumes that input graph is connected and it fails if a disconnected graph is given. Extend
the above algorithm so that it works for a disconnected graph also and produces a forest.
References:
http://en.wikipedia.org/wiki/Bor%C5%AFvka%27s_algorithm
discussed above
Karger’s algorithm for Minimum Cut | Set 1 (Introduction and
Implementation)
Given an undirected and unweighted graph, find the smallest cut (smallest number of edges that disconnects
the graph into two components).
The input graph may have parallel edges.
For example consider the following example, the smallest cut has 2 edges.
A Simple Solution use Max-Flow based s-t cut algorithm to find minimum cut. Consider every pair of vertices
as source ‘s’ and sink ‘t’, and call minimum s-t cut algorithm to find the s-t cut. Return minimum of all s-t
cuts. Best possible time complexity of this algorithm is O(V5) for a graph. [How? there are total possible V2
pairs and s-t cut algorithm for one pair takes O(V*E) time and E = O(V2)].
Below is simple Karger’s Algorithm for this purpose. Below Karger’s algorithm can be implemented in O(E)
= O(V2) time.
1) Initialize contracted graph CG as copy of original graph

2) While there are more than 2 vertices.
a) Pick a random edge (u, v) in the contracted graph.
b) Merge (or contract) u and v into a single vertex (update
the contracted graph).
c) Remove self-loops
3) Return cut represented by two vertices.

Let us understand above algorithm through the example given.
Let the first randomly picked vertex be ‘a‘ which connects vertices 0 and 1. We remove this edge and contract
the graph (combine vertices 0 and 1). We get the following graph.
Let the next randomly picked edge be ‘d’. We remove this edge and combine vertices (0,1) and 3.
We need to remove self-loops in the graph. So we remove edge ‘c’
Now graph has two vertices, so we stop. The number of edges in the resultant graph is the cut produced by
Karger’s algorithm.
Karger’s algorithm is a Monte Carlo algorithm and cut produced by it may not be
minimum. For example, the following diagram shows that a different order of picking random edges
produces a min-cut of size 3.
Below is C++ implementation of above algorithm. The input graph is represented as a collection of edges
and union-find data structure is used to keep track of components.
// Karger's algorithm to find Minimum Cut in an

// undirected, unweighted and connected graph.
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
// a structure to represent a unweighted edge in graph

struct Edge
{
int src, dest;
};
// a structure to represent a connected, undirected

// and unweighted graph as a collection of edges.
// and unweighted graph as a collection of edges.
struct Graph
{
int V, E;

// Since the graph is undirected, the edge
// from src to dest is also edge from dest
Edge* edge;
};

struct subset
{
int parent;
int rank;
};
// Function prototypes for union-find (These functions are defined

// after kargerMinCut() )
int find(struct subset subsets[], int i);
void Union(struct subset subsets[], int x, int y);
// A very basic implementation of Karger's randomized

// algorithm for finding the minimum cut. Please note
// that Karger's algorithm is a Monte Carlo Randomized algo
// and the cut returned by the algorithm may not be
// minimum always
int kargerMinCut(struct Graph* graph)
{
// Get data of given graph
int V = graph->V, E = graph->E;
Edge *edge = graph->edge;

struct subset *subsets = new subset[V];

for (int v = 0; v < V; ++v)
{
}
// Initially there are V vertices in

// contracted graph
int vertices = V;
// Keep contracting vertices until there are

// 2 vertices.
while (vertices > 2)
{
// Pick a random edge
int i = rand() % E;
// Find vertices (or sets) of two corners

// of current edge
int subset1 = find(subsets, edge[i].src);
int subset2 = find(subsets, edge[i].dest);
// If two corners belong to same subset,

// then no point considering this edge
if (subset1 == subset2)
if (subset1 == subset2)
continue;
// Else contract the edge (or combine the

// corners of edge into one vertex)
else
{
printf("Contracting edge %d-%d\n",
edge[i].src, edge[i].dest);
vertices--;
Union(subsets, subset1, subset2);
}
}
// Now we have two vertices (or subsets) left in

// the contracted graph, so count the edges between
// two components and return the count.
int cutedges = 0;
for (int i=0; i<E; i++)
{
int subset1 = find(subsets, edge[i].src);
int subset2 = find(subsets, edge[i].dest);
if (subset1 != subset2)
cutedges++;
}
return cutedges;
}

{
// find root and make root as parent of i
// (path compression)
subsets[i].parent =
find(subsets, subsets[i].parent);
}

{
// Attach smaller rank tree under root of high

// rank tree (Union by Rank)
// If ranks are same, then make one as root and

// increment its rank by one
else
{
}
}
{
Graph* graph = new Graph;
graph->V = V;
graph->E = E;
graph->edge = new Edge[E];
return graph;
}

int main()
{
/* Let us create following unweighted graph
0------1
| \ |
| \ |
| \|
2------3 */
// add edge 0-1

// add edge 0-2

// add edge 0-3

// add edge 1-3

// add edge 2-3


srand(time(NULL));
printf("\nCut found by Karger's randomized algo is %d\n",

kargerMinCut(graph));
return 0;
}
Output:

Contracting edge 0-2
Contracting edge 0-3
Cut found by Karger's randomized algo is 2

Note that the above program is based on outcome of a random function and may produce
different output.
In this post, we have discussed simple Karger’s algorithm and have seen that the algorithm doesn’t always
produce min-cut. The above algorithm produces min-cut with probability greater or equal to that 1/(n2). In
the next post, we will discuss proof of this and how repeated calls of Karger’s algorithm can improve this
probability. We will also discuss applications of Karger’s algorithm.
References:
http://en.wikipedia.org/wiki/Karger%27s_algorithm
https://www.youtube.com/watch?v=P0l8jMDQTEQ
https://www.cs.princeton.edu/courses/archive/fall13/cos521/lecnotes/lec2final.pdf
http://web.stanford.edu/class/archive/cs/cs161/cs161.1138/lectures/11/Small11.pdf
discussed above.
Find the largest pair sum in an unsorted array
Given an unsorted array, find the largest pair sum in it. For example, the largest pair sum in {12, 34, 10, 6,
40} is 74.

Expected Time Complexity: O(n) [Only one traversal of array is allowed]
This problem mainly boils down to finding the largest and second largest element in array. We can find the
largest and second largest in O(n) time by traversing array once.
1) Initialize both first and second largest

first = max(arr[0], arr[1])
second = min(arr[0], arr[1])
2) Loop through remaining elements (from 3rd to end)
a) If the current element is greater than first, then update first
and second.
b) Else if the current element is greater than second then update
second
3) Return (first + second)


// C++ program to find largest pair sum in a given array

#include<iostream>
/* Function to return largest pair sum. Assumes that

there are at-least two elements in arr[] */
int findLargestSumPair(int arr[], int n)
{
// Initialize first and second largest element
int first, second;
{
first = arr[0];
second = arr[1];
}
else
{
first = arr[1];
second = arr[0];
}
// Traverse remaining array and find first and second largest

// elements in overall array
for (int i = 2; i<n; i ++)
{
/* If current element is greater than first then update both
first and second */
if (arr[i] > first)
{
second = first;
first = arr[i];
}
/* If arr[i] is in between first and second then update second */

else if (arr[i] > second && arr[i] != first)
second = arr[i];
}
return (first + second);
}

int main()
{
int arr[] = {12, 34, 10, 6, 40};
cout << "Max Pair Sum is " << findLargestSumPair(arr, n);
return 0;
}

Output:

Max Pair Sum is 74

Time complexity of above solution is O(n).

Select a Random Node from a Singly Linked List
Given a singly linked list, select a random node from linked list (the probability of picking a node should be
1/N if there are N nodes in list). You are given a random number generator.
Below is a Simple Solution

1) Count number of nodes by traversing the list.
2) Traverse the list again and select every node with probability 1/N. The selection can be done by generating
a random number from 0 to N-i for i’th node, and selecting the i’th node node only if generated number is
equal to 0 (or any other fixed number from 0 to N-i).
We get uniform probabilities with above schemes.
i = 1, probability of selecting first node = 1/N

i = 2, probability of selecting second node =
[probability that first node is not selected] *
[probability that second node is selected]
= ((N-1)/N)* 1/(N-1)
= 1/N

Similarly, probabilities of other selecting other nodes is 1/N
The above solution requires two traversals of linked list.
How to select a random node with only one traversal allowed?

The idea is to use Reservoir Sampling. Following are the steps. This is a simpler version of Reservoir
Sampling as we need to select only one key instead of k keys.
(1) Initialize result as first node

result = head->key
(2) Initialize n = 2
(3) Now one by one consider all nodes from 2nd node onward.
(3.a) Generate a random number from 0 to n-1.
Let the generated random number is j.
(3.b) If j is equal to 0 (we could choose other fixed number
between 0 to n-1), then replace result with current node.
(3.c) n = n+1
(3.d) current = current->next

/* C program to randomly select a node from a singly

linked list */
#include<stdio.h>
#include<stdlib.h>
#include <time.h>

struct node
{
int key;
struct node* next;
};
// A reservoir sampling based function to print a

// random node from a linked list
void printRandom(struct node *head)
{
// IF list is empty
if (head == NULL)
return;
// Use a different seed value so that we don't get

// same result each time we run this program
srand(time(NULL));
// Initialize result as first node

int result = head->key;
// Iterate from the (k+1)th element to nth element

struct node *current = head;
int n;
for (n=2; current!=NULL; n++)
{
// change result with probability 1/n
if (rand() % n == 0)
result = current->key;
// Move to next node

}
printf("Randomly selected key is %d\n", result);

}
/* BELOW FUNCTIONS ARE JUST UTILITY TO TEST */
/* A utility function to create a new node */

struct node *newNode(int new_key)
{
/* allocate node */
/* put in the key */

new_node->key = new_key;
return new_node;
}
/* A utility function to insert a node at the beginning

of linked list */
void push(struct node** head_ref, int new_key)
{
/* allocate node */
struct node* new_node = new node;
/* put in the key */

new_node->key = new_key;

}

int main()
{
push(&head, 5);
push(&head, 20);
push(&head, 4);
push(&head, 3);
push(&head, 30);
printRandom(head);
return 0;
}

Randomly selected key is 4

Note that the above program is based on outcome of a random function and may produce different output.
How does this work?

Let there be total N nodes in list. It is easier to understand from last node.
The probability that last node is result simply 1/N [For last or N’th node, we generate a random number
between 0 to N-1 and make last node as result if the generated number is 0 (or any other fixed number]
The probability that second last node is result should also be 1/N.
The probability that the second last node is result

= [Probability that the second last node replaces result] X
[Probability that the last node doesn't replace the result]
= [1 / (N-1)] * [(N-1)/N]
= 1/N

Similarly we can show probability for 3rd last node and other nodes.
Calculate 7n/8 without using division and multiplication operators
Given an integer, write a function that calculates 7n/8 (ceiling of 7n/8) without using division and
multiplication operators.
The idea is to first calculate floor of n/8, i.e., n/8 using right shift bitwise operator. The expression
n>>3 produces the same.
If we subtract n/8 from n, we get 7n/8
Below is C program based on above idea.
// C program to evaluate ceil(7n/8) without using * and /

#include<stdio.h>
int multiplyBySevenByEight(unsigned int n)

{
/* Note the inner bracket here. This is needed
because precedence of '-' operator is higher
than '<<' */
return (n - (n>>3));
}

int main()
{
unsigned int n = 9;
printf("%u", multiplyBySevenByEight(n));
return 0;
}

Output:
Data Structure for a single resource reservations
Design a data structure to do reservations of future jobs on a single machine under following constraints.
1) Every job requires exactly k time units of the machine.
2) The machine can do only one job at a time.
3) Time is part of the system. Future Jobs keep coming at different times. Reservation of a future job is done
only if there is no existing reservation within k time frame (after and before)
4) Whenever a job finishes (or its reservation time plus k becomes equal to current time), it is removed from
system.
Example:
Let time taken by a job (or k) be = 4
At time 0: Reservation request for a job at time 2 in

future comes in, reservation is done as machine
will be available (no conflicting reservations)
Reservations {2}
At time 3: Reservation requests at times 15, 7, 20 and 3.

Job at 7, 15 and 20 can be reserved, but at 3
cannot be reserved as it conflicts with a
reserved at 2.
Reservations {2, 7, 15, 20}
At time 6: Reservation requests at times 30, 17, 35 and 45

Jobs at 30, 35 and 45 are reserved, but at 17
cannot be reserved as it conflicts with a reserved
at 15.
Reservations {7, 15, 30, 35, 45}.
Note that job at 2 is removed as it must be finished by 6.

Let us consider different data structures for this task.
One solution is to keep all future reservations sorted in array. Time complexity of checking for conflicts can
be done in O(Logn) using Binary Search, but insertions and deletions take O(n) time.
Hashing cannot be used here as the search is not exact search, but a search within k time frame.
The idea is to use Binary Search Tree to maintain set of reserved jobs. For every reservation request, insert it
only when there is no conflicting reservation. While inserting job, do “within k time frame check”. If there is
a k distant node on insertion path from root, then reject the reservation request, otherwise do the
reservation.

// A BST node to store future reservations

struct node
{
int time; // reservation time
};

{
struct node *temp =
temp->time = item;
return temp;
}
/* BST insert to process a new reservation request at

a given time (future time). This function does
reservation only if there is no existing job within
k time frame of new job */
struct node* insert(struct node* root, int time, int k)
{
if (root == NULL) return newNode(time);
// Check if this job conflicts with existing

// reservations
if ((time-k < root->time) && (time+k > root->time))
return root;

if (time < root->time)
root->left = insert(root->left, time, k);
else
root->right = insert(root->right, time, k);

return root;
}

Deletion of job is simple BST delete operation.
A normal BST takes O(h) time for insert and delete operations. We can use self-balancing binary search trees
like AVL, Red-Black, .. to do both operations in O(Log n) time.
This question is adopted from this MIT lecture.
How to efficiently sort a big list dates in 20’s
Given a big list of dates in 20’s, how to efficiently sort the list.
Example:
Input:
Date arr[] = {{20, 1, 2014},
{25, 3, 2010},
{ 3, 12, 2000},
{18, 11, 2001},
{19, 4, 2015},
{ 9, 7, 2005}}
Output:
Date arr[] = {{ 3, 12, 2000},
{18, 11, 2001},
{ 9, 7, 2005},
{25, 3, 2010},
{20, 1, 2014},
{19, 4, 2015}}

A Simple Solution is to use a O(nLogn) algorithm like Merge Sort. We can sort the list in O(n) time using
Radix Sort. In a typical Radix Sort implementation, we first sort by last digit, then by second last digit, and so
on. Here we sort in following order.
1) First sort by day using counting sort
2) Then sort by month using counting sort
3) Finally sort by year using counting sort
As the number of days, months and years are fixed, all three steps take O(n) time. Therefore, overall time
complexity is O(n).
Below is C implementation of above idea. Note that the implementation doesn’t do any error handing to
keep the code simple.
// C program to sort an array of dates using Radix Sort

#include <stdio.h>
struct Date
{
int d, m, y;
};
// Prototypes
void countSortDay(Date arr[], int n);
void countSortMonth(Date arr[], int n);
void countSortYear(Date arr[], int n);
// The main function that sorts array of dates

// using Radix Sort
void radixSortDates(Date arr[], int n)
{
// First sort by day
countSortDay(arr, n);
// Then by month
countSortMonth(arr, n);
// Finally by year
countSortYear(arr, n);
}

// day
void countSortDay(Date arr[], int n)
{
Date output[n]; // output array
int i, count[31] = {0};

for (i=0; i<n; i++)
count[arr[i].d - 1]++;
// Change count[i] so that count[i] now contains

// actual position of this day in output[]
for (i=1; i<31; i++)

for (i=n-1; i>=0; i--)
{
output[count[arr[i].d - 1] - 1] = arr[i];
count[arr[i].d - 1]--;
}

for (i=0; i<n; i++)
arr[i] = output[i];
}

// month.
void countSortMonth(Date arr[], int n)
{
int i, count[12] = {0};
for (i = 0; i < n; i++)

count[arr[i].m - 1]++;
for (i = 1; i < 12; i++)
for (i=n-1; i>=0; i--)
{
output[count[arr[i].m - 1] - 1] = arr[i];
count[arr[i].m - 1]--;
}
for (i = 0; i < n; i++)
arr[i] = output[i];
}

// year.
void countSortYear(Date arr[], int n)
{
int i, count[1000] = {0};
for (i = 0; i < n; i++)
count[arr[i].y - 2000]++;
count[arr[i].y - 2000]++;
for (i = 1; i < 1000; i++)
for (i = n - 1; i >= 0; i--)
{
output[count[arr[i].y - 2000] - 1] = arr[i];
count[arr[i].y - 2000]--;
}
for (i = 0; i < n; i++)
arr[i] = output[i];
}

void print(Date arr[], int n)
{
int i;
for (i=0; i<n; i++)
printf("{%2d, %2d, %d}\n",
arr[i].d, arr[i].m, arr[i].y);
}

int main()
{
Date arr[] = {{20, 1, 2014}, {25, 3, 2010},
{3, 12, 2000}, {18, 11, 2001},
{19, 4, 2015}, {9, 7, 2005}};
printf("Input Dates\n");
print(arr, n);
radixSortDates(arr, n);
printf("\nSorted Dates\n");
print(arr, n);
return 0;
}

Output:
Input Dates
{20, 1, 2014}
{25, 3, 2010}
{ 3, 12, 2000}
{18, 11, 2001}
{19, 4, 2015}
{ 9, 7, 2005}
Sorted Dates
{ 3, 12, 2000}
{18, 11, 2001}
{ 9, 7, 2005}
{25, 3, 2010}
{20, 1, 2014}
{19, 4, 2015}

Basic and Extended Euclidean algorithms
Basic Euclidean Algorithm is used to find GCD of two numbers say a and b. Below is a recursive C
function to evaluate gcd using Euclid’s algorithm.
// C program to demonstrate Basic Euclidean Algorithm

#include <stdio.h>
// Function to return gcd of a and b

int gcd(int a, int b)
{
if (a == 0)
return b;
return gcd(b%a, a);
}

int main()
{
int a = 10, b = 15;
printf("GCD(%d, %d) = %d\n", a, b, gcd(a, b));
a = 35, b = 10;
a = 31, b = 2;
return 0;
}

Output:

GCD(10, 15) = 5
GCD(35, 10) = 5
GCD(31, 2) = 1

Extended Euclidean Algorithm:
Extended Euclidean algorithm also finds integer coefficients x and y such that:
ax + by = gcd(a, b)

Examples:

Input: a = 30, b = 20
Output: gcd = 10
x = 1, y = -1
(Note that 30*1 + 20*(-1) = 10)
Input: a = 35, b = 15
Output: gcd = 5
x = 1, y = -2
(Note that 10*0 + 5*1 = 5)

The extended Euclidean algorithm updates results of gcd(a, b) using the results calculated by recursive call
gcd(b%a, a). Let values of x and y calculated by the recursive call be x1 and y1. x and y are updated using
below expressions.
x = y1 - ⌊b/a⌋ * x 1
y = x1
Below is C implementation based on above formulas.

// C program to demonstrate working of extended

// Euclidean Algorithm
#include <stdio.h>
// C function for extended Euclidean Algorithm

int gcdExtended(int a, int b, int *x, int *y)
{
// Base Case
if (a == 0)
{
*x = 0;
*y = 1;
return b;
}
int x1, y1; // To store results of recursive call

int gcd = gcdExtended(b%a, a, &x1, &y1);
// Update x and y using results of recursive

// call
*x = y1 - (b/a) * x1;
*y = x1;
return gcd;
}
// Driver Program
int main()
{
int x, y;
int a = 35, b = 15;
int g = gcdExtended(a, b, &x, &y);
printf("gcd(%d, %d) = %d, x = %d, y = %d",
a, b, g, x, y);
return 0;
}

Output:

gcd(35, 15) = 5, x = 1, y = -2

How does Extended Algorithm Work?

As seen above, x and y are results for inputs a and b,

a.x + b.y = gcd ----(1)
And x1 and y1 are results for inputs b%a and a

(b%a).x1 + a.y1 = gcd

When we put b%a = (b - (⌊b/a⌋).a) in above,
we get following. Note that ⌊b/a⌋ is floor(a/b)
(b - (⌊b/a⌋).a).x1 + a.y1 = gcd
Above equation can also be written as below

b.x1 + a.(y 1 - (⌊b/a⌋).x 1) = gcd ---(2)
After comparing coefficients of 'a' and 'b' in (1) and

(2), we get following
x = y1 - ⌊b/a⌋ * x 1
y = x1

How is Extended Algorithm Useful?
The extended Euclidean algorithm is particularly useful when a and b are coprime (or gcd is 1). Since x is the
modular multiplicative inverse of “a modulo b”, and y is the modular multiplicative inverse of “b modulo a”.
In particular, the computation of the modular multiplicative inverse is an essential step in RSA public-key
encryption method.
References:
http://e-maxx.ru/algo/extended_euclid_algorithm
http://en.wikipedia.org/wiki/Euclidean_algorithm
http://en.wikipedia.org/wiki/Extended_Euclidean_algorithm
This article is contributed by Ankur. Please write comments if you find anything incorrect, or you want to
MakeMyTrip Interview Questions | Set 6
Please refer to the following questions being asked at Make My Trip.
1. Write a program to calculate the value of 7n/9 without using multiplication and division operator.
2. Write a program to find out the number being deleted from the array.
3. Write a program to check the validity of { and } used in program for string as {{{{{}}}}, {{{{{, }}}}{.
Geeks
Given p and n, find the largest x such that p^x divides n!
x
Given an integer n and a prime number p, find the largest x such that p (p raised to power x) divides n!
(factorial)
Examples:
Input: n = 7, p = 3
Output: x = 2
32 divides 7! and 2 is the largest such power of 3.
Input: n = 10, p = 3
Output: x = 4
34 divides 10! and 4 is the largest such power of 3.

n! is multiplication of {1, 2, 3, 4, …n}.
How many numbers in {1, 2, 3, 4, ….. n} are divisible by p?

Every p’th number is divisible by p in {1, 2, 3, 4, ….. n}. Therefore in n!, there are n/p numbers divisible
by p. So we know that the value of x (largest power of p that divides n!) is at-least n/p.

Can x be larger than n/p ?
Yes, there may be numbers which are divisible by p2, p3, …

2 3, …?
How many numbers in {1, 2, 3, 4, ….. n} are divisible by p, p
2 2 2
There are n/(p ) numbers divisible by p (Every p ‘th number would be divisible). Similarly, there are
n/(p3) numbers divisible by p3 and so on.

What is the largest possible value of x?
So the largest possible power is n/p + n/(p 2) + n/(p3) + ……
Note that we add only n/(p2) only once (not twice) as one p is already considered by expression
n/p. Similarly, we consider n/(p3) (not thrice).
Following is C implementation based on above idea.

// C program to find largest x such that p*x divides n!

#include <stdio.h>
// Returns largest power of p that divides n!

int largestPower(int n, int p)
{
int x = 0;
// Calculate x = n/p + n/(p^2) + n/(p^3) + ....

while (n)
{
n /= p;
x += n;
}
return x;
}
// Driver program
int main()
{
int n = 10, p = 3;
printf("The largest power of %d that divides %d! is %d\n",
p, n, largestPower(n, p));
return 0;
}

Output:

The largest power of 3 that divides 10! is 4

Time complexity of the above solution is Logpn.
Source:
http://e-maxx.ru/algo/factorial_divisors
Euler’s Totient Function
Euler’s Totient function Φ(n) for an input n is count of numbers in {1, 2, 3, …, n} that are relatively prime to
n, i.e., the numbers whose GCD (Greatest Common Divisor) with n is 1.
Examples:
Φ(1) = 1
gcd(1, 1) is 1
Φ(2) = 1
gcd(1, 2) is 1, but gcd(2, 2) is 2.
Φ(3) = 2
gcd(1, 3) is 1 and gcd(2, 3) is 1
Φ(4) = 2
gcd(1, 4) is 1 and gcd(3, 4) is 1
Φ(5) = 4
gcd(1, 5) is 1, gcd(2, 5) is 1,
gcd(3, 5) is 1 and gcd(4, 5) is 1
Φ(6) = 2
gcd(1, 6) is 1 and gcd(5, 6) is 1,

How to compute Φ(n) for an input n?
A simple solution is to iterate through all numbers from 1 to n-1 and count numbers with gcd with n as 1.
Below is C implementation of the simple method to compute Euler’s Totient function for an input integer n.

// A simple C program to calculate Euler's Totient Function

#include <stdio.h>

{
if (a == 0)
return b;
return gcd(b%a, a);
}
// A simple method to evaluate Euler Totient Function

int phi(unsigned int n)
{
unsigned int result = 1;
if (gcd(i, n) == 1)
result++;
return result;
}

int main()
{
int n;
for (n=1; n<=10; n++)
printf("phi(%d) = %d\n", n, phi(n));
return 0;
}

Output:

phi(1) = 1
phi(2) = 1
phi(3) = 2
phi(4) = 2
phi(5) = 4
phi(6) = 2
phi(7) = 6
phi(8) = 4
phi(9) = 6
phi(10) = 4

The above code calls gcd function O(n) times. Time complexity of the gcd function is O(h) where h is number
of digits in smaller number of given two numbers. Therefore, an upper bound on time complexity of above
solution is O(nLogn) [How? there can be at most Log10n digits in all numbers from 1 to n]
Below is a Better Solution. The idea is based on Euler’s product formula which states that value of totient
functions is below product over all prime factors p of n.
We can find all prime factors using the idea used in this post.
Below is C implementation of Euler’s product formula.
// C program to calculate Euler's Totient Function

// using Euler's product formula
#include <stdio.h>
int phi(int n)
{
float result = n; // Initialize result as n
// Consider all prime factors of n and for every prime

// factor p, multiply result with (1 - 1/p)
for (int p=2; p*p<=n; ++p)
{
// Check if i is a prime factor.
if (n % p == 0)
{
// If yes, then update n and result
while (n % p == 0)
n /= p;
result *= (1 - (1 / (float) p));
}
}
// If n has a prime factor greater than sqrt(n)

// (There can be at-most one such prime factor)
if (n > 1)
result *= (1 - (1 / (float) n));
return (int)result;
}

int main()
{
int n;
for (n=1; n<=10; n++)
return 0;
}

Output:

phi(1) = 1
phi(2) = 1
phi(3) = 2
phi(4) = 2
phi(5) = 4
phi(6) = 2
phi(7) = 6
phi(8) = 4
phi(9) = 6
phi(10) = 4

We can avoid floating point calculations in above method. The idea is to count all prime factors and their
multiples and subtract this count from n to get the totient function value (Prime factors and multiples of
prime factors won’t have gcd as 1)
1) Initialize result as n
2) Consider every number 'p' (where 'p' varies from 2 to √n).
If p divides n, then do following
a) Subtract all multiples of p from 1 to n [all multiples of p
will have gcd more than 1 (at least p) with n]
b) Update n by repeatedly dividing it by p.
3) If the reduced n is more than 1, then remove all multiples
of n from result.

// C program to calculate Euler's Totient Function

#include <stdio.h>
int phi(int n)
{
int result = n; // Initialize result as n
// Consider all prime factors of n and subtract their

// multiples from result
for (int p=2; p*p<=n; ++p)
{
// Check if i is a prime factor.
if (n % p == 0)
{
// If yes, then update n and result
while (n % p == 0)
n /= p;
result -= result / p;
}
}
// If n has a prime factor greater than sqrt(n)

// (There can be at-most one such prime factor)
if (n > 1)
result -= result / n;
return result;
}

int main()
{
int n;
for (n=1; n<=10; n++)
return 0;
}

Output:

phi(1) = 1
phi(2) = 1
phi(3) = 2
phi(4) = 2
phi(5) = 4
phi(6) = 2
phi(7) = 6
phi(8) = 4
phi(9) = 6
phi(10) = 4

Let us take an example to understand the above algorithm.
n = 10.
Initialize: result = 10
2 is a prime factor, so n = n/i = 5, result = 5

3 is not a prime factor.
The for loop stops after 3 as 4*4 is not less than or equal
to 10.
After for loop, result = 5, n = 5

Since n > 1, result = result - n/result = 4

Some Interesting Properties of Euler’s Totient Function

1) For a prime number p, Φ(p) is p-1. For example Φ(5) is 4, Φ(7) is 6 and Φ(13) is 12. This is obvious, gcd of
all numbers from 1 to p-1 will be 1 because p is a prime.
2) For two numbers a and b, if gcd(a, b) is 1, then Φ(ab) = Φ(a) * Φ(b). For example Φ(5) is 4 and Φ(6) is 2,
so Φ(30) must be 8 as 5 and 6 are relatively prime.
3) For any two prime numbers p and q, Φ(pq) = (p-1)*(q-1). This property is used in RSA algorithm.
4) If p is a prime number, then Φ(pk) = pk – pk-1. This can be proved using Euler’s product formula.
5) Sum of values of totient functions of all divisors of n is equal to n.
For example, n = 6, the divisors of n are 1, 2, 3 and 6. According to Gauss, sum of Φ(1) + Φ(2) + Φ(3) + Φ(6)
should be 6. We can verify the same by putting values, we get (1 + 1 + 2 + 2) = 6.
6) The most famous and important feature is expressed in Euler’s theorem :

The theorem states that if n and a are coprime

(or relatively prime) positive integers, then
aΦ(n) ≡ 1 (mod n)

The RSA cryptosystem is based on this theorem:
In the particular case when m is prime say p, Euler’s theorem turns into the so-called Fermat’s little
theorem :
ap-1 ≡ 1 (mod p)

References:
http://e-maxx.ru/algo/euler_function
http://en.wikipedia.org/wiki/Euler%27s_totient_function
Print all distinct permutations of a given string with duplicates
Given a string that may contain duplicates, write a function to print all permutations of given string such that
no permutation is repeated in output.
Examples:
Input: str[] = "AB"

Output: AB BA
Input: str[] = "AA"

Output: AA
Input: str[] = "ABC"

Output: ABC ACB BAC BCA CBA CAB
Input: str[] = "ABA"

Output: ABA AAB BAA
Input: str[] = "ABCA"

Output: AABC AACB ABAC ABCA ACBA ACAB BAAC BACA
BCAA CABA CAAB CBAA

We have discussed an algorithm to print all permutations in below post. It is strongly recommended to refer
below post as a prerequisite of this post.
Write a C program to print all permutations of a given string
The algorithm discussed on above link doesn’t handle duplicates.
// Program to print all permutations of a string in sorted order.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

http://w...content-available-to-author-only...s.com/reference/clibrary/cstdlib/qsort/
*/
int compare(const void *a, const void * b)
{
return ( *(char *)a - *(char *)b );
}
// A utility function two swap two characters a and b

void swap(char* a, char* b)
{
char t = *a;
*a = *b;
*b = t;
}
// This function finds the index of the smallest character

// which is greater than 'first' and is present in str[l..h]
int findCeil(char str[], char first, int l, int h)
{
// initialize index of ceiling element
int ceilIndex = l;
int ceilIndex = l;
// Now iterate through rest of the elements and find

// the smallest character greater than 'first'
for (int i = l+1; i <= h; i++)
if (str[i] > first && str[i] < str[ceilIndex])
ceilIndex = i;
return ceilIndex;
}

void sortedPermutations(char str[])
{

qsort(str, size, sizeof( str[0] ), compare);

while (!isFinished)
{
static int x = 1;
printf("%d %s \n", x++, str);

int i;
for (i = size - 2; i >= 0; --i)
break;

if (i == -1)
isFinished = true;
else
{
int ceilIndex = findCeil(str, str[i], i + 1, size - 1);

swap(&str[i], &str[ceilIndex]);
// Sort the string on right of 'first char'

qsort(str + i + 1, size - i - 1, sizeof(str[0]), compare);
}
}
}

int main()
{
char str[] = "ACBC";
sortedPermutations( str );
return 0;
}

Output:
Output:

1 ABCC
2 ACBC
3 ACCB
4 BACC
5 BCAC
6 BCCA
7 CABC
8 CACB
9 CBAC
10 CBCA
11 CCAB
12 CCBA

The above code is taken from a comment below by Mr. Lazy.
Time Complexity: O(n2 * n!)

discussed above
Sort an almost sorted array where only two elements are swapped
Given an almost sorted array where only two elements are swapped, how to sort the array efficiently?
Example
Input: arr[] = {10, 20, 60, 40, 50, 30}

// 30 and 60 are swapped
Output: arr[] = {10, 20, 30, 40, 50, 60}
Input: arr[] = {10, 20, 40, 30, 50, 60}

Output: arr[] = {10, 20, 30, 40, 50, 60}
Input: arr[] = {1, 5, 3}

Output: arr[] = {1, 3, 5}

Expected time complexity is O(n) and only one swap operation to fix the array.
The idea is to traverse from rightmost side and find the first out of order element (element which is smaller
than previous element). Once first element is found, find the other our of order element by traversing the
array toward left side.

// C program to sort using one swap

#include<iostream>
#include<algorithm>
// This function sorts an array that can be sorted

// by single swap
void sortByOneSwap(int arr[], int n)
{
// Travers the given array from rightmost side
for (int i = n-1; i > 0; i--)
{
// Check if arr[i] is not in order
if (arr[i] < arr[i-1])
{
// Find the other element to be
// swapped with arr[i]
int j = i-1;
while (j>=0 && arr[i] < arr[j])
j--;
// Swap the pair

swap(arr[i], arr[j+1]);
break;
}
}
}
// A utility function ot print an array of size n

{
int i;
for (i=0; i < n; i++)
cout << arr[i] << " ";
cout << endl;
}

int main()
{
int arr[] = {10, 30, 20, 40, 50, 60, 70};

printArray(arr, n);
sortByOneSwap(arr, n);

printArray(arr, n);
return 0;
}

Output:

Given array is
10 30 20 40 50 60 70
Sorted array is
10 20 30 40 50 60 70

The above program works in O(n) time and swaps only one element.
Source: http://qa.geeksforgeeks.org/index.php?qa=24&qa_1=two-elements-sorted-array-are-swapped-
how-sort-the-array-again
discussed above
Find the nearest smaller numbers on left side in an array
Given an array of integers, find the nearest smaller number for every element such that the smaller element
is on left side.
Examples:
Input: arr[] = {1, 6, 4, 10, 2, 5}

Output: {_, 1, 1, 4, 1, 2}
First element ('1') has no element on left side. For 6,
there is only one smaller element on left side '1'.
For 10, there are three smaller elements on left side (1,
6 and 4), nearest among the three elements is 4.
Input: arr[] = {1, 3, 0, 2, 5}

Output: {_, 1, _, 0, 2}

We strongly recommend you to minimize your browser and try this yourself first.
A Simple Solution is to use two nested loops. The outer loop starts from second element, the inner loop
goes to all elements on left side of the element picked by outer loop and stops as soon as it finds a smaller
element.

// C++ implementation of simple algorithm to find

// smaller element on left side
#include <iostream>
// Prints smaller elements on left side of every element

void printPrevSmaller(int arr[], int n)
{
// Always print empty or '_' for first element
cout << "_, ";
// Start from second element

{
// look for smaller element on left of 'i'
int j;
for (j=i-1; j>=0; j--)
{
if (arr[j] < arr[i])
{
cout << arr[j] << ", ";
break;
}
}
// If there is no smaller element on left of 'i'

if (j == -1)
cout << "_, " ;
}
}

int main()
{
int arr[] = {1, 3, 0, 2, 5};
printPrevSmaller(arr, n);
return 0;
}

Output:

_, 3, _, 2, 5,

Time complexity of the above solution is O(n2).

There can be an Efficient Solution that works in O(n) time. The idea is to use a stack. Stack is used to
maintain a subsequence of the values that have been processed so far and are smaller than any later value
that has already been processed.
Below is stack based algorithm

Let input sequence be 'arr[]' and size of array be 'n'
1) Create a new empty stack S
2) For every element 'arr[i]' in the input sequence 'arr[]',

where 'i' goes from 0 to n-1.
a) while S is nonempty and the top element of
S is greater than or equal to 'arr[i]':
pop S

b) if S is empty:
'arr[i]' has no preceding smaller value
c) else:
the nearest smaller value to 'arr[i]' is
the top element of S
d) push 'arr[i]' onto S


// C++ implementation of simple algorithm to find

// smaller element on left side
#include <iostream>
#include <stack>
// Prints smaller elements on left side of every element

void printPrevSmaller(int arr[], int n)
{
// Create an empty stack
stack<int> S;
// Traverse all array elements

{
// Keep removing top element from S while the top
// element is greater than or equal to arr[i]
while (!S.empty() && S.top() >= arr[i])
S.pop();
// If all elements in S were greater than arr[i]

if (S.empty())
cout << "_, ";
else //Else print the nearest smaller element
cout << S.top() << ", ";
// Push this element

S.push(arr[i]);
}
}

int main()
{
int arr[] = {1, 3, 0, 2, 5};
printPrevSmaller(arr, n);
return 0;
}

Output:

_, 1, _, 0, 2,

Time complexity of above program is O(n) as every element is pushed and popped at most once to the stack.
So overall constant number of operations are performed per element.
This article is contributed by Ashish Kumar Singh. Please write comments if you find the above
codes/algorithms incorrect, or find other ways to solve the same problem.
Steiner Tree Problem
What is Steiner Tree?
Given a graph and a subset of vertices in the graph, a steiner tree spans though the given subset. The
Steiner Tree may contain some vertices which are not in given subset but are used to connect the vertices of
subset.
The given set of vertices is called Terminal Vertices and other vertices that are used to construct Steiner
tree are called Steiner vertices.
The Steiner Tree Problem is to find the minimum cost Steiner Tree. See below for an example.
Spanning Tree vs Steiner Tree

Minimum Spanning Tree is a minimum weight tree that spans through all vertices.
If given subset (or terminal) vertices is equal to set of all vertices in Steiner Tree problem, then the problem
becomes Minimum Spanning Tree problem. And if the given subset contains only two vertices, then it
shortest path problem between two vertices.
Finding out Minimum Spanning Tree is polynomial time solvable, but Minimum Steiner Tree problem is NP
Hard and related decision problem is NP-Complete.
Applications of Steiner Tree

Any situation where the task is minimize cost of connection among some important locations like VLSI
Design, Computer Networks, etc.
Shortest Path based Approximate Algorithm

Since Steiner Tree problem is NP-Hard, there are no polynomial time solutions that always give optimal
cost. Therefore, there are approximate algorithms to solve the same. Below is one simple approximate
algorithm.

1) Start with a subtree T consisting of

one given terminal vertex
2) While T does not span all terminals
a) Select a terminal x not in T that is closest
to a vertex in T.
b) Add to T the shortest path that connects x with T

The above algorithm is (2-2/n) approximate, i.e., it guarantees that solution produced by this algorithm is
not more than this ration of optimized solution for a given graph with n vertices. There are better algorithms
also that provide better ratio. Refer below reference for more details.
References:
www.cs.uu.nl/docs/vakken/an/teoud/an-steiner.ppt
Remove spaces from a given string
Given a string, remove all spaces from the string and return it.
Input: "g eeks for ge eeks "

Output: "geeksforgeeks"

Expected time complexity is O(n) and only one traversal of string.
Below is a Simple Solution
1) Iterate through all characters of given string, do following

a) If current character is a space, then move all subsequent
characters one position back and decrease length of the
result string.

Time complexity of above solution is O(n2).
A Better Solution can solve it in O(n) time. The idea is to keep track of count of non-space character seen
so far.
1) Initialize 'count' = 0 (Count of non-space character seen so far)

2) Iterate through all characters of given string, do following
a) If current character is non-space, then put this character
at index 'count' and increment 'count'
3) Finally, put '\0' at index 'count'


// An efficient C++ program to remove all spaces

// from a string
#include <iostream>
// Function to remove all spaces from a given string

void removeSpaces(char *str)
{
// To keep track of non-space character count
int count = 0;
// Traverse the given string. If current character

// is not space, then place it at index 'count++'
for (int i = 0; str[i]; i++)
if (str[i] != ' ')
str[count++] = str[i]; // here count is
// incremented
str[count] = '\0';
}

int main()
{
char str[] = "g eeks for ge eeks ";
removeSpaces(str);
cout << str;
return 0;
}

Output:

geeksforgeeeks

Time complexity of above solution is O(n) and it does only one traversal of string.
Thanks to Souravi Sarkar for suggesting this problem and initial solution. Please write comments if you find
Modular multiplicative inverse
Given two integers ‘a’ and ‘m’, find modular multiplicative inverse of ‘a’ under modulo ‘m’.
The modular multiplicative inverse is an integer ‘x’ such that.

a x ≡ 1 (mod m)

The value of x should be in {0, 1, 2, … m-1}, i.e., in the ring of integer modulo m.
The multiplicative inverse of “a modulo m” exists if and only if a and m are relatively prime (i.e., if gcd(a, m)
= 1).
Examples:
Input: a = 3, m = 11
Output: 4
Since (4*3) mod 11 = 1, 4 is modulo inverse of 3
One might think, 15 also as a valid output as "(15*3) mod 11"
is also 1, but 15 is not in ring {0, 1, 2, ... 10}, so not
valid.
Input: a = 10, m = 17
Output: 12
Since (10*12) mod 17 = 1, 12 is modulo inverse of 3

The idea is to use Extended Euclidean algorithms that takes two integers ‘a’ and ‘b’, finds their gcd and
also find ‘x’ and ‘y’ such that
ax + by = gcd(a, b)

To find multiplicative inverse of ‘a’ under ‘m’, we put b = m in above formula. Since we know that a and m
are relatively prime, we can put value of gcd as 1.
ax + my = 1

If we take modulo m on both sides, we get
ax + my ≡ 1 (mod m)

We can remove the second term on left side as ‘my (mod m)’ would always be 0 for an integer y.
ax ≡ 1 (mod m)

So the ‘x’ that we can find using Extended Euclid Algorithm is multiplicative inverse of ‘a’

// C++ program to find multiplicative modulo inverse using

// Extended Euclid algorithm.
#include<iostream>

int gcdExtended(int a, int b, int *x, int *y);
// Function to find modulo inverse of a

void modInverse(int a, int m)
{
int x, y;
int g = gcdExtended(a, m, &x, &y);
if (g != 1)
cout << "Inverse doesn't exist";
else
{
// m is added to handle negative x
int res = (x%m + m) % m;
cout << "Modular multiplicative inverse is " << res;
}
}

int gcdExtended(int a, int b, int *x, int *y)
{
// Base Case
if (a == 0)
{
*x = 0, *y = 1;
return b;
}
int x1, y1; // To store results of recursive call

int gcd = gcdExtended(b%a, a, &x1, &y1);
// Update x and y using results of recursive

// call
*x = y1 - (b/a) * x1;
*y = x1;
return gcd;
}
// Driver Program
int main()
{
int a = 3, m = 11;
modInverse(a, m);
return 0;
}

Output:

Modular multiplicative inverse is 4

If we know m is prime, then we can also use Fermats’s little theorem to find the inverse.
am-1 ≡ 1 (mod m)

If we multiply both sides with a-1, we get

a-1 ≡ a m-2 (mod m)


// C++ program to find modular inverse of a under modulo m

// This program works only if m is prime.
#include<iostream>
// To find GCD of a and b

int gcd(int a, int b);
// To compute x raised to power y under modulo m

int power(int x, unsigned int y, unsigned int m);
// Function to find modular inverse of a under modulo m

// Assumption: m is prime
void modInverse(int a, int m)
{
int x, y;
int g = gcd(a, m);
if (g != 1)
cout << "Inverse doesn't exist";
else
{
// If a and m are relatively prime, then modulo inverse
// is a^(m-2) mode m
cout << "Modular multiplicative inverse is "
<< power(a, m-2, m);
}
}
// To compute x^y under modulo m

int power(int x, unsigned int y, unsigned int m)
{
if (y == 0)
return 1;
int p = power(x, y/2, m) % m;
p = (p * p) % m;
return (y%2 == 0)? p : (x * p) % m;

}

{
if (a == 0)
return b;
return gcd(b%a, a);
}
// Driver Program
int main()
{
int a = 3, m = 11;
modInverse(a, m);
return 0;
}

Output:

Modular multiplicative inverse is 4

We have discussed two methods to find multiplicative inverse modulo m.

1) Extended Euler’s GCD algorithm.
2) Fermat’s Little theorem.
Both methods take O(Logm) time, but the second method works only when ‘m’ is prime.
Applications:
Computation of the modular multiplicative inverse is an essential step in RSA public-key encryption
method.
References:
https://en.wikipedia.org/wiki/Modular_multiplicative_inverse
http://e-maxx.ru/algo/reverse_element
K’th largest element in a stream
Given an infinite stream of integers, find the k’th largest element at any point of time.
Example:
Input:
stream[] = {10, 20, 11, 70, 50, 40, 100, 5, ...}
k = 3
Output: {_, _, 10, 11, 20, 40, 50, 50, ...}

Extra space allowed is O(k).
We have discussed different approaches to find k’th largest element in an array in the following posts.
K’th Smallest/Largest Element in Unsorted Array | Set 3 (Worst Case Linear Time)
Here we have a stream instead of whole array and we are allowed to store only k elements.
A Simple Solution is to keep an array of size k. The idea is to keep the array sorted so that the k’th largest
element can be found in O(1) time (we just need to return first element of array if array is sorted in
increasing order)
How to process a new element of stream?
For every new element in stream, check if the new element is smaller than current k’th largest element. If
yes, then ignore it. If no, then remove the smallest element from array and insert new element in sorted
order. Time complexity of processing a new element is O(k).
A Better Solution is to use a Self Balancing Binary Search Tree of size k. The k’th largest element can be
found in O(Logk) time.
For every new element in stream, check if the new element is smaller than current k’th largest element. If
yes, then ignore it. If no, then remove the smallest element from the tree and insert new element. Time
complexity of processing a new element is O(Logk).
An Efficient Solution is to use Min Heap of size k to store k largest elements of stream. The k’th largest
element is always at root and can be found in O(1) time.
Compare the new element with root of heap. If new element is smaller, then ignore it. Otherwise replace root
with new element and call heapify for the root of modified heap. Time complexity of finding the k’th largest
element is O(Logk).
// A C++ program to find k'th smallest element in a stream

#include<iostream>
#include<climits>


class MinHeap
{
int capacity; // maximum possible size of min heap
int heap_size; // Current number of elements in min heap
public:
MinHeap(int a[], int size); // Constructor
void buildHeap();
void MinHeapify(int i); //To minheapify subtree rooted with index i
int extractMin(); // extracts root (minimum) element
int getMin() { return harr[0]; }

void replaceMin(int x) { harr[0] = x; MinHeapify(0); }
};

{
heap_size = size;
}
void MinHeap::buildHeap()
{
while (i >= 0)
{
MinHeapify(i);
i--;
}
}

{
if (heap_size == 0)
return INT_MAX;
// Store the minimum vakue.

int root = harr[0];
if (heap_size > 1)
{
MinHeapify(0);
}
heap_size--;
return root;
}

{
int l = left(i);
int r = right(i);
int smallest = i;
smallest = l;
smallest = r;
if (smallest != i)
{
}
}

{
int temp = *x;
*x = *y;
*y = temp;
}
// Function to return k'th largest element from input stream

void kthLargest(int k)
{
// count is total no. of elements in stream seen so far
int count = 0, x; // x is for new element
// Create a min heap of size k

MinHeap mh(arr, k);
while (1)
{
// Take next element from stream
cout << "Enter next element of stream ";
cin >> x;
// Nothing much to do for first k-1 elements

if (count < k-1)
{
arr[count] = x;
count++;
}
else
{
// If this is k'th element, then store it
// and build the heap created above
if (count == k-1)
{
arr[count] = x;
mh.buildHeap();
}
// If next element is greater than k'th

// largest, then replace the root
if (x > mh.getMin())
mh.replaceMin(x); // replaceMin calls heapify()
// Root of heap is k'th largest element

cout << "K'th largest element is "
<< mh.getMin() << endl;
count++;
}
}
}
}

int main()
{
int k = 3;
cout << "K is " << k << endl;
kthLargest(k);
return 0;
}

Output

K is 3
Enter next element of stream 23
Enter next element of stream
CTRL + C pressed

Count frequencies of all elements in array in O(1) extra space and O(n) time
Given an unsorted array of n integers which can contain integers from 1 to n. Some elements can be repeated
multiple times and some other elements can be absent from the array. Count frequency of all elements that
are present and print the missing elements.
Examples:

Input: arr[] = {2, 3, 3, 2, 5}
Output: Below are frequencies of all elements
1 -> 0
2 -> 2
3 -> 2
4 -> 0
5 -> 1
Input: arr[] = {4, 4, 4, 4}

Output: Below are frequencies of all elements
1 -> 0
2 -> 0
3 -> 0
4 -> 4

A Simple Solution is to create a count array of size n as the elements are in range from 1 to n. This solution
works in O(n) time, but requires O(n) extra space.
How to do it in O(1) extra space and O(n) time?
Below are two methods to solve this in O(n) time and O(1) extra space. Both method modify given array to
achieve O(1) extra space.
Method 1 (By making elements negative)

The idea is to traverse the given array, use elements as index and store their counts at the index. For
example, when we see element 7, we go to index 6 and store the count. There are few problems to handle,
one is the counts can get mixed with the elements, this is handled by storing the counts as negative. Other
problem is loosing the element which is replaced by count, this is handled by first storing the element to be
replaced at current index.

Algorithm:
1) Initialize i as 0
2) Do following while i 0)
(i) arr[i] = arr[elementIndex];
// After storing arr[elementIndex], change it

// to store initial count of 'arr[i]'
(ii) arr[elementIndex] = -1;
d) else
// If this is NOT first occurrence of arr[i],
// then increment its count.
(i) arr[elementIndex]--;
// And initialize arr[i] as 0 means the element

// 'i+1' is not seen so far
(ii) arr[i] = 0;
(iii) i++;
3) Now -arr[i] stores count of i+1.

// C++ program to print frequencies of all array

// elements in O(1) extra space and O(n) time
// Function to find counts of all elements present in

// arr[0..n-1]. The array elements must be range from
// 1 to n
void findCounts(int *arr, int n)
{
int i = 0;
while (i<n)
{
// If this element is already processed,
// then nothing to do
if (arr[i] <= 0)
{
i++;
continue;
}
// Find index corresponding to this element

// For example, index for 5 is 4
int elementIndex = arr[i]-1;
// If the elementIndex has an element that is not

// processed yet, then first store that element
// to arr[i] so that we don't loose anything.
if (arr[elementIndex] > 0)
{
arr[i] = arr[elementIndex];

// to store initial count of 'arr[i]'
arr[elementIndex] = -1;
}
else
{
// If this is NOT first occurrence of arr[i],
// then increment its count.
arr[elementIndex]--;
// And initialize arr[i] as 0 means the element

// 'i+1' is not seen so far
arr[i] = 0;
i++;
}
}
printf("\nBelow are counts of all elements\n");

printf("%d -> %d\n", i+1, abs(arr[i]));
}

int main()
{
int arr[] = {2, 3, 3, 2, 5};
findCounts(arr, sizeof(arr)/ sizeof(arr[0]));
int arr1[] = {1};

findCounts(arr1, sizeof(arr1)/ sizeof(arr1[0]));
int arr3[] = {4, 4, 4, 4};

int arr2[] = {1, 3, 5, 7, 9, 1, 3, 5, 7, 9, 1};

int arr4[] = {3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3};

int arr5[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};

int arr6[] = {11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1};

return 0;
}

Output:

Below are counts of all elements
1 -> 0
2 -> 2
3 -> 2
4 -> 0
5 -> 1

1 -> 1
1 -> 0
2 -> 0
3 -> 0
4 -> 4

1 -> 3
2 -> 0
3 -> 2
4 -> 0
5 -> 2
6 -> 0
7 -> 2
8 -> 0
9 -> 2
10 -> 0
11 -> 0

1 -> 0
2 -> 0
3 -> 11
4 -> 0
5 -> 0
6 -> 0
7 -> 0
8 -> 0
9 -> 0
10 -> 0
11 -> 0

1 -> 1
2 -> 1
3 -> 1
4 -> 1
5 -> 1
6 -> 1
7 -> 1
8 -> 1
9 -> 1
10 -> 1
11 -> 1

1 -> 1
2 -> 1
3 -> 1
4 -> 1
5 -> 1
6 -> 1
7 -> 1
8 -> 1
9 -> 1
10 -> 1
11 -> 1

How does above program work?

Let us take below example to see step by step processing of
above program:
arr[] = {2, 3, 3, 2, 5}
i = 0, arr[i] = 2, arr[] = {2, 3, 3, 2, 5}

Since arr[i] > 0, find elementIndex.
elementIndex = arr[i] – 1 = 2 – 1 = 1,
arr[elementIndex] or arr[1] is 3
Since arr[elementIndex] is postive,
arr[i] = arr[elementIndex] = 3
arr[elementIndex] = -1 // 2 is seen 1 times so far
i is not changed.
i = 0, arr[i] = 3, arr[] = {3, -1, 3, 2, 5}

elementIndex = arr[i] – 1 = 3 – 1 = 2
Since arr[elementIndex] is postive
i is not changed.
i = 0, arr[i] = 3, arr[] = {3, -1, -1, 2, 5}

arr[elementIndex] or arr[2] is -1
Since arr[elementIndex] is negative
arr[elementIndex] = arr[elementIndex] – 1
= -2 // 3 is seen 2 times so far
arr[i] = 0 // 1 is not seen so far
i is incremented
i = 1, arr[i] = -1, arr[] = {0, -1, -2, 2, 5}

Since arr[i] is negative, increment i
i = 2, arr[i] = -2, arr[] = {0, -1, -2, 2, 5}

i = 3, arr[i] = 2, arr[] = {0, -1, -2, 2, 5}

Since arr[i] > 0, we find elementIndex.
arr[elementIndex] or arr[1] is -1
Since arr[elementIndex] is negative
arr[elementIndex] = arr[elementIndex] – 1
= -2 // 2 is seen 2 times so far
arr[i] = 0 // 4 is not seen so far
i is incremented
i = 4, arr[i] = 5, arr[] = {0, -2, -2, 0, 5}

Since arr[i] > 0, we find elementIndex.
Since arr[elementIndex] is postive
i is not changed.
i = 1, arr[i] = -1, arr[] = {0, -2, -2, 0, -1}
Method 2 (By adding n to keep track of counts)
1) Subtract 1 from every element so that the elements

become in range from 0 to n-1
for (int j =0; j

// C++ program to print frequencies of all array
// elements in O(1) extra space and O(n) time
// Function to find counts of all elements present in

// arr[0..n-1]. The array elements must be range from
// 1 to n
void printfrequency(int arr[],int n)
{
// Subtract 1 from every element so that the elements
// become in range from 0 to n-1
for (int j =0; j<n; j++)
arr[j] = arr[j]-1;
// Use every element arr[i] as index and add 'n' to

// element present at arr[i]%n to keep track of count of
// occurrences of arr[i]
arr[arr[i]%n] = arr[arr[i]%n] + n;
// To print counts, simply print the number of times n

// was added at index corresponding to every element
cout << i + 1 << " -> " << arr[i]/n << endl;
}

int main()
{
int arr[] = {2, 3, 3, 2, 5};
printfrequency(arr,n);
return 0;
}
Output:
1 -> 0
2 -> 2
3 -> 2
4 -> 0
5 -> 1
Thanks to Vivek Kumar for suggesting this solution in a comment below.

This article is contributed by Shubham Gupta. Please write comments if you find anything

Find memory conflicts among multiple threads
Consider a RAM organized in blocks. There are multiple processes running on the system. Every application
gets below information.
(Thread T, Memory Block M, time t, R/W) which essentially tells that the thread T was using memory block
M at time t and operation could be read or write.
Memory conflict is defined as –

– Multiple read operations at the same location are not cause of conflict.
– One write operation between x+5 to x-5 to location M, will be cause of conflict for a thread accessing
location M at time x where x is some time in standard unit of time measurement.
– Example – If thread T1 accessed memory location M at time x+1 and if a thread T2 accesses location M
before time x+6, then T1 and T2 are candidate of conflict given one of them does write operation.
You are given with the list of threads accessing memory locations, you have to find all conflicts.
Example–
Input:
(1, 512, 1, R)
(2, 432, 2, W)
(3, 512, 3, R)
(4, 932, 4, R)
(5, 512, 5, W)
(6, 932, 6, R)
(7, 835, 7, R)
(8, 432, 8, R)
Output:
Thread 1 & 3 conflict with thread 5
All other operations are safe.

The idea is to sort all threads by memory block and if memory block is same, then by time. Once we have all
threads sorted, we can traverse all threads one by one. For every thread being traversed, we simply need to
check previous adjacent threads of same block as threads are sorted by time.
Below is C++ implementation of this idea.
// C++ program to find memory conflicts among threads

/* Structure for details of thread */

struct Thread
{
int id, memblck, time;
char access;
};
/* Compare function needed for sorting threads

We first sort threads on the basis of memory block,
If they are same, then we sort on the basis of time */
bool compare(const Thread& x, const Thread& y)
bool compare(const Thread& x, const Thread& y)
{
if (x.memblck == y.memblck)
return x.time < y.time;
else return x.memblck < y.memblck;
}
// Function to print all conflicts among threads

void printConflicts(Thread arr[], int n)
{
/* Sort the threads first by memblock, then by
time */
sort(arr, arr+n, compare);
/*start from second thread till last thread*/

for (int i = 1; i < n; i++)
{
/* As threads are sorted, We check further
for conflict possibility only if there
memblock is same*/
if(arr[i].memblck == arr[i-1].memblck)
{
/* As threads with same block are sorted in increasing order

of access time. So we check possibility conflict from last
thread to all previous threads which access the same block
of memory such that the current thread access under the
arr[i-1].time + 5.. and if any of them does read operation
than conflict occurs. at any point memblock becomes different
or current thread moves out of vulnerable time of latest
previous processed thread, the loop breaks.
*/
if (arr[i].time <= arr[i-1].time+5)
{
int j = i-1; /* start with previous thread */
// Find all previous conflicting threads

while (arr[i].memblck == arr[j].memblck &&
arr[i].time <= arr[j].time+5 &&
j >= 0)
{
if (arr[i].access == 'W' || arr[j].access == 'W')
{
cout << "threads " << arr[j].id << " and "
<< arr[i].id << " conflict.\n";
}
j--;
}
}
}
}
cout << "All other operations are same\n";

}

int main()
{
Thread arr[] = { {1, 512, 1, 'R'}, {2, 432, 2, 'W'},
{3, 512, 3, 'R'}, {4, 932, 4, 'R'},
{5, 512, 5, 'W'}, {6, 932, 6, 'R'},
{7, 835, 7, 'R'}, {8, 432, 8, 'R'}
};
printConflicts(arr, n);
return 0;
}

Output:

threads 3 and 5 conflict.
threads 1 and 5 conflict.
All other operations are same

Time complexity: The above solution uses sorting to sort threads. Sorting can be done in O(nLogn) time.
Then it prints all conflicts. Printing all conflicts takes O(n + m) time where m is number of conflicts. So
overall time complexity is O(nLogn + m).
This article is contributed by Gaurav Ahirwar. Please write comments if you find anything incorrect, or you
Compute sum of digits in all numbers from 1 to n
Given a number x, find sum of digits in all numbers from 1 to n.
Examples:
Input: n = 5
Output: Sum of digits in numbers from 1 to 5 = 15
Input: n = 12
Input: n = 328

Naive Solution:
A naive solution is to go through every number x from 1 to n, and compute sum in x by traversing all digits of
x. Below is C++ implementation of this idea.

// A Simple C++ program to compute sum of digits in numbers from 1 to n

#include<iostream>
int sumOfDigits(int );
// Returns sum of all digits in numbers from 1 to n

int sumOfDigitsFrom1ToN(int n)
{
int result = 0; // initialize result
// One by one compute sum of digits in every number from

// 1 to n
result += sumOfDigits(x);
return result;
}
// A utility function to compute sum of digits in a

// given number x
int sumOfDigits(int x)
{
int sum = 0;
while (x != 0)
{
sum += x %10;
x = x /10;
}
return sum;
}
// Driver Program
int main()
{
int n = 328;
cout << "Sum of digits in numbers from 1 to " << n << " is "
<< sumOfDigitsFrom1ToN(n);
return 0;
}

Output

Sum of digits in numbers from 1 to 328 is 3241

Efficient Solution:
Above is a naive solution. We can do it more efficiently by finding a pattern.

sum(9) = 1 + 2 + 3 + 4 ........... + 9
= 9*10/2
= 45
sum(99) = 45 + (10 + 45) + (20 + 45) + ..... (90 + 45)

= 45*10 + (10 + 20 + 30 ... 90)
= 45*10 + 10(1 + 2 + ... 9)
= 45*10 + 45*10
= sum(9)*10 + 45*10
sum(999) = sum(99)*10 + 45*100

In general, we can compute sum(10d – 1) using below formula
sum(10d - 1) = sum(10d-1 - 1) * 10 + 45*(10 d-1)

In below implementation, the above formula is implemented using dynamic programming as there are
overlapping subproblems.
The above formula is one core step of the idea. Below is complete algorithm
Algorithm: sum(n)
1) Find number of digits minus one in n. Let this value be 'd'.

For 328, d is 2.
2) Compute some of digits in numbers from 1 to 10d - 1.

Let this sum be w. For 328, we compute sum of digits from 1 to
99 using above formula.
3) Find Most significant digit (msd) in n. For 328, msd is 3.
4) Overall sum is sum of following terms
a) Sum of digits in 1 to "msd * 10d - 1". For 328, sum of

digits in numbers from 1 to 299.
For 328, we compute 3*sum(99) + (1 + 2)*100. Note that sum of
sum(299) is sum(99) + sum of digits from 100 to 199 + sum of digits
from 200 to 299.
Sum of 100 to 199 is sum(99) + 1*100 and sum of 299 is sum(99) + 2*100.
In general, this sum can be computed as w*msd + (msd*(msd-1)/2)*10d
b) Sum of digits in msd * 10d to n. For 328, sum of digits in

300 to 328.
For 328, this sum is computed as 3*29 + recursive call "sum(28)"
In general, this sum can be computed as msd * (n % (msd*10d) + 1)
+ sum(n % (10d))

Below is C++ implementation of above aglorithm.

// C++ program to compute sum of digits in numbers from 1 to n

// Function to computer sum of digits in numbers from 1 to n

// Comments use example of 328 to explain the code
int sumOfDigitsFrom1ToN(int n)
{
// base case: if n<10 return sum of
// first n natural numbers
if (n<10)
return n*(n+1)/2;
// d = number of digits minus one in n. For 328, d is 2

int d = log10(n);
// computing sum of digits from 1 to 10^d-1,

// d=1 a[0]=0;
// d=2 a[1]=sum of digit from 1 to 9 = 45
// d=3 a[2]=sum of digit from 1 to 99 = a[1]*10 + 45*10^1 = 900
// d=4 a[3]=sum of digit from 1 to 999 = a[2]*10 + 45*10^2 = 13500
int *a = new int[d+1];
a[0] = 0, a[1] = 45;
for (int i=2; i<=d; i++)
a[i] = a[i-1]*10 + 45*ceil(pow(10,i-1));
// computing 10^d
int p = ceil(pow(10, d));
// Most significant digit (msd) of n,

// For 328, msd is 3 which can be obtained using 328/100
int msd = n/p;
// EXPLANATION FOR FIRST and SECOND TERMS IN BELOW LINE OF CODE

// First two terms compute sum of digits from 1 to 299
// (sum of digits in range 1-99 stored in a[d]) +
// (sum of digits in range 100-199, can be calculated as 1*100 + a[d]
// (sum of digits in range 200-299, can be calculated as 2*100 + a[d]
// The above sum can be written as 3*a[d] + (1+2)*100
// EXPLANATION FOR THIRD AND FOURTH TERMS IN BELOW LINE OF CODE

// The last two terms compute sum of digits in number from 300 to 328
// The third term adds 3*29 to sum as digit 3 occurs in all numbers
// from 300 to 328
// The fourth term recursively calls for 28
return msd*a[d] + (msd*(msd-1)/2)*p +
msd*(1+n%p) + sumOfDigitsFrom1ToN(n%p);
}
// Driver Program
int main()
{
int n = 328;
cout << "Sum of digits in numbers from 1 to " << n << " is "
<< sumOfDigitsFrom1ToN(n);
return 0;
}

Output

Sum of digits in numbers from 1 to 328 is 3241

The efficient algorithm has one more advantage that we need to compute the array ‘a[]’ only once even when
we are given multiple inputs.
This article is computed by Shubham Gupta. Please write comments if you find anything incorrect, or you
How to design a tiny URL or URL shortener?
How to design a system that takes big URLs like “http://www.geeksforgeeks.org/count-sum-of-digits-in-
numbers-from-1-to-n/” and converts them into a short 6 character URL. It is given that URLs are stored in
database and every URL has an associated integer id.
One important thing to note is, the long url should also be uniquely identifiable from short url. So we need a
Bijective Function
One Simple Solution could be Hashing. Use a hash function to convert long string to short string. In
hashing, that may be collisions (2 long urls map to same short url) and we need a unique short url for every
long url so that we can access long url back.
A Better Solution is to use the integer id stored in database and convert the integer to character string that
is at most 6 characters long. This problem can basically seen as a base conversion problem where we have a
10 digit input number and we want to convert it into a 6 character long string.
Below is one important observation about possible characters in URL.
A URL character can be one of the following

1) A lower case alphabet [‘a’ to ‘z’], total 26 characters
2) An upper case alphabet [‘A’ to ‘Z’], total 26 characters
3) A digit [‘0′ to ‘9’], total 10 characters
There are total 26 + 26 + 10 = 62 possible characters.
So the task is to convert a decimal number to base 62 number.
To get the original long url, we need to get url id in database. The id can be obtained using base 62 to
decimal conversion.
Below is a C++ program based on this idea.

// C++ prgram to generate short url from intger id and
// integer id back from short url.
#include<iostream>
#include<algorithm>
#include<string>
// Function to generate a short url from intger ID

string idToShortURL(long int n)
{
// Map to store 62 possible characters
char map[] = "abcdefghijklmnopqrstuvwxyzABCDEF"
"GHIJKLMNOPQRSTUVWXYZ0123456789";
string shorturl;
// Convert given integer id to a base 62 number

while (n)
{
// use above map to store actual character
// in short url
shorturl.push_back(map[n%62]);
n = n/62;
}
// Reverse shortURL to complete base conversion

reverse(shorturl.begin(), shorturl.end());
return shorturl;
}
// Function to get integer ID back from a short url

long int shortURLtoID(string shortURL)
{
long int id = 0; // initialize result
// A simple base conversion logic

for (int i=0; i < shortURL.length(); i++)
{
if ('a' <= shortURL[i] && shortURL[i] <= 'z')
id = id*62 + shortURL[i] - 'a';
if ('A' <= shortURL[i] && shortURL[i] <= 'Z')
id = id*62 + shortURL[i] - 'A' + 26;
if ('0' <= shortURL[i] && shortURL[i] <= '9')
id = id*62 + shortURL[i] - '0' + 52;
}
return id;
}

int main()
{
int n = 12345;
string shorturl = idToShortURL(n);
cout << "Generated short url is " << shorturl << endl;
cout << "Id from url is " << shortURLtoID(shorturl);
return 0;
}

Output:

Generated short url is dnh

Id from url is 12345

Optimization: We can avoid reverse step in idToShortURL(). To make sure that we get same ID back, we also
need to change shortURLtoID() to process characters from end instead of beginning.
This article is computed by Shivam. Please write comments if you find anything incorrect, or you want to
Count numbers from 1 to n that have 4 as a a digit
Given a number n, find count of all numbers from 1 to n that have 4 as a a digit.
Examples:
Input: n = 5
Output: 1
Only 4 has '4' as digit
Input: n = 50
Output: 14
Input: n = 328
Output: 60

This problem is mainly a variation of previous article on Compute sum of digits in all numbers from 1 to n.
Naive Solution:
A naive solution is to go through every number x from 1 to n, and check if x has 4. To check if x has or not, we
can traverse all digits of x. Below is C++ implementation of this idea.

// A Simple C++ program to compute sum of digits in numbers from 1 to n

#include<iostream>
bool has4(int x);
// Returns sum of all digits in numbers from 1 to n

int countNumbersWith4(int n)
{
int result = 0; // initialize result
// One by one compute sum of digits in every number from

// 1 to n
result += has4(x)? 1 : 0;
return result;
}
// A utility function to compute sum of digits in a

// given number x
bool has4(int x)
{
while (x != 0)
{
if (x%10 == 4)
return true;
x = x /10;
}
return false;
}
// Driver Program
int main()
{
int n = 328;
cout << "Count of numbers from 1 to " << n
<< " that have 4 as a a digit is "
<< countNumbersWith4(n) << endl;
return 0;
}

Output:

Count of numbers from 1 to 328 that have 4 as a a digit is 60

Efficient Solution:
Above is a naive solution. We can do it more efficiently by finding a pattern.

Count of numbers from 0 to 9 = 1

Count of numbers from 0 to 99 = 1*9 + 10 = 19
Count of numbers from 0 to 999 = 19*9 + 100 = 271
In general, we can write

count(10d) = 9 * count(10d - 1) + 10d - 1

In below implementation, the above formula is implemented using dynamic programming as there are
overlapping subproblems.
The above formula is one core step of the idea. Below is complete algorithm.
1) Find number of digits minus one in n. Let this value be 'd'.

For 328, d is 2.
2) Compute some of digits in numbers from 1 to 10d - 1.

Let this sum be w. For 328, we compute sum of digits from 1 to
99 using above formula.
3) Find Most significant digit (msd) in n. For 328, msd is 3.
4.a) If MSD is 4. For example if n = 428, then count of

numbers is sum of following.
1) Count of numbers from 1 to 399
2) Count of numbers from 400 to 428 which is 29.
4.b) IF MSD > 4. For example if n is 728, then count of

numbers is sum of following.
1) Count of numbers from 1 to 399 and count of numbers
from 500 to 699, i.e., "a[2] * 6"
2) Count of numbers from 400 to 499, i.e. 100
3) Count of numbers from 700 to 728, recur for 28
4.c) IF MSD

// C++ program to count numbers having 4 as a digit
// Function to count numbers from 1 to n that have

// 4 as a digit
int countNumbersWith4(int n)
{
// Base case
if (n < 4)
return 0;
// d = number of digits minus one in n. For 328, d is 2

int d = log10(n);
// computing count of numbers from 1 to 10^d-1,

// d=0 a[0] = 0;
// d=1 a[1] = count of numbers from 0 to 9 = 1
// d=2 a[2] = count of numbers from 0 to 99 = a[1]*9 + 10 = 19
int *a = new int[d+1];
a[0] = 0, a[1] = 1;
for (int i=2; i<=d; i++)
a[i] = a[i-1]*9 + ceil(pow(10,i-1));
// Computing 10^d
int p = ceil(pow(10, d));
// Most significant digit (msd) of n,

// For 328, msd is 3 which can be obtained using 328/100
int msd = n/p;
// If MSD is 4. For example if n = 428, then count of

// numbers is sum of following.
// 1) Count of numbers from 1 to 399
// 2) Count of numbers from 400 to 428 which is 29.
if (msd == 4)
return (msd)*a[d] + (n%p) + 1;
// IF MSD > 4. For example if n is 728, then count of

// 1) Count of numbers from 1 to 399 and count of numbers
// from 500 to 699, i.e., "a[2] * 6"
// 2) Count of numbers from 400 to 499, i.e. 100
// 3) Count of numbers from 700 to 728, recur for 28
if (msd > 4)
return (msd-1)*a[d] + p + countNumbersWith4(n%p);
// IF MSD < 4. For example if n is 328, then count of

// 1) Count of numbers from 1 to 299 a
// 2) Count of numbers from 300 to 328, recur for 28
return (msd)*a[d] + countNumbersWith4(n%p);
}
// Driver Program
int main()
{
int n = 328;
cout << "Count of numbers from 1 to " << n
<< " that have 4 as a a digit is "
<< countNumbersWith4(n) << endl;
return 0;
}

Output:
Count of numbers from 1 to 328 that have 4 as a a digit is 60
This article is contributed by Shivam. Please write comments if you find anything

Generate all possible sorted arrays from alternate elements of two given
sorted arrays
Given two sorted arrays A and B, generate all possible arrays such that first element is taken from A then
from B then from A and so on in increasing order till the arrays exhausted. The generated arrays should end
with an element from B.
For Example
A = {10, 15, 25}
B = {1, 5, 20, 30}
The resulting arrays are:

10 20
10 20 25 30
10 30
15 20
15 20 25 30
15 30
25 30

The idea is to use recursion. In the recursive function, a flag is passed to indicate whether current element in
output should be taken from ‘A’ or ‘B’. Below is C++ implementation.
void printArr(int arr[], int n);
/* Function to generates and prints all sorted arrays from alternate elements of
'A[i..m-1]' and 'B[j..n-1]'
If 'flag' is true, then current element is to be included from A otherwise
from B.
'len' is the index in output array C[]. We print output array each time
before including a character from A only if length of output array is
greater than 0. We try than all possible combinations */
void generateUtil(int A[], int B[], int C[], int i, int j, int m, int n,
int len, bool flag)
{
if (flag) // Include valid element from A
{
// Print output if there is at least one 'B' in output array 'C'
if (len)
printArr(C, len+1);
// Recur for all elements of A after current index

for (int k = i; k < m; k++)
{
if (!len)
{
/* this block works for the very first call to include
the first element in the output array */
C[len] = A[k];
C[len] = A[k];
// don't increment lem as B is included yet

generateUtil(A, B, C, k+1, j, m, n, len, !flag);
}
else /* include valid element from A and recur */
{
if (A[k] > C[len])
{
C[len+1] = A[k];
generateUtil(A, B, C, k+1, j, m, n, len+1, !flag);
}
}
}
}
else /* Include valid element from B and recur */
{
for (int l = j; l < n; l++)
{
if (B[l] > C[len])
{
C[len+1] = B[l];
generateUtil(A, B, C, i, l+1, m, n, len+1, !flag);
}
}
}
}
/* Wrapper function */
void generate(int A[], int B[], int m, int n)
{
int C[m+n]; /* output array */
generateUtil(A, B, C, 0, 0, m, n, 0, true);
}

{
for (int i = 0; i < n; i++)
cout << arr[i] << " ";
cout << endl;
}
// Driver program
int main()
{
int A[] = {10, 15, 25};
int B[] = {5, 20, 30};
int n = sizeof(A)/sizeof(A[0]);
int m = sizeof(B)/sizeof(B[0]);
generate(A, B, n, m);
return 0;
}

Output:

10 20
10 20 25 30
10 30
15 20
15 20 25 30
15 30
25 30

want to share more information about the topic discussed above\
Count BST nodes that lie in a given range
Given a Binary Search Tree (BST) and a range, count number of nodes that lie in the given range.
Examples:
Input:
10
/ \
5 50
/ / \
1 40 100
Range: [5, 45]
Output: 3
There are three nodes in range, 5, 10 and 40

Source: Google Question
The idea is to traverse the given binary search tree starting from root. For every node being visited, check if
this node lies in range, if yes, then add 1 to result and recur for both of its children. If current node is smaller
than low value of range, then recur for right child, else recur for left child.
// C++ program to count BST nodes withing a given range

// A BST node
struct node
{
int data;
};
// Utility function to create new node

node *newNode(int data)
{
temp->data = data;
return (temp);
}
// Returns count of nodes in BST in range [low, high]

int getCount(node *root, int low, int high)
{
// Base case
if (!root) return 0;
// Special Optional case for improving efficiency

if (root->data == high && root->data == low)
return 1;
// If current node is in range, then include it in count and
// recur for left and right children of it
if (root->data <= high && root->data >= low)
return 1 + getCount(root->left, low, high) +
getCount(root->right, low, high);
// If current node is smaller than low, then recur for right

// child
else if (root->data < low)
return getCount(root->right, low, high);
// Else recur for left child

else return getCount(root->left, low, high);
}
// Driver program
int main()
{
/* Let us constructed BST shown in above example
10
/ \
5 50
/ / \
1 40 100 */
int l = 5;
int h = 45;
cout << "Count of nodes between [" << l << ", " << h
<< "] is " << getCount(root, l, h);
return 0;
}

Output:

Count of nodes between [5, 45] is 3

Time complexity of the above program is O(h + k) where h is height of BST and k is number of nodes in
given range.
Shortest Superstring Problem
Given a set of n strings arr[], find the smallest string that contains each string in the given set as substring.
We may assume that no string in arr[] is substring of another string.
Examples:

Input: arr[] = {"geeks", "quiz", "for"}
Output: geeksquizfor
Input: arr[] = {"catg", "ctaagt", "gcta", "ttca", "atgcatc"}

Output: gctaagttcatgcatc

Shortest Superstring Greedy Approximate Algorithm

Shortest Superstring Problem is a NP Hard problem. A solution that always finds shortest superstring takes
exponential time. Below is an Approximate Greedy algorithm.

Let arr[] be given set of strings.
1) Create an auxiliary array of strings, temp[]. Copy contents

of arr[] to temp[]
2) While temp[] contains more than one strings

a) Find the most overlapping string pair in temp[]. Let this
pair be 'a' and 'b'.
b) Replace 'a' and 'b' with the string obtained in above step a
3) The only string left in temp[] is the result, return it.

Two strings are overlapping if prefix of one string is same suffix of other string or vice verse. The maximum
overlap mean length of the matching prefix and suffix is maximum.
Working of above Algorithm:

arr[] = {"catgc", "ctaagt", "gcta", "ttca", "atgcatc"}
Initialize:
temp[] = {"catgc", "ctaagt", "gcta", "ttca", "atgcatc"}
The most overlapping strings are "catgc" and "atgcatc"

(Suffix of length 4 of "catgc" is same as prefix of "atgcatc")
Replace two strings with "catgcatc", we get
temp[] = {"catgcatc", "ctaagt", "gcta", "ttca"}
The most overlapping strings are "ctaagt" and "gcta"

(Prefix of length 3 of "ctaagt" is same as suffix of "gcta")
Replace two strings with "gctaagt", we get
temp[] = {"catgcatc", "gctaagt", "ttca"}
The most overlapping strings are "catgcatc" and "ttca"

(Prefix of length 2 of "catgcatc" as suffix of "ttca")
Replace two strings with "ttcatgcatc", we get
temp[] = {"ttcatgcatc", "gctaagt"}
Now there are only two strings in temp[], after combing

the two in optimal way, we get tem[] = {"gctaagttcatgcatc"}
Since temp[] has only one string now, return it.

Performance of above algorithm:

The above Greedy Algorithm is proved to be 4 approximate (i.e., length of the superstring generated by this
algorithm is never beyond 4 times the shortest possible superstring). This algorithm is conjectured to 2
approximate (nobody has found case where it generates more than twice the worst). Conjectured worst case
example is {abk, bkc, bk+1}. For example {“abb”, “bbc”, “bbb”}, the above algorithm may generate “abbcbbb”
(if “abb” and “bbc” are picked as first pair), but the actual shortest superstring is “abbbc”. Here ratio is 7/5,
but for large k, ration approaches 2.
There exist better approximate algorithms for this problem. We will soon be covering them in a different
post.
Applications:
Useful in the genome project since it will allow researchers to determine entire coding regions from a
collection of fragmented sections.
Reference:
http://fileadmin.cs.lth.se/cs/Personal/Andrzej_Lingas/superstring.pdf
http://math.mit.edu/~goemans/18434S06/superstring-lele.pdf
This article is contributed by Piyush. Please write comments if you find anything incorrect, or you want to
Count BST subtrees that lie in given range
Given a Binary Search Tree (BST) of integer values and a range [low, high], return count of nodes where all
the nodes under that node (or subtree rooted with that node) lie in the given range.
Examples:
Input:
10
/ \
5 50
/ / \
1 40 100
Range: [5, 45]
Output: 1
There is only 1 node whose subtree is in the given range.
The node is 40
Input:
10
/ \
5 50
/ / \
1 40 100
Range: [1, 45]
Output: 3
There are three nodes whose subtree is in the given range.
The nodes are 1, 5 and 40

The idea is to traverse the given Binary Search Tree (BST) in bottom up manner. For every node, recur for its
subtrees, if subtrees are in range and the nodes is also in range, then increment count and return true (to tell
the parent about its status). Count is passed as a pointer so that it can be incremented across all function
calls.
// C++ program to count subtrees that lie in a given range

// A BST node
struct node
{
int data;
};
// A utility function to check if data of root is

// in range from low to high
bool inRange(node *root, int low, int high)
{
return root->data >= low && root->data <= high;
return root->data >= low && root->data <= high;
}
// A recursive function to get count of nodes whose subtree

// is in range from low to hgih. This function returns true
// if nodes in subtree rooted under 'root' are in range.
bool getCountUtil(node *root, int low, int high, int *count)
{
// Base case
if (root == NULL)
return true;

bool l = (root->left) ? getCountUtil(root->left, low, high, count) : true;
bool r = (root->right) ? getCountUtil(root->right, low, high, count) : true;
// If both left and right subtrees are in range and current node
// is also in range, then increment count and return true
if (l && r && inRange(root, low, high))
{
++*count;
return true;
}
return false;
}
// A wrapper over getCountUtil(). This function initializes count as 0

// and calls getCountUtil()
int getCount(node *root, int low, int high)
{
int count = 0;
getCountUtil(root, low, high, &count);
return count;
}
// Utility function to create new node

node *newNode(int data)
{
temp->data = data;
return (temp);
}
// Driver program
int main()
{
/* Let us constructed BST shown in above example
10
/ \
5 50
/ / \
1 40 100 */
int l = 5;
int h = 45;
cout << "Count of subtrees in [" << l << ", "
<< h << "] is " << getCount(root, l, h);
return 0;
}

Output:

Count of subtrees in [5, 45] is 1

Shortest Common Supersequence
Given two strings str1 and str2, find the shortest string that has both str1 and str2 as subsequences.
Examples:
Input: str1 = "geek", str2 = "eke"

Output: "geeke"
Input: str1 = "AGGTAB", str2 = "GXTXAYB"

Output: "AGXGTXAYB"

This problem is closely related to longest common subsequence problem. Below are steps.
1) Find Longest Common Subsequence (lcs) of two given strings. For example, lcs of “geek” and “eke” is “ek”.
2) Insert non-lcs characters (in their original order in strings) to the lcs found above, and return the result.
So “ek” becomes “geeke” which is shortest common supersequence.
Let us consider another example, str1 = “AGGTAB” and str2 = “GXTXAYB”. LCS of str1 and str2 is “GTAB”.
Once we find LCS, we insert characters of both strings in order and we get “AGXGTXAYB”
How does this work?

We need to find a string that has both strings as subsequences and is shortest such string. If both strings
have all characters different, then result is sum of lengths of two given strings. If there are common
characters, then we don’t want them multiple times as the task is to minimize length. Therefore, we fist find
the longest common subsequence, take one occurrence of this subsequence and add extra characters.
Length of the shortest supersequence = (Sum of lengths of given two strings) -

(Length of LCS of two given strings)

Below is C implementation of above idea. The below implementation only finds length of the shortest
supersequence.
/* C program to find length of the shortest supersequence */

#include<stdio.h>
#include<string.h>


int lcs( char *X, char *Y, int m, int n);
// Function to find length of the shortest supersequence

// of X and Y.
int shortestSuperSequence(char *X, char *Y)
{
int m = strlen(X), n = strlen(Y);
int m = strlen(X), n = strlen(Y);
int l = lcs(X, Y, m, n); // find lcs
// Result is sum of input string lengths - length of lcs

return (m + n - l);
}

int lcs( char *X, char *Y, int m, int n)
{
int L[m+1][n+1];
int i, j;
/* Following steps build L[m+1][n+1] in bottom up fashion.

Note that L[i][j] contains length of LCS of X[0..i-1]
and Y[0..j-1] */
for (i=0; i<=m; i++)
{
for (j=0; j<=n; j++)
{
if (i == 0 || j == 0)
L[i][j] = 0;
else if (X[i-1] == Y[j-1])

L[i][j] = L[i-1][j-1] + 1;
else
L[i][j] = max(L[i-1][j], L[i][j-1]);
}
}
/* L[m][n] contains length of LCS for X[0..n-1] and

Y[0..m-1] */
return L[m][n];
}

int main()
{
printf("Length of the shortest supersequence is %d\n",
shortestSuperSequence(X, Y));
return 0;
}

Output:

Length of the shortest supersequence is 9

Below is Another Method to solve the above problem.

A simple analysis yields below simple recursive solution.

Let X[0..m-1] and Y[0..n-1] be two strings and m and be respective

lengths.
if (m == 0) return n;
if (n == 0) return m;
// If last characters are same, then add 1 to result and

// recur for X[]
if (X[m-1] == Y[n-1])
return 1 + SCS(X, Y, m-1, n-1);
// Else find shortest of following two

// a) Remove last character from X and recur
// b) Remove last character from Y and recur
else return 1 + min( SCS(X, Y, m-1, n), SCS(X, Y, m, n-1) );

Below is simple naive recursive solution based on above recursive formula.
/* A Naive recursive C++ program to find length

of the shortest supersequence */
int superSeq(char* X, char* Y, int m, int n)

{
if (!m) return n;
if (!n) return m;
if (X[m-1] == Y[n-1])
return 1 + superSeq(X, Y, m-1, n-1);
return 1 + min(superSeq(X, Y, m-1, n),

superSeq(X, Y, m, n-1));
}

int main()
{
cout << "Length of the shortest supersequence is "
<< superSeq(X, Y, strlen(X), strlen(Y));
return 0;
}

Output:


Time complexity of the above solution exponential O(2min(m, n) ). Since there are overlapping subproblems,
we can efficiently solve this recursive problem using Dynamic Programming. Below is Dynamic
Programming based implementation. Time complexity of this solution is O(mn).
/* A dynamic programming based C program to find length

of the shortest supersequence */
// Returns length of the shortest supersequence of X and Y

int superSeq(char* X, char* Y, int m, int n)
{
int dp[m+1][n+1];
// Fill table in bottom up manner

for (int i = 0; i <= m; i++)
{
for (int j = 0; j <= n; j++)
{
// Below steps follow above recurrence
if (!i)
dp[i][j] = j;
else if (!j)
dp[i][j] = i;
else if (X[i-1] == Y[j-1])
dp[i][j] = 1 + dp[i-1][j-1];
else
dp[i][j] = 1 + min(dp[i-1][j], dp[i][j-1]);
}
}
return dp[m][n];
}

int main()
{
cout << "Length of the shortest supersequence is "
<< superSeq(X, Y, strlen(X), strlen(Y));
return 0;
}

Output:


Exercise:
Extend the above program to print shortest supersequence also using function to print LCS.
References:
https://en.wikipedia.org/wiki/Shortest_common_supersequence
discussed above
Find n’th Magic Number
A magic number is defined as a number which can be expressed as a power of 5 or sum of unique powers of
5. First few magic numbers are 5, 25, 30(5 + 25), 125, 130(125 + 5), ….
Write a function to find the n’th Magic number.
Example:
Input: n = 2
Output: 25
Input: n = 5
Output: 130

Source: Amazon written round question
If we notice carefully the magic numbers can be represented as 001, 010, 011, 100, 101, 110 etc, where 001 is
0*pow(5,3) + 0*pow(5,2) + 1*pow(5,1). So basically we need to add powers of 5 for each bit set in given
integer n.
Below is C++ implementation based on this idea.

// C++ program to find n't magic numebr

#include <bits/stdc++.h>
// Function to find n'th magic numebr

int nthMagicNo(int n)
{
int pow = 1, answer = 0;
// Go through every bit of n

while (n)
{
pow = pow*5;
// If last bit of n is set

if (n & 1)
answer += pow;
// proceed to next bit

n >>= 1; // or n = n/2
}
return answer;
}

int main()
{
int n = 5;
cout << "n'th magic number is " << nthMagicNo(n) << endl;
return 0;
}

Output:

n'th magic number is 130

Thanks to manrajsingh for suggesting above solution.
This article is contributed by Abhay. Please write comments if you find anything incorrect, or you want to
Minimum steps to reach a destination
Given a number line from -infinity to +infinity. You start at 0 and can go either to the left or to the right. The
condition is that in i’th move, you take i steps.
a) Find if you can reach a given number x
b) Find the most optimal way to reach a given number x, if we can indeed reach it. For example, 3 can be
reached om 2 steps, (0, 1) (1, 3) and 4 can be reached in 3 steps (0, -1), (-1, 1) (1, 4).
Source: Flipkart Interview Question
The important think to note is we can reach any destination as it is always possible to make a move of length
1. At any step i, we can move forward i, then backward i+1.
Below is a recursive solution suggested by Arpit Thapar here.
1) Since distance of +5 and -5 from 0 is same, hence we find answer for absolute value of destination.
2) We use a recursive function which takes as arguments:

i) Source Vertex
ii) Value of last step taken
iii) Destination
3) If at any point source vertex = destination; return number of steps.
4) Otherwise we can go in both of the possible directions. Take the minimum of steps in both cases.
From any vertex we can go to :

(current source + last step +1) and
(current source – last step -1)
5) If at any point, absolute value of our position exceeds the absolute value of our destination then it is
intuitive that the shortest path is not possible from here. Hence we make the value of steps INT_MAX, so
that when i take the minimum of both possibilities, this one gets eliminated.
If we don’t use this last step, the program enters into an INFINITE recursion and gives RUN TIME ERROR.
Below is C++ implementation of above idea. Note that the solution only counts steps.

// C++ program to count number of steps to reach a point

// Function to count number of steps required to reach a

// destination.
// source -> source vertex
// step -> value of last step taken
// dest -> destination vertex
int steps(int source, int step, int dest)
{
// base cases
if (abs(source) > (dest)) return INT_MAX;
if (source == dest) return step;
// at each point we can go either way
// if we go on positive side
int pos = steps(source+step+1, step+1, dest);
// if we go on negative side
int neg = steps(source-step-1, step+1, dest);
// minimum of both cases

return min(pos, neg);
}
// Driver Program
int main()
{
int dest = 11;
cout << "No. of steps required to reach "
<< dest << " is " << steps(0, 0, dest);
return 0;
}

Output:

No. of steps required to reach 11 is 5

Thanks to Arpit Thapar for providing above algorithm and implementation.
This article is contributed by Abhay. Please write comments if you find anything incorrect, or you want to
Karger’s algorithm for Minimum Cut | Set 2 (Analysis and Applications)
We have introduced and discussed below Karger’s algorithm in set 1.

1) Initialize contracted graph CG as copy of original graph
2) While there are more than 2 vertices.
a) Pick a random edge (u, v) in the contracted graph.
b) Merge (or contract) u and v into a single vertex (update
the contracted graph).
c) Remove self-loops
3) Return cut represented by two vertices.

As discussed in the previous post, Karger’s algorithm doesn’t always find min cut. In this post, the
probability of finding min-cut is discussed.
Probability that the cut produced by Karger’s Algorithm is Min-Cut is at greater than or
equal to 1/(n2)
Proof:
Let there be a unique Min-Cut of given graph and let there be C edges in the Min-Cut and the edges be {e1,
e2, e3, .. ec}. The Karger’s algorithm would produce this Min-Cut if and only if none of the edges in set {e, e
1 2,
e3, .. ec} is removed in iterations in the main while loop of above algorithm.

c is number of edges in min-cut

m is total number of edges
n is total number of vertices
S1 = Event that one of the edges in {e 1, e 2,

e3, .. ec} is chosen in 1st iteration.
e3, .. ec} is chosen in 2nd iteration.
e3, .. ec} is chosen in 3rd iteration.
..................
..................
The cut produced by Karger's algorithm would be a min-cut if none of the above
events happen.
So the required probability is P[S1' ∩ S2' ∩ S3' ∩ ............]

Probability that a min-cut edge is chosen in first iteration:
Let us calculate P[S 1']

P[S 1] = c/m
P[S 1'] = (1 - c/m)
Above value is in terms of m (or edges), let us convert

it in terms of n (or vertices) using below 2 facts..
1) Since size of min-cut is c, degree of all vertices must be greater

than or equal to c.
2) As per Handshaking Lemma, sum of degrees of all vertices = 2m
From above two facts, we can conclude below.

n*c = nc/2
P[S1] 1] 1'] >= (1-2/n) ------------(1)

Probability that a min-cut edge is chosen in second iteration:

P[S 1' ∩ S2'] = P[S 2' | S1' ] * P[S1']
In the above expression, we know value of P[S1'] >= (1-2/n)
P[S 2' | S1'] is conditional probability that is, a min cut is

not chosen in second iteration given that it is not chosen in first iteration
Since there are total (n-1) edges left now and number of cut edges is still c,
we can replace n by n-1 in inequality (1). So we get.
P[S2' | S1' ] >= (1 - 2/(n-1))
P[S1' ∩ S2'] >= (1-2/n) x (1-2/(n-1))

Probability that a min-cut edge is chosen in all iterations:
P[S 1' ∩ S2' ∩ S3' ∩.......... ∩ Sn-2']
>= [1 - 2/n] * [1 - 2/(n-1)] * [1 - 2/(n-2)] * [1 - 2/(n-3)] *...

... * [1 - 2/(n - (n-4)] * [1 - 2/(n - (n-3)]
>= [(n-2)/n] * [(n-3)/(n-1)] * [(n-4)/(n-2)] * .... 2/4 * 2/3
>= 2/(n * (n-1))

>= 1/n2

How to increase probability of success?

The above probability of success of basic algorithm is very less. For example, for a graph with 10 nodes, the
probability of finding the min-cut is greater than or equal to 1/100. The probability can be increased by
repeated runs of basic algorithm and return minimum of all cuts found.
Applications:
1) In war situation, a party would be interested in finding minimum number of links that break
communication network of enemy.
2) The min-cut problem can be used to study reliability of a network (smallest number of edges that can
fail).
3) Study of network optimization (find a maximum flow).
4) Clustering problems (edges like associations rules) Matching problems (an NC algorithm for min-cut in
directed graphs would result in an NC algorithm for maximum matching in bipartite graphs)
5) Matching problems (an NC algorithm for min-cut in directed graphs would result in an NC algorithm for
maximum matching in bipartite graphs)
Sources:
https://www.youtube.com/watch?v=-UuivvyHPas
http://disi.unal.edu.co/~gjhernandezp/psc/lectures/02/MinCut.pdf
discussed above.
Find the point where maximum intervals overlap
Consider a big party where a log register for guest’s entry and exit times is maintained. Find the time at
which there are maximum guests in the party. Note that entries in register are not in any order.
Example:
Input: arrl[] = {1, 2, 9, 5, 5}

exit[] = {4, 5, 12, 9, 12}
First guest in array arrives at 1 and leaves at 4,
second guest arrives at 2 and leaves at 5, and so on.
Output: 5
There are maximum 3 guests at time 5.

Below is a Simple Method to solve this problem.
1) Traverse all intervals and find min and max time (time at which first guest arrives and time at which last
guest leaves)
2) Create a count array of size ‘max – min + 1′. Let the array be count[].
3) For each interval [x, y], run a loop for i = x to y and do following in loop.
count[i – min]++;
4) Find the index of maximum element in count array. Let this index be ‘max_index’, return max_index +
min.
Above solution requires O(max-min+1) extra space. Also time complexity of above solution depends on
lengths of intervals. In worst case, if all intervals are from ‘min’ to ‘max’, then time complexity becomes
O((max-min+1)*n) where n is number of intervals.
An Efficient Solution is to use sorting n O(nLogn) time. The idea is to consider all events (all arrivals and
exits) in sorted order. Once we have all events in sorted order, we can trace the number of guests at any time
keeping track of guests that have arrived, but not exited.
Consider the above example.

arr[] = {1, 2, 10, 5, 5}

dep[] = {4, 5, 12, 9, 12}
Below are all events sorted by time. Note that in sorting, if two
events have same time, then arrival is preferred over exit.
Time Event Type Total Number of Guests Present
------------------------------------------------------------
1 Arrival 1
2 Arrival 2
4 Exit 1
5 Arrival 2
5 Arrival 3 // Max Guests
5 Exit 2
9 Exit 1
10 Arrival 2
12 Exit 1
12 Exit 0

Total number of guests at any time can be obtained by subtracting

total exits from total arrivals by that time.
So maximum guests are three at time 5.
Following is C++ implementation of above approach. Note that the implementation doesn’t create a single
sorted list of all events, rather it individually sorts arr[] and dep[] arrays, and then uses merge process of
merge sort to process them together as a single sorted array.

// Program to find maximum guest at any time in a party

#include<iostream>
#include<algorithm>
void findMaxGuests(int arrl[], int exit[], int n)

{
// Sort arrival and exit arrays
sort(arrl, arrl+n);
sort(exit, exit+n);
// guests_in indicates number of guests at a time

int guests_in = 1, max_guests = 1, time = arrl[0];
int i = 1, j = 0;
// Similar to merge in merge sort to process

// all events in sorted order
while (i < n && j < n)
{
// If next event in sorted order is arrival,
// increment count of guests
if (arrl[i] <= exit[j])
{
guests_in++;
// Update max_guests if needed

if (guests_in > max_guests)
{
max_guests = guests_in;
time = arrl[i];
}
i++; //increment index of arrival array
}
else // If event is exit, decrement count
{ // of guests.
guests_in--;
j++;
}
}
cout << "Maximum Number of Guests = " << max_guests

<< " at time " << time;
}

int main()
{
int arrl[] = {1, 2, 10, 5, 5};
int exit[] = {4, 5, 12, 9, 12};
int n = sizeof(arrl)/sizeof(arrl[0]);
findMaxGuests(arrl, exit, n);
return 0;
}

Output:

Maximum Number of Guests = 3 at time 5

Time Complexity of this method is O(nLogn).
discussed above
Find a pair with maximum product in array of Integers
Given an array with both +ive and -ive integers, return a pair with highest product.
Examples:
Input: arr[] = {1, 4, 3, 6, 7, 0}

Output: {6,7}
Input: arr[] = {-1, -3, -4, 2, 0, -5}

Output: {-4,-5}

Source: http://qa.geeksforgeeks.org/446/return-a-pair-with-maximum-product-in-array-of-integers/
A Simple Solution is to consider every pair and keep track maximum product. Below is C++
implementation of this simple solution.

// A simple C++ program to find max product pair in

// an array of integers
// Function to find maximum product pair in arr[0..n-1]

void maxProduct(int arr[], int n)
{
if (n < 2)
{
cout << "No pairs exists\n";
return;
}
// Initialize max product pair

int a = arr[0], b = arr[1];
// Traverse through every possible pair

// and keep track of max product
if (arr[i]*arr[j] > a*b)
a = arr[i], b = arr[j];
cout << "Max product pair is {" << a << ", "
<< b << "}";
}
// Driver program to test

int main()
{
int arr[] = {1, 4, 3, 6, 7, 0};
maxProduct(arr, n);
return 0;
}

Output:

Max product pair is {6, 7}

A Better Solution is to use sorting. Below are detailed steps.

1) Sort input array in increasing order.
2) If all elements are positive, then return product of last two numbers.
3) Else return maximum of products of first two and last two numbers.
Time complexity of this solution is O(nLog n). Thanks to Rahul Jain for suggesting this method.
An Efficient Solution can solve the above problem in single traversal of input array. The idea is to
traverse the input array and keep track of following four values.
a) Maximum positive value
b) Second maximum positive value
c) Maximum negative value i.e., a negative value with maximum absolute value
d) Second maximum negative value.
At the end of the loop, compare the products of first two and last two and print the maximum of two
products. Below is C++ implementation of this idea.
// A O(n) C++ program to find maximum product pair in an array

// Function to find maximum product pair in arr[0..n-1]

void maxProduct(int arr[], int n)
{
if (n < 2)
{
cout << "No pairs exists\n";
return;
}
if (n == 2)
{
cout << arr[0] << " " << arr[1] << endl;
return;
}
// Iniitialize maximum and second maximum

int posa = INT_MIN, posb = INT_MIN;
// Iniitialize minimum and second minimum

int nega = INT_MIN, negb = INT_MIN;
// Traverse given array

for (int i = 0; i < n; i++)
{
// Update maximum and second maximum if needed
if (arr[i] > posa)
{
posb = posa;
posa = arr[i];
}
else if (arr[i] > posb)
posb = arr[i];
// Update minimum and second minimum if needed

if (arr[i] < 0 && abs(arr[i]) > abs(nega))
{
negb = nega;
nega = arr[i];
}
else if(arr[i] < 0 && abs(arr[i]) > abs(negb))
negb = arr[i];
}
if (nega*negb > posa*posb)

cout << "Max product pair is {" << nega << ", "
<< negb << "}";
else
cout << "Max product pair is {" << posa << ", "
<< posb << "}";
}

int main()
int main()
{
int arr[] = {1, 4, 3, 6, 7, 0};
maxProduct(arr, n);
return 0;
}

Output:

Max product pair is {6, 7}


discussed above
How to sort a big array with many repetitions?
Consider a big array where elements are from a small set and in any range, i.e. there are many repetitions.
How to efficiently sort the array?
Example:
Input: arr[] = {100, 12, 100, 1, 1, 12, 100, 1, 12, 100, 1, 1}
Output: arr[] = {1, 1, 1, 1, 1, 12, 12, 12, 100, 100, 100, 100}

A Basic Sorting algorithm like MergeSort, HeapSort would take O(nLogn) time where n is number of
elements, can we do better?
A Better Solution is to use Self-Balancing Binary Search Tree like AVL or Red-Black to sort in O(n Log m)
time where m is number of distinct elements. The idea is to extend tree node to have count of keys also.
struct Node
{
int key;
struct Node *left. *right;
int count; // Added to handle duplicates
// Other tree node info for balancing like height in AVL

}

Below is complete algorithm using AVL tree.

1) Create an empty AVL Tree with count as an additional field.
2) Traverse input array and do following for every element ‘arr[i]’
…..a) If arr[i] is not present in tree, then insert it and initialize count as 1
…..b) Else increment its count in tree.
3) Do Inorder Traversal of tree. While doing inorder put every key its count times in arr[].
The 2nd step takes O(n Log m) time and 3rd step takes O(n) time. So overall time complexity is O(n Log m)
// C++ program to sort an array using AVL tree

#include<iostream>
// An AVL tree Node

struct Node
{
int key;
int height, count;
};
// Function to isnert a key in AVL Tree, if key is already present,

// then it increments count in key's node.
// then it increments count in key's node.
struct Node* insert(struct Node* Node, int key);
// This function puts inorder traversal of AVL Tree in arr[]

void inorder(int arr[], struct Node *root, int *index_ptr);
// An AVL tree based sorting function for sorting an array with

// duplicates
void sort(int arr[], int n)
{
// Create an empty AVL Tree
// Insert all nodes one by one in AVL tree. The insert function
// increments count if key is already present
root = insert(root, arr[i]);
// Do inorder traversal to put elements back in sorted order

int index = 0;
inorder(arr, root, &index);
}
// This function puts inorder traversal of AVL Tree in arr[]

void inorder(int arr[], struct Node *root, int *index_ptr)
{
if (root != NULL)
{
// Recur for left child
inorder(arr, root->left, index_ptr);
// Put all occurrences of root's key in arr[]

for (int i=0; i<root->count; i++)
{
arr[*index_ptr] = root->key;
(*index_ptr)++;
}
// Recur for right child

inorder(arr, root->right, index_ptr);
}
}

int height(struct Node *N)
{
if (N == NULL)
return 0;
return N->height;
}
// Helper function that allocates a new Node

struct Node* newNode(int key)
{
node->key = key;
node->height = node->count = 1;
return(node);
}
// A utility function to right rotate subtree rooted

// with y.
struct Node *rightRotate(struct Node *y)
{
{
struct Node *x = y->left;
struct Node *T2 = x->right;
// Perform rotation
x->right = y;
y->left = T2;
// Update heights
// Return new root

return x;
}

struct Node *leftRotate(struct Node *x)
{
struct Node *y = x->right;
struct Node *T2 = y->left;
// Perform rotation
y->left = x;
x->right = T2;
// Update heights
// Return new root

return y;
}
// Get Balance factor of Node N

int getBalance(struct Node *N)
{
if (N == NULL)
return 0;
}
// Function to isnert a key in AVL Tree, if key is already

// present, then it increments count in key's node.
struct Node* insert(struct Node* Node, int key)
{
if (Node == NULL)
return (newNode(key));
// If key already exists in BST, icnrement count and return

if (key == Node->key)
{
(Node->count)++;
return Node;
}

if (key < Node->key)
Node->left = insert(Node->left, key);
else
Node->right = insert(Node->right, key);
/* 2. Update height of this ancestor Node */

Node->height = max(height(Node->left), height(Node->right)) + 1;
Node->height = max(height(Node->left), height(Node->right)) + 1;
/* 3. Get the balance factor of this ancestor Node to

check whether this Node became unbalanced */
int balance = getBalance(Node);
// If this Node becomes unbalanced, then there are 4 cases
// Left Left Case

if (balance > 1 && key < Node->left->key)
return rightRotate(Node);
// Right Right Case

if (balance < -1 && key > Node->right->key)
return leftRotate(Node);
// Left Right Case

if (balance > 1 && key > Node->left->key)
{
Node->left = leftRotate(Node->left);
return rightRotate(Node);
}
// Right Left Case

if (balance < -1 && key < Node->right->key)
{
Node->right = rightRotate(Node->right);
return leftRotate(Node);
}
/* return the (unchanged) Node pointer */

return Node;
}

{
cout << arr[i] << ", ";
cout << endl;
}

int main()
{
int arr[] = {100, 12, 100, 1, 1, 12, 100, 1, 12, 100, 1, 1};
cout << "Input array is\n";

printArr(arr, n);
sort(arr, n);
cout << "Sorted array is\n";

printArr(arr, n);
}

Output:

Input array is
100, 12, 100, 1, 1, 12, 100, 1, 12, 100, 1, 1,
Sorted array is
1, 1, 1, 1, 1, 12, 12, 12, 100, 100, 100, 100,

We can also use Binary Heap to solve in O(n Log m) time.

We can also use Hashing to solve above problem in O(n + m Log m) time .
1) Create an empty hash table. Input array values are stores as key and their counts are stored as value in
hash table.
2) For every element ‘x’ of arr[], do following
…..a) If x ix present in hash table, increment its value
…..b) Else insert x with value equals to 1.
3) Consider all keys of hash table and sort them.
4) Traverse all sorted keys and print every key its value times.
Time complexity of 2nd step is O(n) under the assumption that hash search and insert take O(1) time. Step 3
takes O(m Log m) time where m is total number of distinct keys in input array. Step 4 takes O(n) time. So
overall time complexity is O(n + m Log m).
Find the element that appears once in a sorted array
Given a sorted array in which all elements appear twice (one after one) and one element appears only once.
Find that element in O(log n) complexity.
Example:
Input: arr[] = {1, 1, 3, 3, 4, 5, 5, 7, 7, 8, 8}

Output: 4
Input: arr[] = {1, 1, 3, 3, 4, 4, 5, 5, 7, 7, 8}

Output: 8

A Simple Solution is to traverse the array from left to right. Since the array is sorted, we can easily figure
out the required element.
An Efficient Solution can find the required element in O(Log n) time. The idea is to use Binary Search.
Below is an observation in input array.
All elements before the required have first occurrence at even index (0, 2, ..) and next occurrence at odd
index (1, 3, …). And all elements after the required element have first occurrence at odd index and next
occurrence at even index.
1) Find the middle index, say ‘mid’.
2) If ‘mid’ is even, then compare arr[mid] and arr[mid + 1]. If both are same, then the required element after
‘mid’ else before mid.
3) If ‘mid’ is odd, then compare arr[mid] and arr[mid – 1]. If both are same, then the required element after
‘mid’ else before mid.

// C program to find the element that appears only once

#include<stdio.h>
// A Binary Search based function to find the element

// that appears only once
void search(int *arr, int low, int high)
{
// Base cases
if (low > high)
return;
if (low==high)
{
printf("The required element is %d ", arr[low]);
return;
}

int mid = (low + high) / 2;
// If mid is even and element next to mid is

// same as mid, then output element lies on
// right side, else on left side
if (mid%2 == 0)
{
if (arr[mid] == arr[mid+1])
search(arr, mid+2, high);
else
search(arr, low, mid);
}
else // If mid is odd
{
if (arr[mid] == arr[mid-1])
search(arr, mid-2, high);
else
search(arr, low, mid-1);
}
}
// Driver program
int main()
{
int arr[] = {1, 1, 2, 4, 4, 5, 5, 6, 6};
int len = sizeof(arr)/sizeof(arr[0]);
search(arr, 0, len-1);
return 0;
}

Output:

The required element is 2

Time Complexity: O(Log n)
This article is contributed by Mehboob Elahi. Please write comments if you find anything incorrect, or you
Find the odd appearing element in O(Log n) time
Given an array where all elements appear even number of times except one. All repeating occurrences of
elements appear in pairs and these pairs are not adjacent (there cannot be more than two consecutive
occurrences of any element). Find the element that appears odd number of times.
Note that input like {2, 2, 1, 2, 2, 1, 1} is valid as all repeating occurrences occur in pairs and these pairs are
not adjacent. Input like {2, 1, 2} is invalid as repeating elements don’t appear in pairs. Also, input like {1, 2,
2, 2, 2} is invalid as two pairs of 2 are adjacent. Input like {2, 2, 2, 1} is also invalid as there are three
consecutive occurrences of 2.
Example:
Input: arr[] = {1, 1, 2, 2, 1, 1, 2, 2, 13, 1, 1, 40, 40, 13, 13}

Output: 13
Input: arr[] = {1, 1, 2, 2, 3, 3, 4, 4, 3, 600, 600, 4, 4}

Output: 3

A Simple Solution is to sort the array and then traverse the array from left to right. Since the array is
sorted, we can easily figure out the required element. Time complexity of this solution is O(n Log n)
A Better Solution is to do XOR of all elements, result of XOR would give the odd appearing element. Time
complexity of this solution is O(n). See XOR based solution for add apearing for more details.
An Efficient Solution can find the required element in O(Log n) time. The idea is to use Binary Search.
Below is an observation in input array.
Since the element appears odd number of times, there must be a single occurrence of the element. For
example, in {2, 1, 1, 2, 2), the first 2 is the odd occurrence. So the idea is to find this odd occurrence using
Binary Search.
All elements before the odd occurrence have first occurrence at even index (0, 2, ..) and next occurrence at
odd index (1, 3, …). And all elements afterhave first occurrence at odd index and next occurrence at even
index.
1) Find the middle index, say ‘mid’.
2) If ‘mid’ is even, then compare arr[mid] and arr[mid + 1]. If both are same, then there is an odd occurrence
of the element after ‘mid’ else before mid.
3) If ‘mid’ is odd, then compare arr[mid] and arr[mid – 1]. If both are same, then there is an odd occurrence
after ‘mid’ else before mid.

// C program to find the element that appears odd number of time

#include<stdio.h>
// A Binary Search based function to find the element

// that appears odd times
void search(int *arr, int low, int high)
{
// Base cases
if (low > high)
return;
if (low==high)
{
printf("The required element is %d ", arr[low]);
return;
}

int mid = (low+high)/2;
// If mid is even and element next to mid is

// same as mid, then output element lies on
// right side, else on left side
if (mid%2 == 0)
{
if (arr[mid] == arr[mid+1])
else
search(arr, low, mid);
}
else // If mid is odd
{
if (arr[mid] == arr[mid-1])
else
search(arr, low, mid-1);
}
}
// Driver program
int main()
{
int arr[] = {1, 1, 2, 2, 1, 1, 2, 2, 13, 1, 1, 40, 40};
int len = sizeof(arr)/sizeof(arr[0]);
search(arr, 0, len-1);
return 0;
}

Output:

The required element is 13

Time Complexity: O(Log n)
This article is contributed by Mehboob Elahi. Please write comments if you find anything incorrect, or you
Sort a linked list that is sorted alternating ascending and descending
orders?
Given a Linked List. The Linked List is in alternating ascending and descending orders. Sort the list
efficiently.
Example:

Input List: 10->40->53->30->67->12->89->NULL
Output List: 10->12->30->43->53->67->89->NULL

Source: http://qa.geeksforgeeks.org/616/linked-that-sorted-alternating-ascending-descending-orders
A Simple Solution is to use Merge Sort for linked List. This solution takes O(n Log n) time.
An Efficient Solution works in O(n) time. Below are all steps.

1. Separate two lists.
2. Reverse the one with descending order
3. Merge both lists. Below is C++ implementation based on above idea.
// Sort a linked list that is alternatively sorted

// in increasing and decreasing order
// Linked list node

struct Node
{
int data;
struct Node *next;
};
Node *mergelist(Node *head1, Node *head2);

void splitList(Node *head, Node **Ahead, Node **Dhead);
void reverselist(Node *&head);
// This is the main function that sorts the

// linked list
void sort(Node **head)
{
// Split the list into lists
Node *Ahead, *Dhead;
splitList(*head, &Ahead, &Dhead);
// Reverse the descending linked list

reverselist(Dhead);
// Merge the two linked lists

*head = mergelist(Ahead, Dhead);
}

{
temp->data = key;
temp->next = NULL;
return temp;
}
// A utility function to reverse a linked list

void reverselist(Node *&head)
{
Node* prev = NULL, *curr = head, *next;
while (curr)
{
next = curr->next;
curr->next = prev;
prev = curr;
curr = next;
}
head = prev;
}

void printlist(Node *head)
{
{
head = head->next;
}
cout << endl;
}
// A utility function to merge two sorted linked lists

Node *mergelist(Node *head1, Node *head2)
{
// Base cases
if (!head1) return head2;
if (!head2) return head1;
Node *temp = NULL;

if (head1->data < head2->data)
{
temp = head1;
head1->next = mergelist(head1->next, head2);
}
else
{
temp = head2;
head2->next = mergelist(head1, head2->next);
}
return temp;
}
// This function alternatively splits a linked list with head

// as head into two:
// For example, 10->20->30->15->40->7 is splitted into 10->30->40
// and 20->15->7
// "Ahead" is reference to head of ascending linked list
// "Dhead" is reference to head of descending linked list
void splitList(Node *head, Node **Ahead, Node **Dhead)
{
// Create two dummy nodes to initialize heads of two linked list
*Ahead = newNode(0);
*Dhead = newNode(0);
*Dhead = newNode(0);
Node *ascn = *Ahead;

Node *dscn = *Dhead;
Node *curr = head;
// Link alternate nodes

while (curr)
{
// Link alternate nodes of ascending linked list
ascn->next = curr;
ascn = ascn->next;
curr = curr->next;
// Link alternate nodes of descending linked list

if (curr)
{
dscn->next = curr;
dscn = dscn->next;
curr = curr->next;
}
}
ascn->next = NULL;
dscn->next = NULL;
*Ahead = (*Ahead)->next;
*Dhead = (*Dhead)->next;
}

int main()
{
Node *head = newNode(10);
head->next = newNode(40);
head->next->next = newNode(53);
head->next->next->next = newNode(30);
head->next->next->next->next = newNode(67);
head->next->next->next->next->next = newNode(12);
head->next->next->next->next->next->next = newNode(89);
cout << "Given Linked List is " << endl;

printlist(head);
sort(&head);
cout << "\nSorted Linked List is " << endl;

printlist(head);
return 0;
}

Output:

Given Linked List is
10 40 53 30 67 12 89
Sorted Linked List is

10 12 30 40 53 67 89

Thanks to Gaurav Ahirwar for suggesting this method here.
discussed above
K’th smallest element in BST using O(1) Extra Space
Given a Binary Search Tree (BST) and a positive integer k, find the k’th smallest element in the Binary
Search Tree.
We have discussed two methods in this post and one method in this post. All of the previous methods require
extra space. How to find the k’th largest element without extra space?
Implementation
The idea is to use Morris Traversal. In this traversal, we first create links to Inorder successor and print the
data using these links, and finally revert the changes to restore original tree. See this for more details.
Below is C++ implementation of the idea.
// C++ program to find k'th largest element in BST

#include<iostream>
#include<climits>
// A BST node
struct Node
{
int key;
Node *left, *right;
};
// A function to find
int KSmallestUsingMorris(Node *root, int k)
{
// Count to iterate over elements till we
// get the kth smallest number
int count = 0;
int ksmall = INT_MIN; // store the Kth smallest

Node *curr = root; // to store the current node
while (curr != NULL)

{
// Like Morris traversal if current does
// not have left child rather than printing
// as we did in inorder, we will just
// increment the count as the number will
// be in an increasing order
if (curr->left == NULL)
{
count++;
// if count is equal to K then we found the

// kth smallest, so store it in ksmall
if (count==k)
ksmall = curr->key;
// go to current's right child

curr = curr->right;
}
else
{
// we create links to Inorder Successor and
// count using these links
Node *pre = curr->left;
while (pre->right != NULL && pre->right != curr)
pre = pre->right;
// building links
if (pre->right==NULL)
{
//link made to Inorder Successor
pre->right = curr;
curr = curr->left;
}
// While breaking the links in so made temporary

// threaded tree we will check for the K smallest
// condition
else
{
// Revert the changes made in if part (break link
// from the Inorder Successor)
pre->right = NULL;
count++;
// If count is equal to K then we found

// the kth smallest and so store it in ksmall
if (count==k)
ksmall = curr->key;
curr = curr->right;
}
}
}
return ksmall; //return the found value
}

{
temp->key = item;
return temp;
}

{


return node;
}

int main()
{
50
/ \
30 70
/ \ / \
20 40 60 80 */
Node *root = NULL;
insert(root, 30);
insert(root, 20);
insert(root, 40);
insert(root, 70);
insert(root, 60);
insert(root, 80);
for (int k=1; k<=7; k++)

cout << KSmallestUsingMorris(root, k) << " ";
return 0;
}

Output:

20 30 40 50 60 70 80

This article is contributed by Abhishek Somani. Please write comments if you find anything incorrect, or you
Construct all possible BSTs for keys 1 to N
In this article, first count of possible BST (Binary Search Trees)s is discussed, then construction of all
possible BSTs.
How many structurally unique BSTs for keys from 1..N?
For example, for N = 2, there are 2 unique BSTs

1 2
\ /
2 1
For N = 3, there are 5 possible BSTs

1 3 3 2 1
\ / / / \ \
3 2 1 1 3 2
/ / \ \
2 1 2 3

We know that all node in left subtree are smaller than root and in right subtree are larger than root so if we
have ith number as root, all numbers from 1 to i-1 will be in left subtree and i+1 to N will be in right subtree.
If 1 to i-1 can form x different trees and i+1 to N can from y different trees then we will have x*y total trees
when ith number is root and we also have N choices for root also so we can simply iterate from 1 to N for root
and another loop for left and right subtree. If we take a closer look, we can notice that the count is basically
n’th Catalan number. We have discussed different approaches to find n’th Catalan number here.

How to construct all BST for keys 1..N?
The idea is to maintain a list of roots of all BSTs. Recursively construct all possible left and right subtrees.
Create a tree for every pair of left and right subtree and add the tree to list. Below is detailed algorithm.
1) Initialize list of BSTs as empty.

2) For every number i where i varies from 1 to N, do following
......a) Create a new node with key as 'i', let this node be 'node'
......b) Recursively construct list of all left subtrees.
......c) Recursively construct list of all right subtrees.
3) Iterate for all left subtrees
a) For current leftsubtree, iterate for all right subtrees
Add current left and right subtrees to 'node' and add
'node' to list.


// A C++ prgroam to contrcut all unique BSTs for keys from 1 to n
#include <iostream>
#include<vector>
// node structure
struct node
struct node
{
int key;
};

{
struct node *temp = new node;
temp->key = item;
return temp;
}
// A utility function to do preorder traversal of BST

void preorder(struct node *root)
{
if (root != NULL)
{
}
}
// function for constructing trees

vector<struct node *> constructTrees(int start, int end)
{
vector<struct node *> list;
/* if start > end then subtree will be empty so returning NULL

in the list */
if (start > end)
{
list.push_back(NULL);
return list;
}
/* iterating through all values from start to end for constructing\

left and right subtree recursively */
for (int i = start; i <= end; i++)
{
/* constructing left subtree */
vector<struct node *> leftSubtree = constructTrees(start, i - 1);
/* constructing right subtree */

vector<struct node *> rightSubtree = constructTrees(i + 1, end);
/* now looping through all left and right subtrees and connecting
them to ith root below */
for (int j = 0; j < leftSubtree.size(); j++)
{
struct node* left = leftSubtree[j];
for (int k = 0; k < rightSubtree.size(); k++)
{
struct node * right = rightSubtree[k];
struct node * node = newNode(i);// making value i as root
node->left = left; // connect left subtree
node->right = right; // connect right subtree
list.push_back(node); // add this tree to list
}
}
}
return list;
return list;
}

int main()
{
// Construct all possible BSTs
vector<struct node *> totalTreesFrom1toN = constructTrees(1, 3);
/* Printing preorder traversal of all constructed BSTs */

cout << "Preorder traversal of all constructed BSTs is \n";
for (int i = 0; i < totalTreesFrom1toN.size(); i++)
{
preorder(totalTreesFrom1toN[i]);
cout << endl;
}
return 0;
}

Output:

Preorder traversal of all constructed BSTs is
1 2 3
1 3 2
2 1 3
3 1 2
3 2 1

This article is contributed by Utkarsh Trivedi. Please write comments if you find anything incorrect, or
Z algorithm (Linear time pattern searching Algorithm)
This algorithm finds all occurrences of a pattern in a text in linear time. Let length of text be n and of pattern
be m, then total time taken is O(m + n) with linear space complexity. Now we can see that both time and
space complexity is same as KMP algorithm but this algorithm is Simpler to understand.
In this algorithm, we construct a Z array.
What is Z Array?
For a string str[0..n-1], Z array is of same length as string. An element Z[i] of Z array stores length of the
longest substring starting from str[i] which is also a prefix of str[0..n-1]. The first entry of Z array is meaning
less as complete string is always prefix of itself.
Example:
Index 0 1 2 3 4 5 6 7 8 9 10 11
Text a a b c a a b x a a a z
Z values X 1 0 0 3 1 0 0 2 2 1 0

More Examples:
str = "aaaaaa"
Z[] = {x, 5, 4, 3, 2, 1}
str = "aabaacd"
Z[] = {x, 1, 0, 2, 1, 0, 0}
str = "abababab"
Z[] = {x, 0, 6, 0, 4, 0, 2, 0}

How is Z array helpful in Searching Pattern in Linear time?

The idea is to concatenate pattern and text, and create a string “P$T” where P is pattern, $ is a special
character should not be present in pattern and text, and T is text. Build the Z array for concatenated string.
In Z array, if Z value at any point is equal to pattern length, then pattern is present at that point.
Example:
Pattern P = "aab", Text T = "baabaa"
The concatenated string is = "aab$baabaa"
Z array for above concatenated string is {x, 1, 0, 0, 0,

3, 1, 0, 2, 1}.
Since length of pattern is 3, the value 3 in Z array
indicates presence of pattern.

How to construct Z array?

A Simple Solution is two run two nested loops, the outer loop goes to every index and the inner loop finds
length of the longest prefix that matches substring starting at current index. The time complexity of this
solution is O(n2).
We can construct Z array in linear time.
The idea is to maintain an interval [L, R] which is the interval with max R
such that [L,R] is prefix substring (substring which is also prefix).
Steps for maintaining this interval are as follows –
1) If i > R then there is no prefix substring that starts before i and

ends after i, so we reset L and R and compute new [L,R] by comparing
str[0..] to str[i..] and get Z[i] (= R-L+1).
2) If i = min(Z[K], R-i+1) because

str[i..] matches with str[K..] for atleast R-i+1 characters (they are in
[L,R] interval which we know is a prefix substring).
Now two sub cases arise –
a) If Z[K] = R-i+1 then it is possible to extend the [L,R] interval
thus we will set L as i and start matching from str[R] onwards and
get new R then we will update interval [L,R] and calculate Z[i] (=R-L+1).

For better understanding of above step by step procedure please check this animation –
http://www.utdallas.edu/~besp/demo/John2010/z-algorithm.htm
The algorithm runs in linear time because we never compare character less than R and with matching we
increase R by one so there are at most T comparisons. In mismatch case, mismatch happen only once for
each i (because of which R stops), that’s another at most T comparison making overall linear complexity.
Below is C++ implementation of Z algorithm for pattern searching.
// A C++ program that implements Z algorithm for pattern searching

#include<iostream>
void getZarr(string str, int Z[]);
// prints all occurrences of pattern in text using Z algo

void search(string text, string pattern)
{
// Create concatenated string "P$T"
string concat = pattern + "$" + text;
int l = concat.length();
// Construct Z array
int Z[l];
getZarr(concat, Z);
// now looping through Z array for matching condition

for (int i = 0; i < l; ++i)
{
// if Z[i] (matched region) is equal to pattern
// length we got the pattern
if (Z[i] == pattern.length())
cout << "Pattern found at index "
<< i - pattern.length() -1 << endl;
}
}
// Fills Z array for given string str[]
void getZarr(string str, int Z[])
{
int L, R, k;
// [L,R] make a window which matches with prefix of s

L = R = 0;
for (int i = 1; i < n; ++i)
{
// if i>R nothing matches so we will calculate.
// Z[i] using naive way.
if (i > R)
{
L = R = i;
// R-L = 0 in starting, so it will start

// checking from 0'th index. For example,
// for "ababab" and i = 1, the value of R
// remains 0 and Z[i] becomes 0. For string
// "aaaaaa" and i = 1, Z[i] and R become 5
while (R<n && str[R-L] == str[R])
R++;
Z[i] = R-L;
R--;
}
else
{
// k = i-L so k corresponds to number which
// matches in [L,R] interval.
k = i-L;
// if Z[k] is less than remaining interval

// then Z[i] will be equal to Z[k].
// For example, str = "ababab", i = 3, R = 5
// and L = 2
if (Z[k] < R-i+1)
Z[i] = Z[k];
// For example str = "aaaaaa" and i = 2, R is 5,

// L is 0
else
{
// else start from R and check manually
L = i;
while (R<n && str[R-L] == str[R])
R++;
Z[i] = R-L;
R--;
}
}
}
}
// Driver program
int main()
{
string text = "GEEKS FOR GEEKS";
string pattern = "GEEK";
search(text, pattern);
return 0;
}

Output:


Find sum of all elements in a matrix except the elements in row and/or
column of given cell?
Given a 2D matrix and a set of cell indexes e.g., an array of (i, j) where i indicates row and j column. For every
given cell index (i, j), find sums of all matrix elements except the elements present in i’th row and/or j’th
column.
Example:
mat[][] = { {1, 1, 2}
{3, 4, 6}
{5, 3, 2} }
Array of Cell Indexes: {(0, 0), (1, 1), (0, 1)}
Output: 15, 10, 16

Source: http://qa.geeksforgeeks.org/622/select-column-matrix-then-find-remaining-elements-matrices?
show=625#a625
A Naive Solution is to one by once consider all given cell indexes. For every cell index (i, j), find the sum of
matrix elements that are not present either at i’th row or at j’th column. Below is C++ implementation of the
Naive approach.

#define R 3
#define C 3
// A structure to represent a cell index

struct Cell
{
int r; // r is row, varies from 0 to R-1
int c; // c is column, varies from 0 to C-1
};
// A simple solution to find sums for a given array of cell indexes

void printSums(int mat[][C], struct Cell arr[], int n)
{
// Iterate through all cell indexes
{
int sum = 0, r = arr[i].r, c = arr[i].c;
// Compute sum for current cell index

for (int j=0; j<R; j++)
for (int k=0; k<C; k++)
if (j != r && k != c)
sum += mat[j][k];
cout << sum << endl;
}
}

int main()
{
int mat[][C] = {{1, 1, 2}, {3, 4, 6}, {5, 3, 2}};
struct Cell arr[] = {{0, 0}, {1, 1}, {0, 1}};
printSums(mat, arr, n);
return 0;
}

Output:

15
10
16

Time complexity of the above solution is O(n * R * C) where n is number of given cell indexes and R x C is
matrix size.
An Efficient Solution can compute all sums in O(R x C + n) time. The idea is to precompute total sum,
row and column sums before processing the given array of indexes. Below are details
1. Calculate sum of matrix, call it sum.
2. Calculate sum of individual rows and columns. (row[] and col[])
3. For a cell index (i, j), the desired sum will be “sum- row[i] – col[j] + arr[i][j]”
// An efficient C++ program to compute sum for given array of cell indexes
#define R 3
#define C 3
// A structure to represent a cell index

struct Cell
{
int r; // r is row, varies from 0 to R-1
int c; // c is column, varies from 0 to C-1
};
void printSums(int mat[][C], struct Cell arr[], int n)

{
int sum = 0;
int row[R] = {};
int col[C] = {};
// Compute sum of all elements, sum of every row and sum every column
{
for (int j=0; j<C; j++)
{
sum += mat[i][j];
col[j] += mat[i][j];
row[i] += mat[i][j];
}
}
// Compute the desired sum for all given cell indexes

{
int ro = arr[i].r, co = arr[i].c;
cout << sum - row[ro] - col[co] + mat[ro][co] << endl;
}
}

int main()
{
int mat[][C] = {{1, 1, 2}, {3, 4, 6}, {5, 3, 2}};
struct Cell arr[] = {{0, 0}, {1, 1}, {0, 1}};
printSums(mat, arr, n);
return 0;
}

Output:

15
10
16

Time Complexity: O(R x C + n)
Auxiliary Space: O(R + C)
Thanks to Gaurav Ahirwar for suggesting this efficient solution here.
discussed above
Rotate Matrix Elements
Given a matrix, clockwise rotate elements in it.
Examples:
Input
1 2 3
4 5 6
7 8 9
Output:
4 1 2
7 5 3
8 9 6
For 4*4 matrix

Input:
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 16
Output:
5 1 2 3
9 10 6 4
13 11 7 8
14 15 16 12

The idea is to use loops similar to the program for printing a matrix in spiral form. One by one rotate all
rings of elements, starting from the outermost. To rotate a ring, we need to do following.
1) Move elements of top row.
2) Move elements of last column.
3) Move elements of bottom row.
4) Move elements of first column.
Repeat above steps for inner ring while there is an inner ring.
Below is C++ implementation of above idea. Thanks to Gaurav Ahirwar for suggesting below solution
here.
// C++ program to rotate a matrix
#define R 4
#define C 4
// A function to rotate a matrix mat[][] of size R x C.

// Initially, m = R and n = C
void rotatematrix(int m, int n, int mat[R][C])
{
int row = 0, col = 0;
int prev, curr;
/*
/*
row - Staring row index
col - starting column index
i - iterator
*/
while (row < m && col < n)
{
if (row + 1 == m || col + 1 == n)
break;
// Store the first element of next row, this

// element will replace first element of current
// row
prev = mat[row + 1][col];
/* Move elements of first row from the remaining rows */

for (int i = col; i < n; i++)
{
curr = mat[row][i];
mat[row][i] = prev;
prev = curr;
}
row++;
/* Move elements of last column from the remaining columns */

for (int i = row; i < m; i++)
{
curr = mat[i][n-1];
mat[i][n-1] = prev;
prev = curr;
}
n--;
/* Move elements of last row from the remaining rows */

if (row < m)
{
for (int i = n-1; i >= col; i--)
{
curr = mat[m-1][i];
mat[m-1][i] = prev;
prev = curr;
}
}
m--;
/* Move elements of first column from the remaining rows */

if (col < n)
{
for (int i = m-1; i >= row; i--)
{
curr = mat[i][col];
mat[i][col] = prev;
prev = curr;
}
}
col++;
}
// Print rotated matrix

{
cout << mat[i][j] << " ";
cout << endl;
}
}

int main()
{
// Test Case 1
int a[R][C] = { {1, 2, 3, 4},
{5, 6, 7, 8},
{9, 10, 11, 12},
{13, 14, 15, 16} };
// Tese Case 2
/* int a[R][C] = {{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
*/ rotatematrix(R, C, a);
return 0;
}

Output:

5 1 2 3
9 10 6 4
13 11 7 8
14 15 16 12

discussed above
Search an element in an array where difference between adjacent elements
is 1
Given an array where difference between adjacent elements is 1, write an algorithm to search for an element
in the array and return the position of the element (return the first occurrence).
Examples:
Let element to be searched be x
Input: arr[] = {8, 7, 6, 7, 6, 5, 4, 3, 2, 3, 4, 3}

x = 3
Output: Element 3 found at index 7
Input: arr[] = {1, 2, 3, 4, 5, 4}

x = 5
Output: Element 5 found at index 4

A Simple Approach is to traverse the given array one by one and compare every element with given
element ‘x’. If matches, then return index.
The above solution can be Optimized using the fact that difference between all adjacent elements is 1. The
idea is to start comparing from the leftmost element and find the difference between current array element
and x. Let this difference be ‘diff’. From the given property of array, we always know that x must be at-least
‘diff’ away, so instead of searching one by one, we jump ‘diff’. Thanks to RajnishKrJha for suggesting this
solution here.

// C++ program to search an element in an array where

// difference between all elements is 1
// x is the elmenet to be searched in arr[0..n-1]

int search(int arr[], int n, int x)
{
// Travers the given array starting from
// leftmost element
int i = 0;
while (i<n)
{
// If x is found at index i
if (arr[i] == x)
return i;
// Jump the difference between current

// array element and x
i = i + abs(arr[i]-x);
}
cout << "number is not present!";

return -1;
}

int main()
{
int arr[] = {8 ,7, 6, 7, 6, 5, 4, 3, 2, 3, 4, 3 };
int x = 3;
cout << "Element " << x << " is present at index "
<< search(arr,n,3);
return 0;
}

Output:

Element 3 is present at index 7

Morgan Stanley Interview | Set 14 (On-Campus)
Morgan Stanley recently visited our campus for post of Tech & Full Time Analyst . So here is how it went.
1st Round: Coding and MCQ round:

There were 20 MCQs and 2 coding questions and the test was conducted on Hacker-rank platform.
The MCQs were based on topics like aptitude, Basic Data structures, OOP and some input output questions.
The first Coding question was comparatively easy and the 2nd coding question was also based on finding the
Maximum Sum Subarray.
I was able to code the first question and I could not get the time to solve the 2nd question, but my friends
told that it was easy and as the test cases were very weak so even O(N^3) also passed.
After this round, 29 students were called for technical interviews.
2nd Round: Technical PI:

My interview was one of the first to be scheduled. I don’t know if it was random or my aptitude went well.
But many of my friends were able to pass good number of test cases of the 2nd question as well and I was not
able to code the 2nd question.
1. He first asked me that if I were given a file in which there are alphanumeric characters, I
need to find the top 2 words having only alphabetic characters.
For example: “1. H1i hen 1ss you hen he s you hen he he 1ss 1ss¬“ should give the answer as
“he” and “hen”
I asked him if there were two words that have the same frequency then should I print the word which was
most recently accessed. He told me that it was my own choice to do so. I decided to implement this feature.
I first told him to use a Hash-map for each word. He asked me some questions as to how to check for the
numbers that come between the words and then I thought that there was many test cases to handle in this
approach.
Then I told him to use Trie and MinHeap. He then told me to code the logic and I did as I was told. I
explained all the corner cases prior to him and he seemed pretty happy with this solution.
2. Explain me Polymorphism using this Kinley bottle. I do not know anything about Java so
please do not use any jargons.
3. He asked me an SQL query which used GROUP BY but I cannot recollect the question .
4. Given an array, where only one number is repeating one number of times, find the
number. (Using XOR in one pass)
5. If there is no restriction on how frequently the number is going to repeat for example there
can be 5 numbers occurring 3 number of times and 2 number repeating 6 times and 1 number
repeating once, we need to find the number repeating once.
Example: “1 2 3 2 3 3 3 3 3 3 3 3 4 4 4 5 5 “has got 1 as the element repeating exactly once.
He told me to do it in one pass of the array only. I did it using Balanced BST and I wanted to improve on this
solution but as time was running out, he asked me to stop.
After this round, 11 students were selected for the next rounds. After this round there were no eliminations
and then results were declared.
3rd Round: Group Activity Round:

Out of 11 selected members, we were split up into teams of size 6 and 5. I was the one in the team of size 6.
The time allotted was 30 minutes and there was a mentor from their side who would check how we did after
15 minutes and give some suggestions.
We were given the following task:
We need to prepare an idea for a start-up and present our idea in front of group of investors. We were given
2 chart papers, a Lego kit, few markers and Play-Doh.
In the first chart paper we were told to prepare the logo, name of start-up, objectives, features.
In the other chart paper we were told to provide the Business model, Unique Selling Point of Idea and when
our company would start earning profits.
Our Approach:
We first discussed about the idea that we were going to work on. Amongst the brain-storming of ideas, I told
to do something related to Health Care sector. But as everyone was interested in the idea to provide training
for budding start-ups and work as the company to bridge the gap between investors and new ideas, we
decided to take this idea.
We divided ourselves into 2 groups of 3 each. I was in the group to prepare the logo and everything (i.e.
working on first chart).
Because I was not sure about the idea I asked some doubts to the person who had given the idea. I then
helped in giving the name to the company and preparing the logo for the company. I also helped in
cementing our objectives and features.
After 15 minutes, our mentor asked some questions related to uniqueness of our idea. He gave some advice
and then we were again back to the task.
Evaluation:
I was very nervous about this because there were more than 5 people evaluating us.
They asked us questions like:

a. We have already received such an idea. How is your idea unique?
b. Did you at any point of time think that the idea was not sustainable after deciding the idea?
c. How much did we require for our start-up and when would it start earning profits?
d. How will you publicise the start-up and how will people be attracted by you?
I was quiet during all of this and I simply nodded to what all were saying.
4th Round: HR Round:

1. Tell me something about yourself.
2. Tell me your family background.

Then there was some discussion about how I thought I performed in my previous rounds. I told him that I
am very strong technically so I was most comfortable during that round.
I frankly told him that I was not my best during the Group Activity Round and that I could have performed
better. He then asked me why I was not able to perform well during that round.
I told him that the idea was not my idea and in the initial stage I had to clear my doubts. Then after we
divided us in 2 teams, I was the one who gave the idea of the Logo and the name of the start-up.
I also told him that in all the group projects, I have been the leader and I have been the person who keeps
collecting the data before going to any meeting and that I was an active contributor to any of the group
meetings.
3. He gave me a scenario that if there is some person in my team who is not doing anything, what would I do.
I kept giving him response and he kept on saying that the person is too rigid to participate.
I finally told him that I would report to some higher authority.
4. What is the one quality about you that Morgan Stanley would hire you?
5. If I were to go to your college and ask your friends to list two qualities about you, what would they say?
6. Which is your weak point?
7. What is the problem that the Indian society is currently facing? He then asked me that if I were the
advisor to the finance minister and we had conflicting ideas, how I would go about solving that dispute.
8. What are your hobbies?
9. If you are given 2 opportunities, one is to pursue your hobby and the other is the programming job at
Morgan Stanley, how will you go about choosing one between them and also tell which will you choose.
I chose Programming Job.
10. If you have 2 job opportunities, Programming Job at Morgan Stanley and Programming Job at Google,
how will you go about choosing one of them?
11. Have you ever faced any situations where you had to choose between two things that are of equal priority,
how did you go about deciding which to choose?
12. Do you plan to go for higher studies? Why or Why Not?
13. 2 points that you have in mind about the presentation shown earlier about Morgan Stanley.
14. Any questions?
5th Round: HR Round/ Professional Fitness Round:

1. Tell me something about yourself.
2. Family Background.
3. Why did you choose Research Internship as compared to Industrial Internship?
4. How often you go back home? How often do you interact with your family?
5. Here too I told that I was not good in the Group Activity Round. He asked me many situational questions
as what you did during the brain storming of selection of an idea etc.
6. Any questions? I asked about the work culture at Morgan Stanley. I asked him what is the thing that keeps
the employees excited about the work they do because Excitement is the biggest driving factor for anyone.
6th Round: Technical PI

1. You need to evaluate an expression and the priority of operators would be given by the user. The
associativity of operators is Left to right. He asked me to code the question and then he reviewed it.
2. Database design Question:
Design Database for the pay roll system for various companies having many departments. Every employee
has his salary in 3 parts: Basic, HRA and PA. Every employee can have multiple accounts and he would give
the percentage of salary to be deposited in each account.
To summarize:
Each Company can have many department. If any employee is in 2 departments, than I had another tuple
for that. So an employee can be part of 2 departments.
Each Employee can have multiple accounts and Salary has 3 components: Basic, HRA and PA.
3. Query for the database:
Find the top 3 departments in each company that has got maximum sum of salaries of all employees under
that department.
4. Any Questions?
It was very lengthy process and they don’t just judge you technically, they see your situational response,
team management skills.
Here are some points that I think helped me to get selected:
a. Leadership shown during the Group Activity is not enough, you need to be the leader for your projects as
well.
b. HR interviews are very difficult because they are very frank and they are like rapid fire rounds, so do not
be fake. They are making notes about your personality and if you contradict with the response that you had
given earlier, they will catch you.
c. Confidence during Interviews as well as the Group Activity. Talk out loud to the interviewer, let him know
what is in your head.
Geeks.
Count factorial numbers in a given range
A number F is a factorial number if there exists some integer I >= 0 such that F = I! (that is, F is factorial of
I). Examples of factorial numbers are 1, 2, 6, 24, 120, ….
Write a program that takes as input two long integers ‘low’ and ‘high’ where 0 Input: 0 1 Output: 1 //Reason:
Only factorial number is 1 Input: 12 122 Output: 2 // Reason: factorial numbers are 24, 120 Input: 2 720
Output: 5 // Factorial numbers are: 2, 6, 24, 120, 720
Source: http://qa.geeksforgeeks.org/1137/counting-factorial-numbers-in-c
Below is an algorithm to count factorial numbers in a given closed range [low, high].
1) Find the first factorial that is greater than or equal to low. Let this factorial be x! (factorial of x) and value
of this factorial be ‘fact’
2) Keep incrementing x, and keep updating ‘fact’ while fact is smaller than or equal to
high. Count the
number of times, this loop runs.
3) Return the count computed in step 2.
Below is C++ implementation of above algorithm. Thanks to Kartik for suggesting below solution here.
// Program to count factorial numbers in given range

#include <iostream>
int countFact(int low, int high)

{
// Find the first factorial number 'fact' greater than or
// equal to 'low'
int fact = 1, x = 1;
while (fact < low)
{
fact = fact*x;
x++;
}
// Count factorial numbers in range [low, high]

int res = 0;
while (fact <= high)
{
res++;
fact = fact*x;
x++;
}
// Return the count

return res;
}

int main()
{
cout << "Count is " << countFact(2, 720);
return 0;
}

Output:

Count is 5

Design Patterns | Set 1 (Introduction)
Design pattern is a general reusable solution or template to a commonly occurring problem in software
design. The patterns typically show relationships and interactions between classes or objects. The idea is to
speed up the development process by providing tested, proven development paradigm.

Goal:
• Understand the problem and matching it with some pattern.
• Reusage of old interface or making the present design reusable for the future usage.

Example:
For example, in many real world situations we want to create only one instance of a class. For example, there
can be only one active president of country at a time regardless of personal identity. This pattern is called
Singleton pattern. Other software examples could be a single DB connection shared by multiple objects as
creating a separate DB connection for every object may be costly. Similarly, there can be a single
configuration manager or error manager in an application that handles all problems instead of creating
multiple managers.

Types of Design Patterns
There are mainly three types of design patterns:

1. Creational
These design patterns are all about class instantiation or object creation. These patterns can be further
categorized into Class-creational patterns and object-creational patterns. While class-creation patterns use
inheritance effectively in the instantiation process, object-creation patterns use delegation effectively to get
the job done.
Creational design patterns are Factory Method, Abstract Factory, Builder, Singleton, Object Pool, Prototype
and Singleton.

2. Structural
These design patterns are about organizing different classes and objects to form larger structures and
provide new functionality.
Structural design patterns are Adapter, Bridge, Composite, Decorator, Facade, Flyweight, Private Class Data
and Proxy.

3. Behavioral
Behavioral patterns are about identifying common communication patterns between objects and realize
these patterns.
Behavioral patterns are Chain of responsibility, Command, Interpreter, Iterator, Mediator, Memento, Null
Object, Observer, State, Strategy, Template method, Visitor

References:
https://sourcemaking.com/design_patterns
https://sourcemaking.com/design_patterns/singleton
This article is contributed by Abhijit Saha. Please write comments if you find anything incorrect, or you
Count distinct elements in every window of size k
Given an array of size n and an integer k, return the of count of distinct numbers in all windows of size k.
Example:
Input: arr[] = {1, 2, 1, 3, 4, 2, 3};

k = 4
Output:
3
4
4
3
Explanation:
First window is {1, 2, 1, 3}, count of distinct numbers is 3
Second window is {2, 1, 3, 4} count of distinct numbers is 4
Third window is {1, 3, 4, 2} count of distinct numbers is 4
Fourth window is {3, 4, 2, 3} count of distinct numbers is 3

A Simple Solution is to traverse the given array, consider every window in it and count distinct elements
in the window. Below is C++ implementation of simple solution.

// Simple C++ program to count distinct elements in every

// window of size k
#include <iostream>
// Counts distinct elements in window of size k

int countWindowDistinct(int win[], int k)
{
int dist_count = 0;
// Traverse the
{
// Check if element arr[i] exists in arr[0..i-1]
int j;
for (j=0; j<i; j++)
if (win[i] == win[j])
break;
if (j==i)
dist_count++;
}
return dist_count;
}
// Counts distinct elements in all windows of size k

void countDistinct(int arr[], int n, int k)
{
// Traverse through every window
for (int i=0; i<=n-k; i++)
cout << countWindowDistinct(arr+i, k) << endl;
}
// Driver program
int main()
{
int arr[] = {1, 2, 1, 3, 4, 2, 3}, k = 4;
countDistinct(arr, n, k);
return 0;
}

Output:

3
4
4
3

Time complexity of the above solution is O(nk2). We can improve time complexity to O(nkLok) by modifying
countWindowDistinct() to use sorting. The function can further be optimized to use hashing to find distinct
elements in a window. With hashing the time complexity becomes O(nk). Below is a different approach that
works in O(n) time.
An Efficient Solution is to use the count of previous window, while sliding the window. The idea is to
create a hash map that stores elements of current widow. When we slide the window, we remove an element
from hash and add an element. We also keep track of distinct elements. Below is algorithm.
1) Create an empty hash map. Let hash map be hM
2) Initialize distinct element count ‘dist_count’ as 0.
3) Traverse through first window and insert elements of first window to hM. The elements are used as key
and their counts as value in hM. Also keep updating ‘dist_count’
4) Print ‘dist_count’ for first window.
3) Traverse through remaining array (or other windows).

….a) Remove the first element of previous window.
…….If the removed element appeared only once
…………..remove it from hM and do “dist_count–”
…….Else (appeared multiple times in hM)
…………..decrement its count in hM
….a) Add the current element (last element of new window)

…….If the added element is not present in hM
…………..add it to hM and do “dist_count++”
…….Else (the added element appeared multiple times)
…………..increment its count in hM
Below is Java implementation of above approach.
// An efficient Java program to count distinct elements in

// every window of size k
class CountDistinctWindow
{
static void countDistinct(int arr[], int k)
{
HashMap<Integer, Integer> hM =
new HashMap<Integer, Integer>();
// initialize distinct element count for

// current window
int dist_count = 0;
// Traverse the first window and store count

// of every element in hash map
for (int i = 0; i < k; i++)
{
if (hM.get(arr[i]) == null)
{
hM.put(arr[i], 1);
dist_count++;
}
else
{
int count = hM.get(arr[i]);
hM.put(arr[i], count+1);
}
}
// Print count of first window

System.out.println(dist_count);
// Traverse through the remaining array

for (int i = k; i < arr.length; i++)
{
// Remove first element of previous window

// If there was only one occurrence, then
// reduce distinct count.
if (hM.get(arr[i-k]) == 1)
{
hM.remove(arr[i-k]);
dist_count--;
}
else // reduce count of the removed element
{
int count = hM.get(arr[i-k]);
hM.put(arr[i-k], count-1);
}
// Add new element of current window

// If this element appears first time,
// increment distinct element count
if (hM.get(arr[i]) == null)
{
hM.put(arr[i], 1);
dist_count++;
}
else // Increment distinct element count
{
int count = hM.get(arr[i]);
hM.put(arr[i], count+1);
}
// Print count of current window

}
}
// Driver method
{
int arr[] = {1, 2, 1, 3, 4, 2, 3};
int k = 4;
countDistinct(arr, k);
}
}

Output:

3
4
4
3

Time complexity of the above solution is O(n).
This article is contributed by Piyush. Please write comments if you find anything incorrect, or you want to
Minimum time required to rot all oranges
Given a matrix of dimension m*n where each cell in the matrix can have values 0, 1 or 2 which has the
following meaning:
0: Empty cell
1: Cells have fresh oranges
2: Cells have rotten oranges

So we have to determine what is the minimum time required so that all the oranges become rotten. A rotten
orange at index [i,j] can rot other fresh orange at indexes [i-1,j], [i+1,j], [i,j-1], [i,j+1] (up, down, left and
right). If it is impossible to rot every orange then simply return -1.
Examples:
Input: arr[][C] = { {2, 1, 0, 2, 1},

{1, 0, 1, 2, 1},
{1, 0, 0, 2, 1}};
Output:
All oranges can become rotten in 2 time frames.
Input: arr[][C] = { {2, 1, 0, 2, 1},

{0, 0, 1, 2, 1},
{1, 0, 0, 2, 1}};
Output:
All oranges cannot be rotten.
The idea is to user Breadth First Search. Below is algorithm.
1) Create an empty Q.
2) Find all rotten oranges and enqueue them to Q. Also enqueue
a delimiter to indicate beginning of next time frame.
3) While Q is not empty do following
3.a) While delimiter in Q is not reached
(i) Dequeue an orange from queue, rot all adjacent oranges.
While rotting the adjacents, make sure that time frame
is incremented only once. And time frame is not icnremented
if there are no adjacent oranges.
3.b) Dequeue the old delimiter and enqueue a new delimiter. The
oranges rotten in previous time frame lie between the two
delimiters.

// C++ program to find minimum time required to make all

// oranges rotten
#define R 3
#define C 5
// function to check whether a cell is valid / invalid

{
return (i >= 0 && j >= 0 && i < R && j < C);
}
// structure for storing coordinates of the cell

struct ele {
int x, y;
};
// Function to check whether the cell is delimiter

// which is (-1, -1)
bool isdelim(ele temp)
{
return (temp.x == -1 && temp.y == -1);
}
// Function to check whether there is still a fresh

// orange remaining
bool checkall(int arr[][C])
{
if (arr[i][j] == 1)
return true;
return false;
}
// This function finds if it is possible to rot all oranges or not.

// If possible, then it returns minimum time required to rot all,
// otherwise returns -1
int rotOranges(int arr[][C])
{
// Create a queue of cells
queue<ele> Q;
ele temp;
int ans = 0;
// Store all the cells having rotten orange in first time frame
{
{
if (arr[i][j] == 2)
{
temp.x = i;
temp.y = j;
Q.push(temp);
}
}
}
// Separate these rotten oranges from the oranges which will rotten
// due the oranges in first time frame using delimiter which is (-1, -1)
temp.x = -1;
temp.y = -1;
Q.push(temp);
// Process the grid while there are rotten oranges in the Queue
while (!Q.empty())
{
// This flag is used to determine whether even a single fresh
// orange gets rotten due to rotten oranges in current time
// frame so we can increase the count of the required time.
bool flag = false;
// Process all the rotten oranges in current time frame.

while (!isdelim(Q.front()))
{
temp = Q.front();
// Check right adjacent cell that if it can be rotten

if (isvalid(temp.x+1, temp.y) && arr[temp.x+1][temp.y] == 1)
{
// if this is the first orange to get rotten, increase
// count and set the flag.
if (!flag) ans++, flag = true;
// Make the orange rotten

arr[temp.x+1][temp.y] = 2;
// push the adjacent orange to Queue

temp.x++;
Q.push(temp);
temp.x--; // Move back to current cell

}
// Check left adjacent cell that if it can be rotten

if (isvalid(temp.x-1, temp.y) && arr[temp.x-1][temp.y] == 1) {
arr[temp.x-1][temp.y] = 2;
temp.x--;
Q.push(temp); // push this cell to Queue
temp.x++;
}
// Check top adjacent cell that if it can be rotten

if (isvalid(temp.x, temp.y+1) && arr[temp.x][temp.y+1] == 1) {
arr[temp.x][temp.y+1] = 2;
temp.y++;
Q.push(temp); // Push this cell to Queue
temp.y--;
}
// Check bottom adjacent cell if it can be rotten

if (isvalid(temp.x, temp.y-1) && arr[temp.x][temp.y-1] == 1) {
arr[temp.x][temp.y-1] = 2;
temp.y--;
Q.push(temp); // push this cell to Queue
}
Q.pop();
}
// Pop the delimiter

Q.pop();
// If oranges were rotten in current frame than separate the

// rotten oranges using delimiter for the next frame for processing.
if (!Q.empty()) {
temp.x = -1;
temp.y = -1;
Q.push(temp);
}
// If Queue was empty than no rotten oranges left to process so exit

}
// Return -1 if all arranges could not rot, otherwise -1.

return (checkall(arr))? -1: ans;
}
// Drive program
int main()
{
int arr[][C] = { {2, 1, 0, 2, 1},
{1, 0, 1, 2, 1},
{1, 0, 0, 2, 1}};
int ans = rotOranges(arr);
if (ans == -1)
cout << "All oranges cannot rot\n";
else
cout << "Time required for all oranges to rot => " << ans << endl;
return 0;
}

Output:

Time required for all oranges to rot => 2

Thanks to Gaurav Ahirwar for suggesting above solution here
discussed above
Collect maximum points in a grid using two traversals
Given a matrix where every cell represents points. How to collect maximum points using two traversals
under following conditions?
Let the dimensions of given grid be R x C.
1) The first traversal starts from top left corner, i.e., (0, 0) and should reach left bottom corner, i.e., (R-1, 0).
The second traversal starts from top right corner, i.e., (0, C-1) and should reach bottom right corner, i.e., (R-
1, C-1)/
2) From a point (i, j), we can move to (i+1, j+1) or (i+1, j+1) or (i+1, j)
3) A traversal gets all points of a particular cell through which it passes. If one traversal has already collected
points of a cell, then the other traversal gets no points if goes through that cell again.
Input :
int arr[R][C] = {{3, 6, 8, 2},
{5, 2, 4, 3},
{1, 1, 20, 10},
{1, 1, 20, 10},
{1, 1, 20, 10},
};
Output: 73
Explanation :
First traversal collects total points of value 3 + 2 + 20 + 1 + 1 = 27
Second traversal collects total points of value 2 + 4 + 10 + 20 + 10 = 46.

Total Points collected = 27 + 46 = 73.

Source: http://qa.geeksforgeeks.org/1485/running-through-the-grid-to-get-maximum-nutritional-value
The idea is to do both traversals concurrently. We start first from (0, 0) and second traversal from (0, C-1)
simultaneously. The important thing to note is, at any particular step both traversals will be in same row as
in all possible three moves, row number is increased. Let (x1, y1) and (x2, y2) denote current positions of
first and second traversals respectively. Thus at any time x1 will be equal to x2 as both of them move forward
but variation is possible along y. Since variation in y could occur in 3 ways no change (y), go left (y – 1), go
right (y + 1). So in total 9 combinations among y1, y2 are possible. The 9 cases as mentioned below after base
cases.

Both traversals always move forward along x

Base Cases:
// If destinations reached
if (x == R-1 && y1 == 0 && y2 == C-1)
maxPoints(arr, x, y1, y2) = arr[x][y1] + arr[x][y2];
// If any of the two locations is invalid (going out of grid)

if input is not valid
maxPoints(arr, x, y1, y2) = -INF (minus infinite)
// If both traversals are at same cell, then we count the value of cell
// only once.
If y1 and y2 are same
result = arr[x][y1]
Else
result = arr[x][y1] + arr[x][y2]
result += max { // Max of 9 cases

maxPoints(arr, x+1, y1+1, y2),
maxPoints(arr, x+1, y1+1, y2+1),
maxPoints(arr, x+1, y1+1, y2-1),
maxPoints(arr, x+1, y1-1, y2),
maxPoints(arr, x+1, y1-1, y2+1),
maxPoints(arr, x+1, y1-1, y2-1),
maxPoints(arr, x+1, y1, y2),
maxPoints(arr, x+1, y1, y2+1),
maxPoints(arr, x+1, y1, y2-1)
}

The above recursive solution has many subproblems that are solved again and again. Therefore, we can use
Dynamic Programming to solve the above problem more efficiently. Below is memoization (Memoization is
alternative to table based iterative solution in Dynamic Programming) based implementation. In below
implementation, we use a memoization table ‘mem’ to keep track of already solved problems.
// A Memoization based program to find maximum collection

// using two traversals of a grid
#define R 5
#define C 4
// checks whether a given input is valid or not

bool isValid(int x, int y1, int y2)
{
return (x >= 0 && x < R && y1 >=0 &&
y1 < C && y2 >=0 && y2 < C);
}
// Driver function to collect max value

int getMaxUtil(int arr[R][C], int mem[R][C][C], int x, int y1, int y2)
{
/*---------- BASE CASES -----------*/
// if P1 or P2 is at an invalid cell
if (!isValid(x, y1, y2)) return INT_MIN;
// if both traversals reach their destinations

// if both traversals reach their destinations
if (x == R-1 && y1 == 0 && y2 == C-1)
return arr[x][y1] + arr[x][y2];
// If both traversals are at last row but not at their destination

if (x == R-1) return INT_MIN;
// If subproblem is already solved

if (mem[x][y1][y2] != -1) return mem[x][y1][y2];
// Initialize answer for this subproblem

int ans = INT_MIN;
// this variable is used to store gain of current cell(s)

int temp = (y1 == y2)? arr[x][y1]: arr[x][y1] + arr[x][y2];
/* Recur for all possible cases, then store and return the
one with max value */
ans = max(ans, temp + getMaxUtil(arr, mem, x+1, y1, y2-1));
ans = max(ans, temp + getMaxUtil(arr, mem, x+1, y1, y2+1));
ans = max(ans, temp + getMaxUtil(arr, mem, x+1, y1, y2));
ans = max(ans, temp + getMaxUtil(arr, mem, x+1, y1-1, y2));

ans = max(ans, temp + getMaxUtil(arr, mem, x+1, y1-1, y2-1));
ans = max(ans, temp + getMaxUtil(arr, mem, x+1, y1-1, y2+1));
ans = max(ans, temp + getMaxUtil(arr, mem, x+1, y1+1, y2));

ans = max(ans, temp + getMaxUtil(arr, mem, x+1, y1+1, y2-1));
ans = max(ans, temp + getMaxUtil(arr, mem, x+1, y1+1, y2+1));
return (mem[x][y1][y2] = ans);

}
// This is mainly a wrapper over recursive function getMaxUtil().

// This function creates a table for memoization and calls
// getMaxUtil()
int geMaxCollection(int arr[R][C])
{
// Create a memoization table and initialize all entries as -1
int mem[R][C][C];
memset(mem, -1, sizeof(mem));
// Calculation maximum value using memoization based function

// getMaxUtil()
return getMaxUtil(arr, mem, 0, 0, C-1);
}

int main()
{
int arr[R][C] = {{3, 6, 8, 2},
{5, 2, 4, 3},
{1, 1, 20, 10},
{1, 1, 20, 10},
{1, 1, 20, 10},
};
cout << "Maximum collection is " << geMaxCollection(arr);
return 0;
}

Output:

Maximum collection is 73

Thanks to Gaurav Ahirwar for suggesting above problem and solution here.
discussed above.
Morgan Stanley Interview | Set 15 (On-Campus)
Recently Morgan Stanley visited our Campus for recruitment. Here’s my experience.
Round 1 (Aptitude):
19 MCQ on CS concepts.
2 easy coding questions
Find maximum contiguous sub array sum in a given array.

Given an array find the sum of elements between the given range.
In both the questions the test cases were very easy and also time limit was also not strict.
Round 2 (F2F):
One on One interview were help the next day. I waited for about 3 hrs for my turn.
The following questions were asked to me:
Parse floating point numbers from a stream of input.

How would you implement the Tabs system of chrome where closing one tab will automatically take you to
the previously modified one.
CS concepts like Virtual Memory and Paging etc.
Data structures to implement LRU and LFU caches.
Asked me about my language of choice- I said C++.
Then he discussed Virtual Functions in C++. How to implement them and why they are required.
I was rejected after the interview and only 9 students were shortlisted.
Tips;
Stay calm and focused.

Try to understand the question correctly and represent your thought process.
Approach as you would do in a real life scenario.
I thank GeeksForGeeks for providing such an amazing place to share our experiences and gain load from it.
Geeks.
Find minimum number of coins that make a given value
Given a value V, if we want to make change for V cents, and we have infinite supply of each of C = { C1, C2, .. ,
Cm} valued coins, what is the minimum number of coins to make the change?
Examples:
Input: coins[] = {25, 10, 5}, V = 30

Output: Minimum 2 coins required
We can use one coin of 25 cents and one of 5 cents
Input: coins[] = {9, 6, 5, 1}, V = 11

Output: Minimum 2 coins required
We can use one coin of 6 cents and 1 coin of 5 cents

This problem is a variation of the problem discussed Coin Change Problem. Here instead of finding total
number of possible solutions, we need to find the solution with minimum number of coins.
The minimum number of coins for a value V can be computed using below recursive formula.
If V == 0, then 0 coins required.

If V > 0
minCoin(coins[0..m-1], V) = min {1 + minCoins(V-coin[i])}
where i varies from 0 to m-1
and coin[i]
Below is recursive solution based on above recursive formula.

// A Naive recursive C++ program to find minimum of coins
// to make a given change V
// m is size of coins array (number of different coins)

int minCoins(int coins[], int m, int V)
{
// base case
if (V == 0) return 0;
int res = INT_MAX;
// Try every coin that has smaller value than V

if (coins[i] <= V)
res = min(res, 1 + minCoins(coins, m, V-coins[i]));
return res;
}

int main()
{
int coins[] = {9, 6, 5, 1};
int m = sizeof(coins)/sizeof(coins[0]);
int V = 11;
cout << "Minimum coins required is "
<< minCoins(coins, m, V);
return 0;
}

Output:
Minimum coins required is 2
The time complexity of above solution is exponential. If we draw the complete recursion
tree, we can observer that many subproblems are solved again and again. For example, wh
en we start from V = 11, we can reach 6 by subtracting one 5 times and by subtracting 5 o
ne times. So the subproblem for 6 is called twice.
Since same suproblems are called again, this problem has Overlapping Subprolems property
. So the min coins problem has both properties (see this and this) of a dynamic
programming problem. Like other typical Dynamic Programming(DP) problems, recomputations
of same subproblems can be avoided by constructing a temporary array table[][] in bottom
up manner. Below is Dynamic Programming based solution.

// A Dynamic Programming based C++ program to find minimum of coins
// to make a given change V
// m is size of coins array (number of different coins)

int minCoins(int coins[], int m, int V)
{
// table[i] will be storing the minimum number of coins
// required for i value. So table[V] will have result
int table[V+1];
// Base case (If given value V is 0)

table[0] = 0;
// Initialize all table values as Infinite

for (int i=1; i<=V; i++)
table[i] = INT_MAX;
// Compute minimum coins required for all

// values from 1 to V
for (int i=1; i<=V; i++)
{
// Go through all coins smaller than i
for (int j=0; j<m; j++)
if (coins[j] <= i)
table[i] = min(table[i], table[i-coins[j]] + 1);
}
return table[V];
}

int main()
{
int coins[] = {9, 6, 5, 1};
int V = 11;
int V = 11;
cout << "Minimum coins required is "
<< minCoins(coins, m, V);
return 0;
}
Output:
Minimum coins required is 2
Time complexity of the above solution is O(mV).
Thanks to Goku for suggesting above solution in a comment here and thanks to Vignesh Moh
an for suggesting this problem and initial solution.

Expression Tree
Expression tree is a binary tree in which each internal node corresponds to operator and each leaf node
corresponds to operand so for example expression tree for 3 + ((5+9)*2) would be:
Inorder traversal of expression tree produces infix version of given postfix expression (same with preorder
traversal it gives prefix expression)
Evaluating the expression represented by expression tree:
Let t be the expression tree

If t is not null then
If t.value is operand then
Return t.value
A = solve(t.left)
B = solve(t.right)

// calculate applies operator 't.value'
// on A and B, and returns value
Return calculate(A, B, t.value)

Construction of Expression Tree:

Now For constructing expression tree we use a stack. We loop through input expression and do following for
every character.
1) If character is operand push that into stack
2) If character is operator pop two values from stack make them its child and push current node again.
At the end only element of stack will be root of expression tree.
Below is C++ implementation t
// C++ program for expression tree

// An expression tree node

struct et
{
{
char value;
et* left, *right;
};
// A utility function to check if 'c'

// is an operator
bool isOperator(char c)
{
if (c == '+' || c == '-' ||
c == '*' || c == '/' ||
c == '^')
return true;
return false;
}
// Utility function to do inorder traversal

void inorder(et *t)
{
if(t)
{
inorder(t->left);
printf("%c ", t->value);
inorder(t->right);
}
}

et* newNode(int v)
{
et *temp = new et;
temp->value = v;
return temp;
};
// Returns root of constructed tree for given

// postfix expression
et* constructTree(char postfix[])
{
stack<et *> st;
et *t, *t1, *t2;
// Traverse through every character of

// input expression
for (int i=0; i<strlen(postfix); i++)
{
// If operand, simply push into stack
if (!isOperator(postfix[i]))
{
t = newNode(postfix[i]);
st.push(t);
}
else // operator
{
t = newNode(postfix[i]);
// Pop two top nodes

t1 = st.top(); // Store top
st.pop(); // Remove top
t2 = st.top();
st.pop();
// make them children

t->right = t1;
t->right = t1;
t->left = t2;
// Add this subexpression to stack

st.push(t);
}
}
// only element will be root of expression

// tree
t = st.top();
st.pop();
return t;
}

int main()
{
char postfix[] = "ab+ef*g*-";
et* r = constructTree(postfix);
printf("infix expression is \n");
inorder(r);
return 0;
}

Output:

infix expression is
a + b - e * f * g

Minimum number of squares whose sum equals to given number n
A number can always be represented as a sum of squares of other numbers. Note that 1 is a square and we
can always break a number as (1*1 + 1*1 + 1*1 + …). Given a number n, find the minimum number of squares
that sum to X.
Examples:
Input: n = 100
Output: 1
100 can be written as 102. Note that 100 can also be
written as 52 + 52 + 52 + 52, but this
representation requires 4 squares.
Input: n = 6
Output: 3

The idea is simple, we start from 1 and go till a number whose square is smaller than or equals to n. For
every number x, we recur for n-x. Below is the recursive formula.
If n = 1 and x*x
Below is a simple recursive solution based on above recursive formula.

// A naive recursive C++ program to find minimum
// number of squares whose sum is equal to a given number
// Returns count of minimum squares that sum to n

int getMinSquares(unsigned int n)
{
// base cases
if (n <= 3)
return n;
// getMinSquares rest of the table using recursive

// formula
int res = n; // Maximum squares required is n (1*1 + 1*1 + ..)
// Go through all smaller numbers

// to recursively find minimum
for (int x = 1; x <= n; x++)
{
int temp = x*x;
if (temp > n)
break;
else
res = min(res, 1+getMinSquares(n - temp));
}
return res;
}
// Driver program
// Driver program
int main()
{
cout << getMinSquares(6);
return 0;
}

Output:
The time complexity of above solution is exponential. If we draw the complete recursion
tree, we can observer that many subproblems are solved again and again. For example, wh
en we start from n = 6, we can reach 4 by subtracting one 2 times and by subtracting 2
one times. So the subproblem for 4 is called twice.
Since same suproblems are called again, this problem has Overlapping Subprolems property
. So min square sum problem has both properties (see this and this) of a dynamic
programming problem. Like other typical Dynamic Programming(DP) problems, recomputations
of same subproblems can be avoided by constructing a temporary array table[][] in bottom
up manner. Below is Dynamic Programming based solution

// A dynamic programming based C++ program to find minimum
// number of squares whose sum is equal to a given number
// Returns count of minimum squares that sum to n

int getMinSquares(int n)
{
// Create a dynamic programming table
// to store sq
int *dp = new int[n+1];
// getMinSquares table for base case entries

dp[0] = 0;
dp[1] = 1;
dp[2] = 2;
dp[3] = 3;
// getMinSquares rest of the table using recursive

// formula
for (int i = 4; i <= n; i++)
{
// max value is i as i can always be represented
// as 1*1 + 1*1 + ...
dp[i] = i;
// Go through all smaller numbers to

// to recursively find minimum
for (int x = 1; x <= i; x++) {
int temp = x*x;
if (temp > i)
break;
else dp[i] = min(dp[i], 1+dp[i-temp]);
}
}
// Store result and free dp[]

// Store result and free dp[]
int res = dp[n];
delete [] dp;
return res;
}
// Driver program
int main()
{
cout << getMinSquares(6);
return 0;
}

Output:
Thanks to Gaurav Ahirwar for suggesting this solution in a comment here.

Tiling Problem
Given a “2 x n” board and tiles of size “2 x 1″, count the number of ways to tile the given board using the 2 x 1
tiles. A tile can either be placed horizontally i.e., as a 1 x 2 tile or vertically i.e., as 2 x 1 tile.
Examples:
Input n = 3
Output: 3
Explanation:
We need 3 tiles to tile the board of size 2 x 3.
We can tile the board using following ways
1) Place all 3 tiles vertically.
2) Place first tile vertically and remaining 2 tiles horizontally.
3) Place first 2 tiles horizontally and remaining tiles vertically
Input n = 4
Output: 5
Explanation:
For a 2 x 4 board, there are 5 ways
1) All 4 vertical
2) All 4 horizontal
3) First 2 vertical, remaining 2 horizontal
4) First 2 horizontal, remaining 2 vertical
5) Corner 2 vertical, middle 2 horizontal

Let “count(n)” be the count of ways to place tiles on a “2 x n” grid, we have following two ways to place first
tile.
1) If we place first tile vertically, the problem reduces to “count(n-1)”
2) If we place first tile horizontally, we have to place second tile also horizontally. So the problem reduces to
“count(n-2)”
Therefore, count(n) can be written as below.

count(n) = n if n = 0 or n = 1
count(n) = count(n-1) + count(n-2)

The above recurrence is noting but Fibonacci Number expression. We can find n’th Fibonacci number in
O(Log n) time, see below for all method to find n’th Fibonacci Number.
Different methods for n’th Fibonacci Number.
This article is contributed by Saurabh Jain. Please write comments if you find anything incorrect, or you
Minimum number of swaps required for arranging pairs adjacent to each
other
There are n-pairs and therefore 2n people. everyone has one unique number ranging from 1 to 2n. All these
2n persons are arranged in random fashion in an Array of size 2n. We are also given who is partner of whom.
Find the minimum number of swaps required to arrange these pairs such that all pairs become adjacent to
each other.
Example:
Input:
n = 3
pairs[] = {1->3, 2->6, 4->5} // 1 is partner of 3 and so on
arr[] = {3, 5, 6, 4, 1, 2}
Output: 2
We can get {3, 1, 5, 4, 6, 2} by swapping 5 & 6, and 6 & 1

The idea is to start from first and second elements and recur for remaining elements. Below are detailed
steps/
1) If first and second elements are pair, then simply recur

for remaining n-1 pairs and return the value returned by
recursive call.
2) If first and second are NOT pair, then there are two ways to
arrange. So try both of them return the minimum of two.
a) Swap second with pair of first and recur for n-1 elements.
Let the value returned by recursive call be 'a'.
b) Revert the changes made by previous step.
c) Swap first with pair of second and recur for n-1 elements.
Let the value returned by recursive call be 'b'.
d) Revert the changes made by previous step before returning
control to parent call.
e) Return 1 + min(a, b)

// C++ program to find minimum number of swaps required so that

// all pairs become adjacent.
// This function updates indexes of elements 'a' and 'b'

void updateindex(int index[], int a, int ai, int b, int bi)
{
index[a] = ai;
index[b] = bi;
index[b] = bi;
}
// This function returns minimum number of swaps required to arrange

// all elements of arr[i..n] become aranged
int minSwapsUtil(int arr[], int pairs[], int index[], int i, int n)
{
// If all pairs procesed so no swapping needed return 0
if (i > n) return 0;
// If current pair is valid so DO NOT DISTURB this pair

// and move ahead.
if (pairs[arr[i]] == arr[i+1])
return minSwapsUtil(arr, pairs, index, i+2, n);
// If we reach here, then arr[i] and arr[i+1] don't form a pair
// Swap pair of arr[i] with arr[i+1] and recursively compute

// minimum swap required if this move is made.
int one = arr[i+1];
int indextwo = i+1;
int indexone = index[pairs[arr[i]]];
int two = arr[index[pairs[arr[i]]]];
swap(arr[i+1], arr[indexone]);
updateindex(index, one, indexone, two, indextwo);
int a = minSwapsUtil(arr, pairs, index, i+2, n);
// Backtrack to previous configuration. Also restore the

// previous indices, of one and two
swap(arr[i+1], arr[indexone]);
updateindex(index, one, indextwo, two, indexone);
one = arr[i], indexone = index[pairs[arr[i+1]]];
// Now swap arr[i] with pair of arr[i+1] and recursively

// compute minimum swaps required for the subproblem
// after this move
two = arr[index[pairs[arr[i+1]]]], indextwo = i;
swap(arr[i], arr[indexone]);
updateindex(index, one, indexone, two, indextwo);
int b = minSwapsUtil(arr, pairs, index, i+2, n);
// Backtrack to previous configuration. Also restore

// the previous indices, of one and two
swap(arr[i], arr[indexone]);
updateindex(index, one, indextwo, two, indexone);
// Return minimum of two cases

return 1 + min(a, b);
}
// Returns minimum swaps required

int minSwaps(int n, int pairs[], int arr[])
{
int index[2*n + 1]; // To store indices of array elements
// Store index of each element in array index

for (int i = 1; i <= 2*n; i++)
index[arr[i]] = i;
// Call the recursive function

return minSwapsUtil(arr, pairs, index, 1, 2*n);
}
// Driver program
int main()
int main()
{
// For simplicity, it is assumed that arr[0] is
// not used. The elements from index 1 to n are
// only valid elements
int arr[] = {0, 3, 5, 6, 4, 1, 2};
int pairs[] = {0, 3, 6, 1, 5, 4, 2};
int n = m/2; // Number of pairs n is half of total elements
// If there are n elements in array, then

// there are n pairs
cout << "Min swaps required is " << minSwaps(n, pairs, arr);
return 0;
}

Output:

Min swaps required is 2

Thanks to Gaurav Ahirwar for above solution.
discussed above
Trapping Rain Water
Given n non-negative integers representing an elevation map where the width of each bar is 1, compute how
much water it is able to trap after raining.
Examples:
Input: arr[] = {2, 0, 2}

Output: 2
Structure is like below
| |
|_|
We can trap 2 units of water in the middle gap.
Input: arr[] = {3, 0, 0, 2, 0, 4}

Output: 10
Structure is like below
|
| |
| | |
|__|_|
We can trap "3*2 units" of water between 3 an 2,
"1 unit" on top of bar 2 and "3 units" between 2
and 4. See below diagram also.
Input: arr[] = [0, 1, 0, 2, 1, 0, 1, 3, 2, 1, 2, 1]

Output: 6
|
| || |
_|_||_||||||
Trap "1 unit" between first 1 and 2, "4 units" between
first 2 and 3 and "1 unit" between second last 1 and last 2

Source: http://qa.geeksforgeeks.org/1875/trapping-rain-water
An element of array can store water if there are higher bars on left and right. We can find amount of water to
be stored in every element by finding the heights of bars on left and right sides. The idea is to compute
amount of water that can be stored in every element of array. For example, consider the array {3, 0, 0, 2, 0,
4}, we can store two units of water at indexes 1 and 2, and one unit of water at index 2.
A Simple Solution is to traverse every array element and find the highest bars on left and right sides. Take
the smaller of two heights. The difference between smaller height and height of current element is the
amount of water that can be stored in this array element. Time complexity of this solution is O(n2).
An Efficient Solution is to prre-compute highest bar on left and right of every bar in O(n) time. Then use
these pre-computed values to find the amount of water in every array element. Below is C++ implementation
of this solution.

// C++ program to find maximum amount of water that can

// be trapped within given set of bars.
int findWater(int arr[], int n)

{
// left[i] contains height of tallest bar to the
// left of i'th bar including itself
int left[n];
// Right [i] contains height of tallest bar to

// the right of ith bar including itself
int right[n];
int water = 0;
// Fill left array

left[0] = arr[0];
for (int i = 1; i < n; i++)
left[i] = max(left[i-1], arr[i]);
// Fill right array

right[n-1] = arr[n-1];
for (int i = n-2; i >= 0; i--)
right[i] = max(right[i+1], arr[i]);
// Calculate the accumulated water element by element

// consider the amount of water on i'th bar, the
// amount of water accumulated on this particular
// bar will be equal to min(left[i], right[i]) - arr[i] .
for (int i = 0; i < n; i++)
water += min(left[i],right[i]) - arr[i];
return water;
}
// Driver program
int main()
{
int arr[] = {0, 1, 0, 2, 1, 0, 1, 3, 2, 1, 2, 1};
cout << "Maximum water that can be accumulated is "
<< findWater(arr, n);
return 0;
}

Output:

Maximum water that can be accumulated is 6


discussed above
Design Patterns | Set 2 (Factory Method)
Factory method is a creational design pattern, i.e., related to object creation. In Factory pattern, we create
object without exposing the creation logic to client and the client use the same common interface to create
new type of object.
The idea is to use a static member-function (static factory method) which creates & returns instances, hiding
the details of class modules from user.
A factory pattern is one of the core design principles to create an object, allowing clients to create objects of
a library(explained below) in a way such that it doesn’t have tight coupling with the class hierarchy of the
library.
What is meant when we talk about library and clients?

A library is something which is provided by some third party which exposes some public APIs and clients
make calls to those public APIs to complete its task. A very simple example can be different kinds of Views
provided by Android OS.
Why factory pattern?


// A design without factory pattern

#include <iostream>
// Library classes
class Vehicle {
public:
virtual void printVehicle() = 0;
};
class TwoWheeler : public Vehicle {
public:
void printVehicle() {
cout << "I am two wheeler" << endl;
}
};
class FourWheeler : public Vehicle {
public:
cout << "I am four wheeler" << endl;
}
};
// Client (or user) class

class Client {
public:
Client(int type) {
// Client explicitly creates classes according to type

if (type == 1)
pVehicle = new TwoWheeler();
else if (type == 2)
pVehicle = new FourWheeler();
else
pVehicle = NULL;
}
~Client() {
if (pVehicle)
{
delete[] pVehicle;
pVehicle = NULL;
}
}
Vehicle* getVehicle() {
return pVehicle;
}
private:
Vehicle *pVehicle;
};
// Driver program
int main() {
Client *pClient = new Client(1);
Vehicle * pVehicle = pClient->getVehicle();
pVehicle->printVehicle();
return 0;
}

Output:

I am two wheeler

What is the problems with above design?

As you must have observed in the above example, Client creates objects of either TwoWheeler or
FourWheeler based on some input during constructing its object.
Say, library introduces a new class ThreeWheeler to incorporate three wheeler vehicles also. What would
happen? Client will end up chaining a new else if in the conditional ladder to create objects of ThreeWheeler.
Which in turn will need Client to be recompiled. So, each time a new change is made at the library side,
Client would need to make some corresponding changes at its end and recompile the code. Sounds bad? This
is a very bad practice of design.
How to avoid the problem?

The answer is, create a static (or factory) method. Let us see below code.
// C++ program to demonstrate factory method design pattern

#include <iostream>
enum VehicleType {
VT_TwoWheeler, VT_ThreeWheeler, VT_FourWheeler
};
// Library classes
class Vehicle {
public:
virtual void printVehicle() = 0;
static Vehicle* Create(VehicleType type);
};
class TwoWheeler : public Vehicle {
public:
cout << "I am two wheeler" << endl;
}
};
class ThreeWheeler : public Vehicle {
public:
cout << "I am three wheeler" << endl;
}
};
class FourWheeler : public Vehicle {
public:
cout << "I am four wheeler" << endl;
}
};
// Factory method to create objects of different types.

// Change is required only in this function to create a new object type
Vehicle* Vehicle::Create(VehicleType type) {
if (type == VT_TwoWheeler)
return new TwoWheeler();
else if (type == VT_ThreeWheeler)
return new ThreeWheeler();
return new ThreeWheeler();
else if (type == VT_FourWheeler)
return new FourWheeler();
else return NULL;
}
// Client class
class Client {
public:
// Client doesn't explicitly create objects

// but passes type to factory method "Create()"
Client()
{
VehicleType type = VT_ThreeWheeler;
pVehicle = Vehicle::Create(type);
}
~Client() {
if (pVehicle) {
delete[] pVehicle;
pVehicle = NULL;
}
}
Vehicle* getVehicle() {
return pVehicle;
}
private:
Vehicle *pVehicle;
};
// Driver program
int main() {
Client *pClient = new Client();
Vehicle * pVehicle = pClient->getVehicle();
pVehicle->printVehicle();
return 0;
}

Output:

I am three wheeler

In the above example, we have totally decoupled the selection of type for object creation from Client. The
library is now responsible to decide which object type to create based on an input. Client just needs to make
call to library’s factory Create method and pass the type it wants without worrying about the actual
implementation of creation of objects.
Thanks to Rumplestiltskin for providing above explanation here.
Other examples of Factory Method:
1. Say, in a ‘Drawing’ system, depending on user’s input, different pictures like square, rectangle, circle
can be drawn. Here we can use factory method to create instances depending on user’s input. For
adding new type of shape, no need to change client’s code.
2. Another example: In travel site, we can book train ticket as well bus tickets and flight ticket. In this
case user can give his travel type as ‘bus’, ‘train’ or ‘flight’.
Here we have an abstract class ‘AnyTravel’ with a static member function ‘GetObject’ which depending
on user’s travel type, will create & return object of ‘BusTravel’ or ‘ TrainTravel’. ‘BusTravel’ or ‘
TrainTravel’ have common functions like passenger name, Origin, destinationparameters.
3. Also see this interview question.
Thanks to Abhijit Saha providing the first 2 examples.
discussed above.
Longest Consecutive Subsequence
Given an array of integers, find the length of the longest sub-sequence such that elements in the sequence
are consecutive integers.
Examples
Input: arr[] = {1, 9, 3, 10, 4, 20, 2};

Output: 4
The subsequence 1, 3, 4, 2 is the longest subsequence
of consecutive elements
Input: arr[] = {36, 41, 56, 35, 44, 33, 34, 92, 43, 32, 42}
Output: 5
The subsequence 36, 35, 33, 34, 32 is the longest subsequence
of consecutive elements.

One Solution is to first sort the array and find the longest subarray with consecutive elements. Time
complexity of this solution is O(nLogn). Thanks to Hao.W for suggesting this solution here.
We can solve this problem in O(n) time using an Efficient Solution. The idea is to use Hashing. We first
insert all elements in a Hash. Then check all the possible starts of consecutive subsequences. Below is
complete algorithm.
1) Create an empty hash.

2) Insert all array elements to hash.
3) Do following for every element arr[i]
....a) Check if this element is the starting point of a
subsequence. To check this, we simply look for
arr[i] - 1 in hash, if not found, then this is
the first element a subsequence.

If this element is a first element, then count
number of elements in the consecutive starting
with this element.
If count is more than current res, then update

res.


// C++ program to find longest contiguous subsequence

// Returns length of the longest contiguous subsequence

int findLongestConseqSubseq(int arr[], int n)
{
unordered_set<int> S;
int ans = 0;
// Hash all the array elements

for (int i = 0; i < n; i++)
S.insert(arr[i]);
// check each possible sequence from the start

// then update optimal length
{
// if current element is the starting
// element of a sequence
if (S.find(arr[i]-1) == S.end())
{
// Then check for next elements in the
// sequence
int j = arr[i];
while (S.find(j) != S.end())
j++;
// update optimal length if this length

// is more
ans = max(ans, j - arr[i]);
}
}
return ans;
}
// Driver program
int main()
{
int arr[] = {1, 9, 3, 10, 4, 20, 2};
int n = sizeof arr/ sizeof arr[0];
cout << "Length of the Longest contiguous subsequence is "
<< findLongestConseqSubseq(arr, n);
return 0;
}

Output:

Length of the Longest contiguous subsequence is 4

Time Complexity: At first look, time complexity looks more than O(n). If we take a closer look, we can
notice that it is O(n) under the assumption that hash insert and search take O(1) time. The function S.find()
inside the while loop is called at most twice for every element. For example, consider the case when all array
elements are consecutive. In this case, the outer find is called for every element, but we go inside the if
condition only for the smallest element. Once we are inside the if condition, we call find() one more time for
every other element.
discussed above.
Transform One String to Another using Minimum Number of Given
Operation
Given two strings A and B, the task is to convert A to B if possible. The only operation allowed is to put any
character from A and insert it at front. Find if it’s possible to convert the string. If yes, then output minimum
no. of operations required for transformation.
Input: A = "ABD", B = "BAD"

Output: 1
Explanation: Pick B and insert it at front.
Input: A = "EACBD", B = "EABCD"

Output: 3
Explanation: Pick B and insert at front, EACBD => BEACD
Pick A and insert at front, BEACD => ABECD
Pick E and insert at front, BEACD => ABECD

Checking whether a string can be transformed to another is simple. We need to check whether both strings
have same number of characters and same set of characters. This can be easily done by creating a count array
for first string and checking if second string has same count of every character.
How to find minimum number of operations when we are sure that we can transform A to B? The idea is to
start matching from last characters of both strings. If last characters match, then our task reduces to n-1
characters. If last characters don’t match, then find the position of B’s mismatching character in A. The
difference between two positions indicates that these many characters of A must be moved before current
character of A.
1) Find if A can be transformed to B or not by first creating a count array for all characters of A, then
checking with B if B has same count for every character.
2) Start traversing from end of both strings.
……a) If current characters of A and B match, i.e., A[i] == B[j]
………then do i = i-1 and j = j-1
……b) If current characters don’t match, then search B[j] in A[0..i-1]
………While searching, keep incrementing result as these characters
………must be moved ahead for A to B transformation.
Below is C++ implementation based on this idea.

// C++ program to find minimum number of
// operations required to transform one string to other
// Function to find minimum number of operations required to transform

// A to B.
int minOps(string& A, string& B)
{
int m = A.length(), n = B.length();
// This parts checks whether conversion is

// possible or not
if (n != m)
return -1;
int count[256];
for (int i=0; i<n; i++) // count characters in A
count[B[i]]++;
for (int i=0; i<n; i++) // subtract count for
count[A[i]]--; // every character in B
for (int i=0; i<n; i++) // Check if all counts become 0
if (count[i])
return -1;
// This part calculates the number of operations required

int res = 0;
for (int i=n-1, j=n-1; i>=0; )
{
// If there is a mismatch, then keep incrementing
// result 'res' until B[j] is not found in A[0..i]
while (i>=0 && A[i] != B[j])
{
i--;
res++;
}
// If A[i] and B[j] match

if (i >= 0)
{
i--;
j--;
}
}
return res;
}
// Driver program
int main()
{
string A = "EACBD";
string B = "EABCD";
cout << "Minimum number of operations "
"required is " << minOps(A, B);
return 0;
}

Output:

Minimum number of operations required is 3

Time Complexity: O(n), please note that i is always decremented (in while loop and in if), and the for loop
starts from n-1 and runs while i >= 0.
discussed above
Find length of the longest consecutive path from a given starting character
Given a matrix of characters. Find length of the longest path from a given character, such that all characters
in the path are consecutive to each other, i.e., every character in path is next to previous in alphabetical
order. It is allowed to move in all 8 directions from a cell.
Example
Input: mat[][] = { {a, c, d},

{h, b, e},
{i, g, f}}
Starting Point = 'e'
Output: 5
If starting point is 'e', then longest path with consecutive
characters is "e f g h i".
Input: mat[R][C] = { {b, e, f},

{h, d, a},
{i, c, a}};
Starting Point = 'b'
Output: 1
'c' is not present in all adjacent cells of 'b'

The idea is to first search given starting character in the given matrix. Do Depth First Search (DFS) from all
occurrences to find all consecutive paths. While doing DFS, we may encounter many subproblems again and
again. So we use dynamic programming to store results of subproblems.
// C++ program to find the longest consecutive path

#define R 3
#define R 3
#define C 3
// tool matrices to recur for adjacent cells.

int x[] = {0, 1, 1, -1, 1, 0, -1, -1};
int y[] = {1, 0, 1, 1, -1, -1, 0, -1};
// Used to keep track of visited cells.

bool visited[R][C];
// dp[i][j][k] Stores length of longest consecutive

// path starting at mat[i][j] when previous character is k.
int dp[R][C][26]; // Assuming that there are only 26 characters
// from 'a' to 'z'
// check whether mat[i][j] is a valid cell or not.

{
if (i < 0 || j < 0 || i >= R || j >= C)
return false;
return true;
}
// Check whether current character is adjacent to previous

// character (character processed in parent call) or not.
bool isadjacent(char prev, char curr)
{
return ((curr - prev) == 1);
}
// i, j are the indices of the current cell and prev is the

// character processed in the parent call.. also mat[i][j]
// is our current character.
int getLenUtil(char mat[R][C], int i, int j, char prev)
{
// If this cell is not valid or current character is not
// adjacent to previous one (e.g. d is not adjacent to b )
// or if this cell is already included in the path than return 0.
if (!isvalid(i, j) || !isadjacent(prev, mat[i][j]) || visited[i][j])
return 0;
// If this subproblem is already solved , return the answer

if (dp[i][j][prev - 'a'] != -1)
return dp[i][j][prev - 'a'];
int ans = 0; // Initialize answer
// mark current node, so it does not get included again.

visited[i][j] = true;
// recur for paths with differnt adjacent cells and store

// the length of longest path.
for (int k=0; k<8; k++)
ans = max(ans, 1 + getLenUtil(mat, i + x[k],
j + y[k], mat[i][j]));
// unmark current node so can be processed later as part of

// some another path if possible
visited[i][j] = false;
// save the answer and return

return dp[i][j][prev - 'a'] = ans;
}
// Returns length of the longest path with all characters consecutive
// to each other. This function first initializes dp array that
// is used to store results of subproblems, then it calls
// recursive DFS based function getLenUtil() to find max length path
int getLen(char mat[R][C], char s)
{
memset(dp, -1, sizeof dp);
int ans = 0;

{
{
// check for each possible starting point
if (mat[i][j] == s) {
// recur for all eight adjacent cells

for (int k=0; k<8; k++)
ans = max(ans, 1 + getLenUtil(mat,
i + x[k], j + y[k], s));
}
}
}
return ans;
}
// Driver program
int main() {
char mat[R][C] = { {'a','c','d'},

{ 'h','b','a'},
{ 'i','g','f'}};
cout << getLen(mat, 'a') << endl;

cout << getLen(mat, 'e') << endl;
cout << getLen(mat, 'b') << endl;
cout << getLen(mat, 'f') << endl;
return 0;
}

Output:

4
0
3
4

discussed above
Maximum Path Sum in a Binary Tree
Given a binary tree, find the maximum path sum. The path may start and end at any node in the tree.
Example:
Input: Root of below tree

1
/ \
2 3
Output: 6
See below diagram for another example.

1+2+3

For each node there can be four ways that the max path goes through the node:
1. Node only
2. Max path through Left Child + Node
3. Max path through Right Child + Node
4. Max path through Left Child + Node + Max path through Right Child
The idea is to keep trace of four paths and pick up the max one in the end. An important thing to note is, root
of every subtree need to return maximum path sum such that at most one child of root is involved. This is
needed for parent function call. In below code, this sum is stored in ‘max_single’ and returned by the
recursive function.
// C program to remove all half Nodes

#include <iostream>

struct Node
{
int data;
};
// A utility function to allocate a new node

{
struct Node* newNode = new Node;
newNode->data = data;
newNode->left = newNode->right = NULL;
return (newNode);
}
// This function returns overall maximum path sum in 'res'

// And returns max path sum going through root.
int findMaxUtil(Node* root, int &res)
{
//Base Case
if (root == NULL)
return 0;
// l and r store maximum path sum going through left and

// right child of root respectively
int l = findMaxUtil(root->left,res);
int r = findMaxUtil(root->right,res);
// Max path for parent call of root. This path must

// include at-most one child of root
int max_single = max(max(l, r) + root->data, root->data);
// Max Top represents the sum when the Node under

// consideration is the root of the maxsum path and no
// ancestors of root are there in max sum path
int max_top = max(max_single, l + r + root->data);
res = max(res, max_top); // Store the Maximum Result.
return max_single;
}
// Returns maximum path sum in tree with given root

int findMaxSum(Node *root)
{
int res = INT_MIN;
// Compute and return result

findMaxUtil(root, res);
return res;
}
// Driver program
int main(void)
{
root->right->right = newNode(-25);
cout << "Max path sum is " << findMaxSum(root);
return 0;
}
}
Output:

Max path sum is 42

Time Complexity: O(n) where n is number of nodes in Binary Tree.
This article is contributed by Anmol Varshney. Please write comments if you find anything incorrect, or
Convert array into Zig-Zag fashion
Given an array of distinct elements, rearrange the elements of array in zig-zag fashion in O(n) time. The
converted array should be in form a c e
Example:
Input: arr[] = {4, 3, 7, 8, 6, 2, 1}
Output: arr[] = {3, 7, 4, 8, 2, 6, 1}
Input: arr[] = {1, 4, 3, 2}

Output: arr[] = {1, 4, 2, 3}

A Simple Solution is to first sort the array. After sorting, exclude the first element, swap the remaining
elements in pairs. (i.e. keep arr[0] as it is, swap arr[1] and arr[2], swap arr[3] and arr[4], and so on). Time
complexity is O(nlogn) since we need to sort the array first.
We can convert in O(n) time using an Efficient Approach. The idea is to use modified one pass of bubble
sort. Maintain a flag for representing which order(i.e. ) currently we need. If the current two elements are
not in that order then swap those elements otherwise not.
Let us see the main logic using three consecutive elements A, B, C. Suppose we are processing B and C
currently and the current relation is ‘ C. Since current relation is ‘‘ i.e., A must be greater than B. So, the
relation is A > B and B > C. We can deduce A > C. So if we swap B and C then the relation is A > C and C A C
B
Refer this for more explanation.
Below is C++ implementation of above algorithm

// C++ program to sort an array in Zig-Zag form

#include <iostream>
// Program for zig-zag conversion of array

void zigZag(int arr[], int n)
{
// Flag true indicates relation "<" is expected,
// else ">" is expected. The first expected relation
// is "<"
bool flag = true;
for (int i=0; i<=n-2; i++)

{
if (flag) /* "<" relation expected */
{
/* If we have a situation like A > B > C,
we get A > B < C by swapping B and C */
swap(arr[i], arr[i+1]);
}
else /* ">" relation expected */
{
/* If we have a situation like A < B < C,
we get A < C > B by swapping B and C */
if (arr[i] < arr[i+1])
swap(arr[i], arr[i+1]);
}
flag = !flag; /* flip flag */
}
}
// Driver program
int main()
{
int arr[] = {4, 3, 7, 8, 6, 2, 1};
zigZag(arr, n);
cout << arr[i] << " ";
return 0;
}

Output:

3 7 4 8 2 6 1


This article is contributed by Siva Krishna Aleti. Please write comments if you find anything incorrect, or
Find same contacts in a list of contacts
Given a list of contacts containing username, email and phone number in any order. Identify the same
contacts (i.e., same person having many different contacts) and output the same contacts together.
Notes:
1) A contact can store its three fields in any order, i.e., phone number can appear before username or
username can appear before phone number.
2) Two contacts are same if they have either same username or email or phone number.
Example:
Input: contact[] =
{ {"Gaurav", "gaurav@gmail.com", "gaurav@gfgQA.com"},
{ "Lucky", "lucky@gmail.com", "+1234567"},
{ "gaurav123", "+5412312", "gaurav123@skype.com"}.
{ "gaurav1993", "+5412312", "gaurav@gfgQA.com"}
}
Output:
0 2 3
1
contact[2] is same as contact[3] because they both have same
contact number.
contact[0] is same as contact[3] because they both have same
e-mail address.
Therefore, contact[0] and contact[2] are also same.

Input is basically an array of structures. A structure contains three fields such that any field can represent
any detail about a contact.
The idea is to first create a graph of contacts using given array. In the graph, there is an edge between vertex
i to vertex j if they both have either same username or same email or same phone number. Once the graph is
constructed, the task reduces to finding connected components in an undirected graph. We can find
connected components either by doing DFS or BFS starting from every unvisited vertex. In below code, DFS
is used.
Below is C++ implementation of this idea.
// A C++ program to find same contacts in a list of contacts

// Structure for storing contact details.

struct contact
{
string field1, field2, field3;
};
// A utility function to fill entries in adjacency matrix

// representation of graph
void buildGraph(contact arr[], int n, int *mat[])
{
// Initialize the adjacency matrix
mat[i][j] = 0;
// Traverse through all contacts

for (int i = 0; i < n; i++) {
// Add mat from i to j and vice versa, if possible.

// Since length of each contact field is at max some
// constant. (say 30) so body execution of this for
// loop takes constant time.
for (int j = i+1; j < n; j++)
if (arr[i].field1 == arr[j].field1 ||
arr[i].field1 == arr[j].field2 ||
arr[i].field3 == arr[j].field3)
{
mat[i][j] = 1;
mat[j][i] = 1;
break;
}
}
}
// A recuesive function to perform DFS with vertex i as source

void DFSvisit(int i, int *mat[], bool visited[], vector<int>& sol, int n)
{
visited[i] = true;
sol.push_back(i);
for (int j = 0; j < n; j++)

if (mat[i][j] && !visited[j])
DFSvisit(j, mat, visited, sol, n);
}
// Finds similar contacrs in an array of contacts

void findSameContacts(contact arr[], int n)
{
// vector for storing the solution
vector<int> sol;
// Declare 2D adjaceny matrix for mats

int **mat = new int*[n];
for (int i = 0; i < n; i++)

mat[i] = new int[n];
// visited array to keep track of visited nodes

bool visited[n];
// Fill adjacency matrix

buildGraph(arr, n, mat);
// Since, we made a graph with contacts as nodes with fields as links.

// two nodes are linked if they represent the same person.
// so, total number of connected components and nodes in each component
// will be our answer.
for (int i = 0; i < n; i++)
{
if (!visited[i])
{
DFSvisit(i, mat, visited, sol, n);
// Add delimeter to separate nodes of one component from other.

sol.push_back(-1);
}
}

for (int i = 0; i < sol.size(); i++)
if (sol[i] == -1) cout << endl;
else cout << sol[i] << " ";
}
// Drive program
int main()
{
contact arr[] = {{"Gaurav", "gaurav@gmail.com", "gaurav@gfgQA.com"},
{"Lucky", "lucky@gmail.com", "+1234567"},
{"gaurav123", "+5412312", "gaurav123@skype.com"},
{"gaurav1993", "+5412312", "gaurav@gfgQA.com"},
{"raja", "+2231210", "raja@gfg.com"},
{"bahubali", "+878312", "raja"}
};
int n = sizeof arr / sizeof arr[0];

findSameContacts(arr, n);
return 0;
}

Output:

0 3 2
1
4 5

Time complexity: O(n2) where n is number of contacts.
discussed above
Length of shortest chain to reach a target word
Given a dictionary, and two words ‘start’ and ‘target’ (both of same length). Find length of the smallest chain
from ‘start’ to ‘target’ if it exists, such that adjacent words in the chain only differ by one character and each
word in the chain is a valid word i.e., it exists in the dictionary. It may be assumed that the ‘target’ word
exists in dictionary.
Example:
Input: Dictionary = {POON, PLEE, SAME, POIE, PLEA, PLIE, POIN}

start = TOON
target = PLEA
Output: 7
Explanation: TOON - POON - POIN - POIE - PLIE - PLEE - PLEA

The idea is to use BFS. We start from the given start word, traverse all words that adjacent (differ by one
character) to it and keep doing so until we find the target word or we have traversed all words.
// C++ program to find length of the shortest chain

// transformation from source to target
// To check if strings differ by exactly one character

bool isadjacent(string& a, string& b)
{
int count = 0; // to store count of differences
int n = a.length();
// Iterate through all characters and return false

// if there are more than one mismatching characters
for (int i = 0; i < n; i++)
{
if (a[i] != b[i]) count++;
if (count > 1) return false;
}
return count == 1 ? true : false;
}
// A queue item to store word and minimum chain length

// to reach the word.
struct QItem
{
string word;
int len;
};
// Returns length of shortest chain to reach 'target' from 'start'

// using minimum number of adjacent moves. D is dictionary
int shortestChainLen(string& start, string& target, set<string> &D)
{
// Create a queue for BFS and insert 'start' as source vertex
queue<QItem> Q;
QItem item = {start, 1}; // Chain length for start word is 1
Q.push(item);
// While queue is not empty

while (!Q.empty())
{
// Take the front word
QItem curr = Q.front();
Q.pop();
// Go through all words of dictionary

for (typeof(D.begin()) it = D.begin(); it != D.end(); it++)
{
// Process a dictionary word if it is adjacent to current
// word (or vertex) of BFS
string temp = *it;
if (isadjacent(curr.word, temp))
{
// Add the dictionary word to Q
item.word = temp;
item.len = curr.len + 1;
Q.push(item);
// Remove from dictionary so that this word is not

// processed again. This is like marking visited
D.erase(temp);
// If we reached target
if (temp == target)
return item.len;
}
}
}
return 0;
}
// Driver program
int main()
{
// make dictionary
set<string> D;
D.insert("poon");
D.insert("plee");
D.insert("same");
D.insert("poie");
D.insert("plie");
D.insert("poin");
string start = "toon";

string target = "plea";
cout << "Length of shortest chain is: "
<< shortestChainLen(start, target, D);
return 0;
}

Output:

Length of shortest chain is: 7

Thanks to Gaurav Ahirwar and Rajnish Kumar Jha for above solution.
discussed above.
Look-and-Say Sequence
Find the n’th term in Look-and-say (Or Count and Say) Sequence. The look-and-say sequence is the
sequence of below integers:
1, 11, 21, 1211, 111221, 312211, 13112221, 1113213211, …
How is above sequence generated?

n’th term in generated by reading (n-1)’th term.
The first term is "1"
Second term is "11", generated by reading first term as "One 1"

(There is one 1 in previous term)
Third term is "21", generated by reading second term as "Two 1"
Fourth term is "1211", generated by reading third term as "One 2 One 1"
and so on

How to find n’th term?
Input: n = 3
Output: 21
Input: n = 5
Output: 111221

The idea is simple, we generate all terms from 1 to n. First two terms are initialized as “1” and “11”, and all
other terms are generated using previous terms. To generate a term using previous term, we scan the
previous term. While scanning a term, we simply keep track of count of all consecutive characters. For
sequence of same characters, we append the count followed by character to generate the next term.
// C++ program to find n'th term in look and say

// sequence
// Returns n'th term in look-and-say sequence

string countnndSay(int n)
{
// Base cases
if (n == 1) return "1";
if (n == 2) return "11";
// Find n'th term by generating all terms from 3 to

// n-1. Every term is generated using previous term
string str = "11"; // Initialize previous term
string str = "11"; // Initialize previous term
for (int i = 3; i<=n; i++)
{
// In below for loop, previous character
// is processed in current iteration. That
// is why a dummy character is added to make
// sure that loop runs one extra iteration.
str += '$';
int cnt = 1; // Initialize count of matching chars

string tmp = ""; // Initialize i'th term in series
// Process previous term to find the next term

for (int j = 1; j < len; j++)
{
// If current character does't match
if (str[j] != str[j-1])
{
// Append count of str[j-1] to temp
tmp += cnt + '0';
// Append str[j-1]
tmp += str[j-1];
// Reset count
cnt = 1;
}
// If matches, then increment count of matching

// characters
else cnt++;
}
// Update str
str = tmp;
}
return str;
}
// Driver program
int main()
{
int N = 3;
cout << countnndSay(N) << endl;
return 0;
}

Output:

21

Thanks to Utkarsh for suggesting the above solution.
discussed above
3-Way QuickSort
In simple QuickSort algorithm, we select an element as pivot, partition the array around pivot and recur for
subarrays on left and right of pivot.
Consider an array which has many redundant elements. For example, {1, 4, 2, 4, 2, 4, 1, 2, 4, 1, 2, 2, 2, 2, 4, 1,
4, 4, 4}. If 4 is picked as pivot in Simple QuickSort, we fix only one 4 and recursively process remaining
occurrences.
The idea of 3 way QuickSort is to process all occurrences of pivot.
In 3 Way QuickSort, an array arr[l..r] is divided in 3 parts:

a) arr[l..i] elements less than pivot.
b) arr[i+1..j-1] elements equal to pivot.
c) arr[j..r] elements greater than pivot.

// C++ program for 3-way quick sort

/* This function partitions a[] in three parts

a) a[l..i] contains all elements smaller than pivot
b) a[i+1..j-1] contains all occurrences of pivot
c) a[j..r] contains all elements greater than pivot */
void partition(int a[], int l, int r, int &i, int &j)
{
i = l-1, j = r;
int p = l-1, q = r;
int v = a[r];
while (true)
{
// From left, find the first element greater than
// or equal to v. This loop will definitely terminate
// as v is last element
while (a[++i] < v);
// From right, find the first element smaller than or

// equal to v
while (v < a[--j])
if (j == l)
break;
// If i and j cross, then we are don

if (i >= j) break;
// Swap, so that smaller goes on left greater goes on right

swap(a[i], a[j]);
// Move all same left occurrence of pivot to beginning of

// array and keep count using p
if (a[i] == v)
{
p++;
swap(a[p], a[i]);
swap(a[p], a[i]);
}
// Move all same right occurrence of pivot to end of array

// and keep count using q
if (a[j] == v)
{
q--;
swap(a[j], a[q]);
}
}
// Move pivot element to its correct index

swap(a[i], a[r]);
// Move all left same occurrences from beginning

// to adjacent to arr[i]
j = i-1;
for (int k = l; k < p; k++, j--)
swap(a[k], a[j]);
// Move all right same occurrences from end

// to adjacent to arr[i]
i = i+1;
for (int k = r-1; k > q; k--, i++)
swap(a[i], a[k]);
}
// 3-way partition based quick sort

void quicksort(int a[], int l, int r)
{
if (r <= l) return;
int i, j;
// Note that i and j are passed as reference

partition(a, l, r, i, j);
// Recur
quicksort(a, l, j);
quicksort(a, i, r);
}

void printarr(int a[], int n)
{
for (int i = 0; i < n; ++i)
printf("%d ", a[i]);
printf("\n");
}
// Driver program
int main()
{
int a[] = {4, 9, 4, 4, 1, 9, 4, 4, 9, 4, 4, 1, 4};
int size = sizeof(a) / sizeof(int);
printarr(a, size);
quicksort(a, 0, size - 1);
printarr(a, size);
return 0;
}

Output:

4 9 4 4 1 9 4 4 9 4 4 1 4
1 1 4 4 4 4 4 4 4 4 9 9 9

Thanks to Utkarsh for suggesting above implementation.
Reference:
http://algs4.cs.princeton.edu/lectures/23DemoPartitioning.pdf
http://www.sorting-algorithms.com/quick-sort-3-way
discussed above.
Find maximum average subarray of k length
Given an array with positive and negative numbers, find the maximum average subarray of given length.
Example:
Input: arr[] = {1, 12, -5, -6, 50, 3}, k = 4

Output: Maximum average subarray of length 4 begins
at index 1.
Maximum average is (12 - 5 - 6 + 50)/4 = 51/4

A Simple Solution is to run two loops. The outer loop picks starting point, the inner loop goes till length ‘k’
from the starting point and computes average of elements. Time complexity of this solution is O(n*k).
A Better Solution is to create an auxiliary array of size n. Store cumulative sum of elements in this array.
Let the array be csum[]. csum[i] stores sum of elements from arr[0] to arr[i]. Once we have csum[] array
with us, we can compute sum between two indexes in O(1) time.
Below is C++ implementation of this idea. One observation is, a subarray of given length has maximum
average if it has maximum sum. So we can avoid floating point arithmetic by just comparing sum.

// C++ program to find maximum average subarray

// of given length.
// Returns beginning index of maximum average

// subarray of length 'k'
int findMaxAverage(int arr[], int n, int k)
{
// Check if 'k' is valid
if (k > n)
return -1;
// Create and fill array to store cumulative

// sum. csum[i] stores sum of arr[0] to arr[i]
int *csum = new int[n];
csum[0] = arr[0];
csum[i] = csum[i-1] + arr[i];
// Initialize max_sm as sum of first subarray

int max_sum = csum[k-1], max_end = k-1;
// Find sum of other subarrays and update

// max_sum if required.
{
int curr_sum = csum[i] - csum[i-k];
if (curr_sum > max_sum)
{
max_sum = curr_sum;
max_end = i;
}
}
delete [] csum; // To avoid memory leak
// Return starting index

return max_end - k + 1;
}
// Driver program
int main()
{
int arr[] = {1, 12, -5, -6, 50, 3};
int k = 4;
cout << "The maximum average subarray of "
"length "<< k << " begins at index "
<< findMaxAverage(arr, n, k);
return 0;
}

Output:

The maximum average subarray of length 4 begins at index 1

Time Complexity of above solution is O(n), but it requires O(n) auxiliary space.
We can avoid need of extra space by using below Efficient Method.

1) Compute sum of first ‘k’ elements, i.e., elements arr[0..k-1]. Let this sum be ‘sum’. Initialize ‘max_sum’ as
‘sum’
2) Do following for every element arr[i] where i varies from ‘k’ to ‘n-1′
…….a) Remove arr[i-k] from sum and add arr[i], i.e., do sum += arr[i] – arr[i-k]
…….b) If new sum becomes more than max_sum so far, update max_sum.
3) Return ‘max_sum’

// C++ program to find maximum average subarray

// of given length.
// Returns beginning index of maximum average

// subarray of length 'k'
int findMaxAverage(int arr[], int n, int k)
{
// Check if 'k' is valid
if (k > n)
return -1;
// Compute sum of first 'k' elements

int sum = arr[0];
sum += arr[i];
int max_sum = sum, max_end = k-1;
// Compute sum of remaining subarrays

{
int sum = sum + arr[i] - arr[i-k];
if (sum > max_sum)
{
max_sum = sum;
max_end = i;
}
}
// Return starting index

return max_end - k + 1;
}
// Driver program
int main()
{
int arr[] = {1, 12, -5, -6, 50, 3};
int k = 4;
cout << "The maximum average subarray of "
"length "<< k << " begins at index "
<< findMaxAverage(arr, n, k);
return 0;
}

Output:

The maximum average subarray of length 4 begins at index 1

Time complexity of this method is also O(n), but it requires constant extra space.
discussed above
Total number of non-decreasing numbers with n digits
A number is non-decreasing if every digit (except the first one) is greater than or equal to previous digit. For
example, 223, 4455567, 899, are non-decreasing numbers.
So, given the number of digits n, you are required to find the count of total non-decreasing numbers with n
digits.
Examples:
Input: n = 1
Output: count = 10
Input: n = 2
Output: count = 55
Input: n = 3
Output: count = 220

One way to look at the problem is, count of numbers is equal to count n digit number ending with 9 plus
count of ending with digit 8 plus count for 7 and so on. How to get count ending with a particular digit? We
can recur for n-1 length and digits smaller than or equal to the last digit. So below is recursive formula.
Count of n digit numbers = (Count of (n-1) digit numbers Ending with digit 9) +
(Count of (n-1) digit numbers Ending with digit 8) +
.............................................+
.............................................+
(Count of (n-1) digit numbers Ending with digit 0)

Let count ending with digit ‘d’ and length n be count(n, d)
count(n, d) = ∑ (count(n-1, i)) where i varies from 0 to d
Total count = ∑ count(n-1, d) where d varies from 0 to n-1

The above recursive solution is going to have many overlapping subproblems. Therefore, we can use
Dynamic Programming to build a table in bottom up manner. Below is Dynamic programming based C++
program.

// C++ program to count non-decreasing number with n digits

long long int countNonDecreasing(int n)

{
// dp[i][j] contains total count of non decreasing
// numbers ending with digit i and of length j
long long int dp[10][n+1];
memset(dp, 0, sizeof dp);
// Fill table for non decreasing numbers of length 1

// Base cases 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
for (int i = 0; i < 10; i++)
dp[i][1] = 1;
// Fill the table in bottom-up manner

for (int digit = 0; digit <= 9; digit++)
{
// Compute total numbers of non decreasing
// numbers of length 'len'
for (int len = 2; len <= n; len++)
{
// sum of all numbers of length of len-1
// in which last digit x is <= 'digit'
for (int x = 0; x <= digit; x++)
dp[digit][len] += dp[x][len-1];
}
}
long long int count = 0;
// There total nondecreasing numbers of length n

// wiint be dp[0][n] + dp[1][n] ..+ dp[9][n]
for (int i = 0; i < 10; i++)
count += dp[i][n];
return count;
}
// Driver program
int main()
{
int n = 3;
cout << countNonDecreasing(n);
return 0;
}

Output:

220

Thanks to Gaurav Ahirwar for suggesting above method.
Another method is based on below direct formula

Count of non-decreasing numbers with n digits =

N*(N+1)/2*(N+2)/3* ....*(N+n-1)/n
Where N = 10

Below is a C++ program to compute count using above formula.
// C++ program to count non-decreasing numner with n digits

long long int countNonDecreasing(int n)

{
int N = 10;
// Compute value of N*(N+1)/2*(N+2)/3* ....*(N+n-1)/n

long long count = 1;
{
count *= (N+i-1);
count /= i;
}
return count;
}
// Driver program
int main()
{
int n = 3;
cout << countNonDecreasing(n);
return 0;
}

Output:

220

Thanks to Abhishek Somani for suggesting this method.
How does this formula work?

N * (N+1)/2 * (N+2)/3 * .... * (N+n-1)/n
Where N = 10

Let us try for different values of n.

For n = 1, the value is N from formula.

Which is true as for n = 1, we have all single digit
numbers, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9.
For n = 2, the value is N(N+1)/2 from formula

We can have N numbers beginning with 0, (N-1) numbers
beginning with 1, and so on.
So sum is N + (N-1) + .... + 1 = N(N+1)/2
For n = 3, the value is N(N+1)/2(N+2)/3 from formula

We can have N(N+1)/2 numbers beginning with 0, (N-1)N/2
numbers beginning with 1 (Note that when we begin with 1,
we have N-1 digits left to consider for remaining places),
(N-2)(N-1)/2 beginning with 2, and so on.
Count = N(N+1)/2 + (N-1)N/2 + (N-2)(N-1)/2 +
(N-3)(N-2)/2 .... 3 + 1
[Combining first 2 terms, next 2 terms and so on]
= 1/2[N2 + (N-2)2 + .... 4]
= N*(N+1)*(N+2)/6 [Refer this , putting n=N/2 in the
even sum formula]

For general n digit case, we can apply Mathematical Induction. The count would be equal to count n-1 digit
beginning with 0, i.e., N*(N+1)/2*(N+2)/3* ….*(N+n-1-1)/(n-1). Plus count of n-1 digit numbers beginning
with 1, i.e., (N-1)*(N)/2*(N+1)/3* ….*(N-1+n-1-1)/(n-1) (Note that N is replaced by N-1) and so on.
discussed above
Time Complexity of Loop with Powers
What is the time complexity of below function?
void fun(int n, int k)

{
{
int p = pow(n, k);
for (int j=1; j<=p; j++)
{
// Some O(1) work
}
}
}

Time complexity of above function can be written as 1k + 2k + 3k + … n1k.
Let us try few examples:
k=1
Sum = 1 + 2 + 3 ... n
= n(n+1)/2
= n 2 + n/2
k=2
Sum = 12 + 22 + 32 + ... n12.
= n(n+1)(2n+1)/6
= n 3/3 + n2/2 + n/6
k=3
Sum = 13 + 23 + 33 + ... n13.
= n 2(n+1)2/4
= n 4/4 + n3/2 + n2/4

In general, asymptotic value can be written as (nk+1)/(k+1) + Θ(n k)
Note that, in asymptotic notations like Θ we can always ignore lower order terms. So the time complexity is
Θ(nk+1 / (k+1))
discussed above
Time Complexity where loop variable is incremented by 1, 2, 3, 4 ..
What is the time complexity of below code?
void fun(int n)
{
int j = 1;
for (int i = 0; i<n ;i++)
{
// Some O(1) task
i = i + j;
j++;
}
}

The loop variable ‘i’ is incremented by 1, 2, 3, 4, … until i becomes greater than or equal to n.
The value of i is x(x+1)/2 after x iterations. So if loop runs x times, then x(x+1)/2
Minimum positive points to reach destination
Given a grid with each cell consisting of positive, negative or no points i.e, zero points. We can move across a
cell only if we have positive points ( > 0 ). Whenever we pass through a cell, points in that cell are added to
our overall points. We need to find minimum initial points to reach cell (m-1, n-1) from (0, 0).
Constraints :
From a cell (i, j) we can move to (i+1, j) or (i, j+1).

We cannot move from (i, j) if your overall points at (i, j) is
We have to reach at (n-1, m-1) with minimum positive points i.e., > 0.
Example:
Input: points[m][n] = { {-2, -3, 3},

{-5, -10, 1},
{10, 30, -5}
};
Output: 7
Explanation:
7 is the minimum value to reach destination with
positive throughout the path. Below is the path.
(0,0) -> (0,1) -> (0,2) -> (1, 2) -> (2, 2)
We start from (0, 0) with 7, we reach(0, 1)

with 5, (0, 2) with 2, (1, 2) with 5, (2, 2)
with and finally we have 1 point (we needed
greater than 0 points at the end).

At the first look, this problem looks similar Max/Min Cost Path, but maximum overall points gained will not
guarantee the minimum initial points. Also, it is compulsory in the current problem that the points never
drops to zero or below. For instance, Suppose following two paths exists from source to destination cell.
We can solve this problem through bottom-up table filling dynamic programing technique.
To begin with, we should maintain a 2D array dp of the same size as the grid, where dp[i][j] represents
the minimum points that guarantees the continuation of the journey to destination before entering
the cell (i, j). It’s but obvious that dp[0][0] is our final solution. Hence, for this problem, we need to fill
the table from the bottom right corner to left top.
Now, let us decide minimum points needed to leave cell (i, j) (remember we are moving from bottom
to up). There are only two paths to choose: (i+1, j) and (i, j+1). Of course we will choose the cell that
the player can finish the rest of his journey with a smaller initial points. Therefore we have:
min_Points_on_exit = min(dp[i+1][j], dp[i][j+1])
Now we know how to compute min_Points_on_exit, but we need to fill the table dp[][] to get the solution in
dp[0][0].
How to compute dp[i][j]?

The value of dp[i][j] can be written as below.
dp[i][j] = max(min_Points_on_exit – points[i][j], 1)
Let us see how above expression covers all cases.

If points[i][j] == 0, then nothing is gained in this cell; the player can leave the cell with the same
points as he enters the room with, i.e. dp[i][j] = min_Points_on_exit.
If dp[i][j] If dp[i][j] > 0, then the player could enter (i, j) with points as little as min_Points_on_exit –
points[i][j]. since he could gain “points[i][j]” points in this cell. However, the value of
min_Points_on_exit – points[i][j] might drop to 0 or below in this situation. When this happens, we
must clip the value to 1 in order to make sure dp[i][j] stays positive:
dp[i][j] = max(min_Points_on_exit – points[i][j], 1).
Finally return dp[0][0] which is our answer.

// C++ program to find minimum initial points to reach destination

#define R 3
#define C 3
int minInitialPoints(int points[][C])

{
// dp[i][j] represents the minimum initial points player
// should have so that when starts with cell(i, j) successfully
// reaches the destination cell(m-1, n-1)
int dp[R][C];
int m = R, n = C;
// Base case
dp[m-1][n-1] = points[m-1][n-1] > 0? points[m-1][n-1]:
abs(points[m-1][n-1]) + 1;
// Fill last row and last column as base to fill

// entire table
for (int i = m-2; i >= 0; i--)
dp[i][n-1] = max(dp[i+1][n-1] - points[i][n-1], 1);
for (int j = n-2; j >= 0; j--)
dp[m-1][j] = max(dp[m-1][j+1] - points[m-1][j], 1);
// fill the table in bottom-up fashion

for (int i=m-2; i>=0; i--)
{
for (int j=n-2; j>=0; j--)
{
int min_points_on_exit = min(dp[i+1][j], dp[i][j+1]);
dp[i][j] = max(min_points_on_exit - points[i][j], 1);
}
}
return dp[0][0];
}
// Driver Program
int main()
{
int points[R][C] = { {-2,-3,3},

{-5,-10,1},
{10,30,-5}
};
cout << "Minimum Initial Points Required: "
<< minInitialPoints(points);
return 0;
}

Output:

Minimum Initial Points Required: 7

Count of n digit numbers whose sum of digits equals to given sum
Given two integers ‘n’ and ‘sum’, find count of all n digit numbers with sum of digits as ‘sum’. Leading 0’s are
not counted as digits.
1
Example:
Input: n = 2, sum = 2
Output: 2
Explanation: Numbers are 11 and 20
Output: 5
Explanation: Numbers are 14, 23, 32, 41 and 50
Output: 21

We strongly recommend you to minimize your browser and try this yourself first
The idea is simple, we subtract all values from 0 to 9 from given sum and recur for sum minus that digit.
Below is recursive formula.
countRec(n, sum) = {x + countRec(n-1, sum-x)}

where 0 = 0
One important observation is, leading 0's must be
handled explicitly as they are not counted as digits.
So our final count can be written as below.

finalCount(n, sum) = {x + countRec(n-1, sum-x)}
where 1 = 0

Below is a simple recursive solution based on above recursive formula.

// A recursive program to count numbers with sum

// of digits as given 'sum'
// Recursive function to count 'n' digit numbers

// with sum of digits as 'sum'. This function
// considers leading 0's also as digits, that is
// why not directly called
unsigned long long int countRec(int n, int sum)
{
// Base case
if (n == 0)
return sum == 0;
// Initialize answer
unsigned long long int ans = 0;
// Traverse through every digit and count

// numbers beginning with it using recursion
for (int i=0; i<=9; i++)
if (sum-i >= 0)
ans += countRec(n-1, sum-i);
return ans;
}
// This is mainly a wrapper over countRec. It

// explicitly handles leading digit and calls
// countRec() for remaining digits.
unsigned long long int finalCount(int n, int sum)
{
// Initialize final answer
// Traverse through every digit from 1 to

// 9 and count numbers beginning with it
for (int i = 1; i <= 9; i++)
if (sum-i >= 0)
return ans;
}
// Driver program
int main()
{
int n = 2, sum = 5;
cout << finalCount(n, sum);
return 0;
}

Output:

5

The time complexity of above solution is exponential. If we draw the complete recursion tree, we can
observer that many subproblems are solved again and again. For example, if we start with n = 3 and sum =
10, we can reach n = 1, sum = 8, by considering digit sequences 1,1 or 2, 0.
Since same suproblems are called again, this problem has Overlapping Subprolems property. So min square
sum problem has both properties (see this and this) of a dynamic programming problem.
Below is Memoization based C++ implementation.
// A recursive program to count numbers with sum

// of n as given 'sum'
// A lookup table used for memoization

unsigned long long int lookup[101][50001];
// Memoizatiob based implementation of recursive

// function
unsigned long long int countRec(int n, int sum)
{
// Base case
if (n == 0)
return sum == 0;
// If this subproblem is already evaluated,

// return the evaluated value
if (lookup[n][sum] != -1)
return lookup[n][sum];
// Initialize answer
// Traverse through every digit and

// recursively count numbers beginning
// with it
for (int i=0; i<10; i++)
if (sum-i >= 0)
return lookup[n][sum] = ans;

}

// countRec() for remaining n.
unsigned long long int finalCount(int n, int sum)
{
// Initialize all entries of lookup table
memset(lookup, -1, sizeof lookup);
// Initialize final answer

// Traverse through every digit from 1 to

// 9 and count numbers beginning with it
for (int i = 1; i <= 9; i++)
if (sum-i >= 0)
return ans;
}
// Driver program
int main()
{
int n = 3, sum = 5;
cout << finalCount(n, sum);
return 0;
}

Output:
Thanks to Gaurav Ahirwar for suggesting above solution.
discussed above
Count total number of N digit numbers such that the difference between
sum of even and odd digits is 1
Given a number n, we need to count total number of n digit numbers such that the sum of even digits is 1
more than the sum of odd digits. Here even and odd means positions of digits are like array indexes, for
exampl, the leftmost (or leading) digit is considered as even digit, next to leftmost is considered as odd and
so on.
Example
Input: n = 2
Output: Required Count of 2 digit numbers is 9
Explanation : 10, 21, 32, 43, 54, 65, 76, 87, 98.
Input: n = 3
Output: Required Count of 3 digit numbers is 54
Explanation: 100, 111, 122, ......, 980

This problem is mainly an extension of Count of n digit numbers whose sum of digits equals to given sum.
Here the solution of subproblems depend on four variables: digits, esum (current even sum), osum (current
odd sum), isEven(A flag to indicate whether current digit is even or odd).
Below is Memoization based solution for the same.
// A memoization based recursive program to count numbers

// with difference between odd and even digit sums as 1
// A lookup table used for memoization.

unsigned long long int lookup[50][1000][1000][2];
// Memnoization based recursive function to count numbers

// with even and odd digit sum difference as 1. This function
// conisders leading zero as a digit
unsigned long long int countRec(int digits, int esum,
int osum, bool isEven, int n)
{
// Base Case
if (digits == n)
return (esum - osum == 1);
// If current subproblem is already computed

if (lookup[digits][esum][osum][isEven] != -1)
return lookup[digits][esum][osum][isEven];
// If current digit is even, then add it to even sum and recur

if (isEven)
for (int i = 0; i <= 9; i++)
ans += countRec(digits+1, esum, osum+i, false, n);
ans += countRec(digits+1, esum, osum+i, false, n);
else // Add to odd sum and recur
for (int i = 0; i <= 9; i++)
ans += countRec(digits+1, esum+i, osum, true, n);
// Store current result in lookup table and return the same

return lookup[digits][esum][osum][isEven] = ans;
}

// countRec() for remaining digits.
unsigned long long int finalCount(int n)
{
// Initialize number digits considered so far
int digits = 0;
// Initialize all entries of lookup table

// Initializa final answer

// Initialize even and odd sums

int esum = 0, osum = 0;
// Explicitly handle first digit and call recursive function

// countRec for remaining digits. Note that the first digit
// is considered as even digit.
for (int i = 1; i <= 9; i++)
ans += countRec(digits+1, esum + i, osum, true, n);
return ans;
}
// Driver program
int main()
{
int n = 3;
cout << "Coutn of "<<n << " digit numbers is " << finalCount(n);
return 0;
}

Output:

Count of 3 digit numbers is 54

Thanks to Gaurav Ahirwar for providing above solution.
discussed above
Why is Binary Heap Preferred over BST for Priority Queue?
A typical Priority Queue requires following operations to be efficient.
1. Get Top Priority Element (Get minimum or maximum)

2. Insert an element
3. Remove top priority element
4. Decrease Key
A Binary Heap supports above operations with following time complexities:
1. O(1)
2. O(Logn)
3. O(Logn)
4. O(Logn)
A Self Balancing Binary Search Tree like AVL Tree, Red-Black Tree, etc can also support above operations
with same time complexities.
1. Finding minimum and maximum are not naturally O(1), but can be easily implemented in O(1) by
keeping an extra pointer to minimum or maximum and updating the pointer with insertion and
deletion if required. With deletion we can update by finding inorder predecessor or successor.
2. Inserting an element is naturally O(Logn)
3. Removing maximum or minimum are also O(Logn)
4. Decrease key can be done in O(Logn) by doing a deletion followed by insertion.
So why is Binary Heap Preferred for Priority Queue?
Since Binary Heap is implemented using arrays, there is always better locality of reference and
operations are more cache friendly.
Although operations are of same time complexity, constants in Binary Search Tree are higher./li>
We can build a Binary Heap in O(n) time. Self Balancing BSTs require O(nLogn) time to construct.
Binary Heap doesn’t require extra space for pointers.
Binary Heap is easier to implement.
There are variations of Binary Heap like Fibonacci Heap that can support insert and decrease-key in
Θ(1) time
Is Binary Heap always better?

Although Binary Heap better than Self-Balancing BSTs for implementation of Priority Queue, BSTs have
their own advantages and the list of advantages is in-fact bigger compared to binary heap.
Searching an element in self-balancing BST is O(Logn) which is O(n) in Binary Heap.

We can print all elements of BST in sorted order in O(n) time, but Binary Heap requires O(nLogn)
time.
Floor and ceil can be found in O(Logn) time.
K’th largest/smallest element be found in O(Logn) time by augmenting tree with an additional field.
This article is contributed by Vivek Gupta. Please write comments if you find anything incorrect, or you
Print string of odd length in ‘X’ format
Given a string of odd length, print the string X format.
Examples:
Input: 12345
Output:
1 5
2 4
3
2 4
1 5
Input: geeksforgeeks
Output:
g s
e k
e e
k e
s g
f r
o
f r
s g
k e
e e
e k
g s

The idea is to use two variables in a single loop, the first variable ‘i’ goes from left to right and second
variables ‘j’ goes from right to left. The upper part of Cross (or X) is printed before they meet. The central
character is printed when they meet and lower parted is printed after they cross each other. In the upper
part str[i] is printed before str[j] and in the lower part, str[j] is printed before str[i].
// C++ program to print Cross pattern

#include<iostream>
// Function to print given string in cross pattern

// Length of string must be odd
void printPattern(string str)
{
// i goes from 0 to len and j goes from len-1 to 0

for (int i=0,j=len-1; i<=len,j>=0; i++,j--)
{
// To print the upper part. This loop runs
// til middle point of string (i and j become
// same
if (i<j)
{
{
// Print i spaces
for (int x=0; x<i; x++)
cout << " ";
// Print i'th character

cout << str[i];
// Print j-i-1 spaces

for (int x=0; x<j-i-1; x++)
cout << " ";
// Print j'th character

cout << str[j] << endl;
}
// To print center point

if (i==j)
{
// Print i spaces
for (int x=0; x<i; x++)
cout << " ";
// Print middle character

cout << str[i] << endl;
}
// To print lower part

else if (i>j)
{
// Print j spances
for (int x = j-1; x>=0; x--)
cout << " ";
// Print j'th character

cout << str[j];
// Print i-j-1 spaces

for (int x=0; x<i-j-1; x++)
cout << " ";
// Print i'h character

cout << str[i] << endl;
}
}
}
// Driver program
int main()
{
printPattern("geeksforgeeks");
return 0;
}

Output:

g s
e k
e e
k e
s g
f r
o
f r
s g
k e
e e
e k
g s

This article is contributed by Dinesh T.P.D. Please write comments if you find anything incorrect, or you
Validity of a given Tic-Tac-Toe board configuration
A Tic-Tac-Toe board is given after some moves are played. Find out if the given board is valid, i.e., is it
possible to reach this board position after some moves or not.
Note that every arbitrary filled grid of 9 spaces isn’t valid e.g. a grid filled with 3 X and 6 O isn’t valid
situation because each player needs to take alternate turns.
Input is given as a 1D array of size 9.
Input: board[] = {'X', 'X', 'O',

'O', 'O', 'X',
'X', 'O', 'X'};
Output: Valid
Input: board[] = {'O', 'X', 'X',

'O', 'X', 'X',
'O', 'O', 'X'};
Output: Invalid
(Both X and O cannot win)
Input: board[] = {'O', 'X', ' ',

' ', ' ', ' ',
' ', ' ', ' '};
Output: Valid
(Valid board with only two moves played)

Basically, to find the validity of an input grid, we can think of the conditions when an input grid is invalid.
Let no. of “X”s be countX and no. of “O”s be countO. Since we know that the game starts with X, a given grid
of Tic-Tac-Toe game would be definitely invalid if following two conditions meet
a) countX != countO AND
b) countX != countO + 1
Since “X” is always the first move, second condition is also required.
Now does it mean that all the remaining board positions are valid one? The answer is NO. Think of the cases
when input grid is such that both X and O are making straight lines. This is also not valid position because
the game ends when one player wins. So we need to check the following condition as well
c) If input grid shows that both the players are in winning situation, it’s an invalid position.
d) If input grid shows that the player with O has put a straight-line (i.e. is in win condition) and countX !=
countO, it’s an invalid position. The reason is that O plays his move only after X plays his move. Since X has
started the game, O would win when both X and O has played equal no. of moves.
Armed with above conditions i.e. a), b), c) and d), we can now easily formulate an algorithm/program to
check the validity of a given Tic-Tac-Toe board position.
1) countX == countO or countX == countO + 1

2) If O is in win condition then check
a) If X also wins, not valid
b) If xbox != obox , not valid

Another way to find the validity of a given board is using ‘inverse method’ i.e. rule out all the possibilities
when a given board is invalid.
// C++ program to check whether a given tic tac toe

// board is valid or not
#include <iostream>
// This matrix is used to find indexes to check all

// possible wining triplets in board[0..8]
int win[8][3] = {{0, 1, 2}, // Check first row.
{3, 4, 5}, // Check second Row
{6, 7, 8}, // Check third Row
{0, 3, 6}, // Check first column
{1, 4, 7}, // Check second Column
{2, 5, 8}, // Check third Column
{0, 4, 8}, // Check first Diagonal
{2, 4, 6}}; // Check second Diagonal
// Returns true if character 'c' wins. c can be either

// 'X' or 'O'
bool isCWin(char *board, char c)
{
// Check all possible winning combinations
for (int i=0; i<8; i++)
if (board[win[i][0]] == c &&
board[win[i][1]] == c &&
board[win[i][2]] == c )
return true;
return false;
}
// Returns true if given board is valid, else returns false

bool isValid(char board[9])
{
// Count number of 'X' and 'O' in the given board
int xCount=0, oCount=0;
for (int i=0; i<9; i++)
{
if (board[i]=='X') xCount++;
if (board[i]=='O') oCount++;
}
// Board can be valid only if either xCount and oCount
// is same or xount is one more than oCount
if (xCount==oCount || xCount==oCount+1)
{
// Check if 'O' is winner
if (isCWin(board, 'O'))
{
// Check if 'X' is also winner, then
// return false
if (isCWin(board, 'X'))
return false;
// Else return true xCount and yCount are same

return (xCount == oCount);
}
// If 'O' is not winner, then return true

return true;
}
return false;
}
// Driver program
int main()
{
char board[] = {'X', 'X', 'O',
'O', 'O', 'X',
'X', 'O', 'X'};
(isValid(board))? cout << "Given board is valid":
cout << "Given board is not valid";
return 0;
}

Output:

Given board is valid

Thanks to Utkarsh for suggesting this solution here.
discussed above
Find the largest rectangle of 1’s with swapping of columns allowed
Given a matrix with 0 and 1’s, find the largest rectangle of all 1’s in the matrix. The rectangle can be formed
by swapping any pair of columns of given matrix.
Example:
Input: bool mat[][] = { {0, 1, 0, 1, 0},

{0, 1, 0, 1, 1},
{1, 1, 0, 1, 0}
};
Output: 6
The largest rectangle's area is 6. The rectangle
can be formed by swapping column 2 with 3
The matrix after swapping will be
0 0 1 1 0
0 0 1 1 1
1 0 1 1 0
Input: bool mat[R][C] = { {0, 1, 0, 1, 0},

{0, 1, 1, 1, 1},
{1, 1, 1, 0, 1},
{1, 1, 1, 1, 1}
};
Output: 9

The idea is to use an auxiliary matrix to store count of consecutive 1’s in every column. Once we have these
counts, we sort all rows of auxiliary matrix in non-increasing order of counts. Finally traverse the sorted rows
to find the maximum area.
Below are detailed steps for first example mentioned above.
Step 1: First of all, calculate no. of consecutive 1’s in every column. An auxiliary array hist[][] is used to
store the counts of consecutive 1’s. So for the above first example, contents of hist[R][C] would be
0 1 0 1 0
0 2 0 2 1
1 3 0 3 0

Time complexity of this step is O(R*C)
Step 2: Sort the rows in non-increasing fashion. After sorting step the matrix hist[][] would be
1 1 0 0 0
2 2 1 0 0
3 3 1 0 0

This step can be done in O(R * (R + C)). Since we know that the values are in range from 0 to R, we can use
counting sort for every row.
Step 3: Traverse each row of hist[][] and check for the max area. Since every row is sorted by count of 1’s,
current area can be calculated by multiplying column number with value in hist[i][j]. This step also takes
O(R * C) time.
Below is C++ implementation based of above idea.
// C++ program to find the largest rectangle of 1's with swapping

// of columns allowed.
#define R 3
#define C 5
// Returns area of the largest rectangle of 1's

int maxArea(bool mat[R][C])
{
// An auxiliary array to store count of consecutive 1's
// in every column.
int hist[R+1][C+1];
// Step 1: Fill the auxiliary array hist[][]

{
// First row in hist[][] is copy of first row in mat[][]
hist[0][i] = mat[0][i];
// Fill remaining rows of hist[][]

for (int j=1; j<R; j++)
hist[j][i] = (mat[j][i]==0)? 0: hist[j-1][i]+1;
}
// Step 2: Sort rows of hist[][] in non-increasing order

{
int count[R+1] = {0};
// counting occurrence
count[hist[i][j]]++;
// Traverse the count array from right side

int col_no = 0;
for (int j=R; j>=0; j--)
{
if (count[j] > 0)
{
for (int k=0; k<count[j]; k++)
{
hist[i][col_no] = j;
col_no++;
}
}
}
}
// Step 3: Traverse the sorted hist[][] to find maximum area

int curr_area, max_area = 0;
int curr_area, max_area = 0;
{
{
// Since values are in decreasing order,
// The area ending with cell (i, j) can
// be obtained by multiplying column number
// with value of hist[i][j]
curr_area = (j+1)*hist[i][j];
if (curr_area > max_area)
max_area = curr_area;
}
}
return max_area;
}
// Driver program
int main()
{
bool mat[R][C] = { {0, 1, 0, 1, 0},
{0, 1, 0, 1, 1},
{1, 1, 0, 1, 0}
};
cout << "Area of the largest rectangle is " << maxArea(mat);
return 0;
}

Output:

Area of the largest rectangle is 6

Time complexity of above solution is O(R * (R + C)) where R is number of rows and C is number of
columns in input matrix.
Extra space: O(R * C)
This article is contributed by Shivprasad Choudhary. Please write comments if you find anything
Find the maximum of minimums for every window size in a given array
Given an integer array of size n, find the maximum of the minimum’s of every window size in the array. Note
that window size varies from 1 to n.
Example:
Input: arr[] = {10, 20, 30, 50, 10, 70, 30}

Output: 70, 30, 20, 10, 10, 10, 10
First element in output indicates maximum of minimums of all

windows of size 1.
Minimums of windows of size 1 are {10}, {20}, {30}, {50}, {10},
{70} and {30}. Maximum of these minimums is 70
Second element in output indicates maximum of minimums of all

windows of size 2.
Minimums of windows of size 2 are {10}, {20}, {30}, {10}, {10},
and {30}. Maximum of these minimums is 30
Third element in output indicates maximum of minimums of all

windows of size 3.
Minimums of windows of size 3 are {20}, {10}, {10}, {10} and {10}.
Maximum of these minimums is 20
Similarly other elements of output are computed.

A Simple Solution is to go through all windows of every size, find maximum of all windows. Below is C++
implementation of this idea.

// A naive method to find maximum of minimum of all windows of

// different sizes
#include <iostream>
void printMaxOfMin(int arr[], int n)

{
// Consider all windows of different sizes starting
// from size 1
for (int k=1; k<=n; k++)
{
// Initialize max of min for current window size k
int maxOfMin = arr[0];
// Traverse through all windows of current size k

for (int i = 0; i <= n-k; i++)
{
// Find minimum of current window
int min = arr[i];
for (int j = 1; j < k; j++)
{
if (arr[i+j] < min)
min = arr[i+j];
}
// Update maxOfMin if required

if (min > maxOfMin)
maxOfMin = min;
}
// Print max of min for current window size

cout << maxOfMin << " ";
}
}
// Driver program
int main()
{
int arr[] = {10, 20, 30, 50, 10, 70, 30};
printMaxOfMin(arr, n);
return 0;
}

Output:

70 30 20 10 10 10 10

Time complexity of above solution can be upper bounded by O(n3).
We can solve this problem in O(n) time using an Efficient Solution. The idea is to extra space. Below are
detailed steps.
Step 1: Find indexes of next smaller and previous smaller for every element. Next smaller is the largest
element on right side of arr[i] such that the element is smaller than arr[i]. Similarly, previous smaller
element is on left side/
If there is no smaller element on right side, then next smaller is n. If there is no smaller on left side, then
previous smaller is -1.
For input {10, 20, 30, 50, 10, 70, 30}, array of indexes of next smaller is {7, 4, 4, 4, 7, 6, 7}.
For input {10, 20, 30, 50, 10, 70, 30}, array of indexes of previous smaller is {-1, 0, 1, 2, -1, 4, 4}
This step can be done in O(n) time using the approach discussed in next greater element.
Step 2: Once we have indexes of next and previous smaller, we know that arr[i] is a minimum of a window of
length “right[i] – left[i] – 1″. Lengths of windows for which the elements are minimum are {7, 3, 2, 1, 7, 1, 2}.
This array indicates, first element is minimum in window of size 7, second element is minimum in window
of size 1, and so on.
Create an auxiliary array ans[n+1] to store the result. Values in ans[] can be filled by iterating through
right[] and left[]
for (int i=0; i

We get the ans[] array as {0, 70, 30, 20, 0, 0, 0, 10}. Note that ans[0] or answer for l
ength 0 is useless.
Step 3:Some entries in ans[] are 0 and yet to be filled. For example, we know maximum of
minimum for lengths 1, 2, 3 and 7 are 70, 30, 20 and 10 respectively, but we don't know t
he same for lengths 4, 5 and 6.
Below are few important observations to fill remaining entries
a) Result for length i, i.e. ans[i] would always be greater or same as result for length
i+1, i.e., an[i+1].
b) If ans[i] is not filled it means there is no direct element which is minimum of lengt
h i and therefore either the element of length ans[i+1], or ans[i+2], and so on is same
as ans[i]
So we fill rest of the entries using below loop.

for (int i=n-1; i>=1; i--)
ans[i] = max(ans[i], ans[i+1]);


// An efficient C++ program to find maximum of all minimums of
// windows of different sizes
#include <iostream>
#include<stack>
void printMaxOfMin(int arr[], int n)

{
stack<int> s; // Used to find previous and next smaller
// Arrays to store previous and next smaller

int left[n+1];
int right[n+1];
int right[n+1];
// Initialize elements of left[] and right[]

{
left[i] = -1;
right[i] = n;
}
// Fill elements of left[] using logic discussed on

// http://www.geeksforgeeks.org/next-greater-element/
{
while (!s.empty() && arr[s.top()] >= arr[i])
s.pop();
if (!s.empty())
left[i] = s.top();
s.push(i);
}
// Empty the stack as stack is going to be used for right[]

while (!s.empty())
s.pop();
// Fill elements of right[] using same logic

for (int i = n-1 ; i>=0 ; i-- )
{
while (!s.empty() && arr[s.top()] >= arr[i])
s.pop();
if(!s.empty())
right[i] = s.top();
s.push(i);
}
// Create and initialize answer array

int ans[n+1];
ans[i] = 0;
// Fill answer array by comparing minimums of all

// lengths computed using left[] and right[]
{
// length of the interval
int len = right[i] - left[i] - 1;
// arr[i] is a possible answer for this length

// 'len' interval, check if arr[i] is more than
// max for 'len'
ans[len] = max(ans[len], arr[i]);
}
// Some entries in ans[] may not be filled yet. Fill

// them by taking values from right side of ans[]
for (int i=n-1; i>=1; i--)
ans[i] = max(ans[i], ans[i+1]);
// Print the result

cout << ans[i] << " ";
}
}
// Driver program
int main()
{
int arr[] = {10, 20, 30, 50, 10, 70, 30};
printMaxOfMin(arr, n);
return 0;
}

Output:
70 30 20 10 10 10 10
This article is contributed by Ekta Goel. Please write comments if you find anything inc
orrect, or you want to share more information about the topic discussed above

Print Common Nodes in Two Binary Search Trees
Given two Binary Search Trees, find common nodes in them. In other words, find intersection of two BSTs.
Example:
Method 1 (Simple Solution) A simple way is to one by once search every node of first tree in second tree.
Time complexity of this solution is O(m * h) where m is number of nodes in first tree and h is height of
second tree.
Method 2 (Linear Time) We can find common elements in O(n) time.

1) Do inorder traversal of first tree and store the traversal in an auxiliary array ar1[]. See sortedInorder()
here.
2) Do inorder traversal of second tree and store the traversal in an auxiliary array ar2[]
3) Find intersection of ar1[] and ar2[]. See this for details.
Time complexity of this method is O(m+n) where m and n are number of nodes in first and second tree
respectively. This solution requires O(m+n) extra space.
Method 3 (Linear Time and limited Extra Space) We can find common elements in O(n) time and
O(h1 + h2) extra space where h1 and h2 are heights of first and second BSTs respectively.
The idea is to use iterative inorder traversal. We use two auxiliary stacks for two BSTs. Since we need to find
common elements, whenever we get same element, we print it.
// Iterative traversal based method to find common elements

// in two BSTs.
#include<iostream>
#include<stack>
// A BST node
struct Node
{
int key;
};

Node *newNode(int ele)
{
{
temp->key = ele;
return temp;
}
// Function two print common elements in given two trees

void printCommon(Node *root1, Node *root2)
{
// Create two stacks for two inorder traversals
stack<Node *> stack1, s1, s2;
while (1)
{
// push the Nodes of first tree in stack s1
if (root1)
{
s1.push(root1);
root1 = root1->left;
}
// push the Nodes of second tree in stack s2

else if (root2)
{
s2.push(root2);
root2 = root2->left;
}
// Both root1 and root2 are NULL here

else if (!s1.empty() && !s2.empty())
{
root1 = s1.top();
root2 = s2.top();
// If current keys in two trees are same

if (root1->key == root2->key)
{
cout << root1->key << " ";
s1.pop();
s2.pop();
// move to the inorder successor

root1 = root1->right;
}
else if (root1->key < root2->key)

{
// If Node of first tree is smaller, than that of
// second tree, then its obvious that the inorder
// successors of current Node can have same value
// as that of the second tree Node. Thus, we pop
// from s2
s1.pop();
// root2 is set to NULL, because we need

// new Nodes of tree 1
root2 = NULL;
}
else if (root1->key > root2->key)
{
s2.pop();
root1 = NULL;
}
}
// Both roots and both stacks are empty

else break;
}
}
// A utility function to do inorder traversal

void inorder(struct Node *root)
{
if (root)
{
cout<<root->key<<" ";
}
}
/* A utility function to insert a new Node with given key in BST */

struct Node* insert(struct Node* node, int key)
{
/* If the tree is empty, return a new Node */

/* return the (unchanged) Node pointer */

return node;
}
// Driver program
int main()
{
// Create first tree as shown in example
Node *root1 = NULL;
root1 = insert(root1, 5);
// Create second tree as shown in example

Node *root2 = NULL;
cout << "Tree 1 : ";

inorder(root1);
cout << endl;
cout << "Tree 2 : ";

inorder(root2);
cout << "\nCommon Nodes: ";
printCommon(root1, root2);
return 0;
}

Output:

4 7 9 10

This article is contributed by Ekta Goel. Please write comments if you find anything incorrect, or you want
Citicorp Interview Experience | Set 2 (On-Campus)
Written Round:
It was conducted on aspiringminds and there were 4 sections in total; quantitative aptitude , verbal , logical
and 2 codes in the last section. Shortlisting was done on the basis of only 3 sections, coding section was not a
part of shortlisting.
First Round (technical):
First quest. was Tell me about urself. And then a series of coding question followed as i said in my intro m
gud with coding.
# AVL tree basic rotation.
#Trie tree no code just wanted to know how it works.
#Deletion in BST.
#Nth element from end in singly linked list.
#Middle element in a linked list.
#Implementation of DEQUE.
#stack using linked list.
#All anagrams of a string.
#Was to create a data structure in which i used linked list to create and successfully did that but don’t
remember what was actual question.
#Segregation of 0.1.2’s in an array.
few more question which i dont remember right nw. And 1 question he asked me from DBMS which i was
unable to do as he wanted me to do but my solution was also correct.
The interview continued for 1 hr arnd or may be l’ll more.
Second Round(HR)
started with introduction and basic HR question about family background and hobbies but apart from these
he asked me to implement hash function in c++.
The interview continued for 15-20 min.
Third Round(Technical)
From all other fellow they took only 2 round but i was called for 3rd.
The interviewer wanted to know do i have some background of oops and OS because in my earlier rounds i
was not asked in those topics. so he asked few basic questions from OS as well as oops and then in 15 min.
only he was satisfied since they were getting late for dinner. It was at 12:30 midnight.And then he asked me
to ask any queries if i have.
I just asked about the verticles and environment. he gave me all details for next 15 min. and then it was over.
Geeks.
Find all possible outcomes of a given expression
Given an arithmetic expression, find all possible outcomes of this expression. Different outcomes are
evaluated by putting brackets at different places.
We may assume that the numbers are single digit numbers in given expression.
Example:
Input: 1+3*2
Output: 8 7
Explanation
(1 + 3)*2 = 80
(1 + (3 * 2)) = 70
Input: 1*2+3*4
Output: 14 20 14 20 20
(1*(2+(3*4))) = 14
(1*((2+3)*4)) = 20
((1*2)+(3*4)) = 14
((1*(2+3))*4) = 20
((1*2)+3)*4) = 20

The idea is to iterate through every operator in given expression. For every operator, evaluate all possible
values of its left and right sides. Apply current operator on every pair of left side and right side values and
add all evaluated values to the result.
1) Initialize result 'res' as empty.

2) Do following for every operator 'x'.
a) Recursively evaluate all possible values on left of 'x'.
Let the list of values be 'l'.
a) Recursively evaluate all possible values on right of 'x'.
Let the list of values be 'r'.
c) Loop through all values in list 'l'
loop through all values in list 'r'
Apply current operator 'x' on current items of
'l' and 'r' and add the evaluated value to 'res'
3) Return 'res'.

// C++ program to evaluate all possible values of

// a expression
// Utility function to evaluate a simple expression

// with one operator only.
int eval(int a, char op, int b)
{
if (op=='+') return a+b;
if (op=='+') return a+b;
if (op=='-') return a-b;
if (op == '*') return a*b;
}
// This function evaluates all possible values and

// returns a list of evaluated values.
vector<int> evaluateAll(string exp, int low, int high)
{
// To store result (all possible evaluations of
// given expression 'exp')
vector<int> res;
// If there is only one character, it must

// be a digit (or operand), return it.
if (low == high)
{
res.push_back(exp[low] - '0');
return res;
}
// If there are only three characters, middle

// one must be operator and corner ones must be
// operand
if (low == (high-2))
{
int num = eval(exp[low]-'0', exp[low+1],
exp[low+2]-'0');
res.push_back(num);
return res;
}
// every i refers to an operator

for (int i=low+1; i<=high; i+=2)
{
// l refers to all the possible values
// in the left of operator
vector<int> l = evaluateAll(exp, low, i-1);
// r refers to all the possible values

// in the right of operator
vector<int> r = evaluateAll(exp, i+1, high);
// Take above evaluated all possible

// values in left side of 'i'
for (int s1=0; s1<l.size(); s1++)
{
// Take above evaluated all possible
// values in right side of 'i'
for (int s2=0; s2<r.size(); s2++)
{
// Calculate value for every pair
// and add the value to result.
int val = eval(l[s1], exp[i], r[s2]);
res.push_back(val);
}
}
}
return res;
}
// Driver program
int main()
{
{
string exp = "1*2+3*4";
int len = exp.length();
vector<int> ans = evaluateAll(exp, 0, len-1);
for (int i=0; i< ans.size(); i++)

cout << ans[i] << endl;
return 0;
}

Output:

14
20
14
20
20

Exercise: Extend the above solution so that it works for numbers with multiple digits also. For example,
expressions like “100*30+20″ (Hint: We can create an integer array to store all operands and operators of
given expression).
Wooqer Interview Experience | Set 1 (on-Campus)
Recently Wooqer visited our campus and took the following rounds for the final selection.
Round 1:
Written aptitude round containing basic questions on C and C++ programming.The questions were easy.
Around 20 students were selected for second round.
Round 2(WRITTEN coding ):
1.The list of stock prices are given after consecutive 1 second.You have to select two stock prices which should
be bought and then sold respectively to attain a maximum profit.You have to print the maximum profit.
I/p: 2,6,9,15,89,100
O/p:98
2.Donot remember the entire question but involved hashing and involving good approach on strucures and
structures using array.
Around 10 students were selected after the written coding round.
Round 3(HR Round):

1.Tell me about yourself.
2.Tell me your hobbies.
3.Tell me your strengths.
4.Why should i hire you.
5.Why do u want to join Wooqer.
6.What so u know about Wooqer?
7.Then he asked my CGPA and JEE MAINS Rank and JEE Advanced Marks.
8.Finally he asked do u hav any questions for me?
I have prepared these questions well and the interviewer seemed happy after this.
As expected i was on the top and was one of 4 chosen for next and final technical round:
Round 4(Technical):
1.WAP to check if a given binary tree is a binary search tree?

http://www.geeksforgeeks.org/a-program-to-check-if-a-binary-tree-is-bst-or-not/
He also discussed about binary search trees and asked me to write the full code.
2.WAP to check the duplicates in a given array containing N elements from 0 to N-1.I told him using hashing
and then using modified binary search.He did not ask me to code.
3.He aslo asked me why i want to join wooqer?
4.Finally he asked me if i had any question? then i ask how any company trusts wooqer before providing
data. Then he very nicely explains it to me.
I had done really well in this round also.
I want to thanks geeksforgeeks for helping me acquiring this intern.
Geeks.
Euclid’s Algorithm when % and / operations are costly
Euclid’s algorithm is used to find GCD of two numbers.
There are mainly two versions of algorithm.

Version 1 (Using subtraction)
// Recursive function to return gcd of a and b

{
if (a == b)
return a;

return (a > b)? gcd(a-b, b): gcd(a, b-a);
}

Version 2 (Using modulo operator)

{
if (a == 0)
return b;

return gcd(b%a, a);
}

Which of the above two is more efficient?

Version 1 can take linear time to find the GCD, consider the situation when one of the given numbers is
much bigger than the other. Version 2 is obviously more efficient as there are less recursive calls and takes
logarithmic time.
Consider a situation where modulo operator is not allowed, can we optimize version 1 to
work faster?
Below are some important observations. The idea is to use bitwise operators. We can find x/2 using x>>1.
We can check whether x is odd or even using x&1.
gcd(a, b) = 2*gcd(a/2, b/2) if both a and b are even.

gcd(a, b) = gcd(a/2, b) if a is even and b is odd.
gcd(a, b) = gcd(a, b/2) if a is odd and b is even.
Below is C++ implementation.

// Efficient C++ program when % and / are not allowed

{
// Base cases
if (b == 0 || a == b) return a;
if (a == 0) return b;
// If both a and b are even, divide both a

// and b by 2. And multiply the result with 2
if ( (a & 1) == 0 && (b & 1) == 0 )
return gcd(a>>1, b>>1) << 1;
// If a is even and b is odd, divide a bb 2

if ( (a & 1) == 0 && (b & 1) != 0 )
return gcd(a>>1, b);
// If a is odd and b is even, divide b bb 2

if ( (a & 1) != 0 && (b & 1) == 0 )
return gcd(a, b>>1);
// If both are odd, then apply normal subtraction

// algorithm. Note that odd-odd case always
// converts odd-even case after one recursion
return (a > b)? gcd(a-b, b): gcd(a, b-a);
}

This article is compiled by Shivam Agrawal. Please write comments if you find anything incorrect, or you
Find the largest subarray with 0 sum
Given an array of integers, find length of the largest subarray with sum equals to 0.
Examples:
Input: arr[] = {15, -2, 2, -8, 1, 7, 10, 23};

Output: 5
The largest subarray with 0 sum is -2, 2, -8, 1, 7
Input: arr[] = {1, 2, 3}

Output: 0
There is no subarray with 0 sum
Input: arr[] = {1, 0, 3}

Output: 1

A simple solution is to consider all subarrays one by one and check the sum of every subarray. We can run
two loops: the outer loop picks a starting point i and the inner loop tries all subarrays starting from i. Time
complexity of this method is O(n 2).
Below is C++ implementation of this solution.

/* A simple C++ program to find largest subarray with 0 sum */

// Returns length of the largest subarray with 0 sum

int maxLen(int arr[], int n)
{

for (int i = 0; i < n; i++)
{
// Initialize currr_sum for every starting point
int curr_sum = 0;
// try all subarrays starting with 'i'

for (int j = i; j < n; j++)
{
curr_sum += arr[j];
// If curr_sum becomes 0, then update max_len

// if required
if (curr_sum == 0)
max_len = max(max_len, j-i+1);
}
}
return max_len;
}

int main()
{
int arr[] = {15, -2, 2, -8, 1, 7, 10, 23};
cout << "Length of the longest 0 sum subarray is "
<< maxLen(arr, n);
return 0;
}

Output:

Length of the longest 0 sum subarray is 5

We can Use Hashing to solve this problem in O(n) time. The idea is to iterate through the array and for
every element arr[i], calculate sum of elements form 0 to i (this can simply be done as sum += arr[i]). If the
current sum has been seen before, then there is a zero sum array. Hashing is used to store the sum values, so
that we can quickly store sum and find out whether the current sum is seen before or not.
Following is Java implementation of the above approach.

// A Java program to find maximum length subarray with 0 sum

class MaxLenZeroSumSub {
// Returns length of the maximum length subarray with 0 sum

static int maxLen(int arr[])
{
int sum = 0; // Initialize sum of elements


{
// Add current element to sum
sum += arr[i];
if (arr[i] == 0 && max_len == 0)

max_len = 1;
if (sum == 0)
max_len = i+1;
// Look this sum in hash table

Integer prev_i = hM.get(sum);
// If this sum is seen before, then update max_len

// if required
if (prev_i != null)
max_len = Math.max(max_len, i-prev_i);
else // Else put this sum in hash table
hM.put(sum, i);
}
return max_len;
}
// Drive method
{
int arr[] = {15, -2, 2, -8, 1, 7, 10, 23};
System.out.println("Length of the longest 0 sum subarray is "
+ maxLen(arr));
}
}
Output:

Length of the longest 0 sum subarray is 5

Time Complexity of this solution can be considered as O(n) under the assumption that we have good hashing
function that allows insertion and retrieval operations in O(1) time.
This article is contributed by Rahul Agrawal. Please write comments if you find anything incorrect, or you
Check if a given number is sparse or not
A number is said to be a sparse number if in binary representation of the number no two or more
consecutive bits are set. Write a function to check if a given number is Sparse or not.
Example:
Input: x = 72
Output: true
Explanation: Binary representation of 72 is 01001000.
There are no two consecutive 1's in binary representation
Input: x = 12
Output: false
Explanation: Binary representation of 12 is 1100.
Third and fourth bits (from end) are set.

If we observer carefully, then we can notice that if we can use bitwise AND of binary representation of the
“given number its “right shifted number”(i.e., half the given number) to figure out whether the number is
sparse or not. Result of AND operator would be 0 if number is sparse and non-zero if not sparse.

// C++ program to check if n is sparse or not

#include<iostream>
// Return true if n is sparse, else false

bool checkSparse(int n)
{
// n is not sparse if there is set
// in AND of n and n/2
if (n & (n>>1))
return false;
return true;
}
// Driver program
int main()
{
cout << checkSparse(72) << endl;
return 0;
}

Output:
1
0
1
0

Note: Instead of right shift, we could have used left shift also, but left shift might lead to overflow in some
cases.
This article is contributed by Vimal Vestron. Please write comments if you find anything incorrect, or you
Priority Inversion : What the heck !
Let us first put ‘priority inversion’ in the context of the Big Picture i.e. where does this come from.
In Operating System, one of the important concepts is Task Scheduling. There are several Scheduling
methods such as First Come First Serve, Round Robin, Priority based scheduling etc. Each scheduling
method has its pros and cons. As you might have guessed, Priority Inversion comes under Priority based
Scheduling. Basically, it’s a problem which arises sometimes when Priority based scheduling is used by OS.
In Priority based scheduling, different tasks are given different priority so that higher priority tasks can
intervene lower priority tasks if possible. So, in a priority based scheduling, if lower priority task (L) is
running and if a higher priority task (H) also needs to run, the lower priority task (L) would be preempted by
higher priority task (H). Now, suppose both lower and higher priority tasks need to share a common
resource (say access to the same file or device) to achieve their respective work. In this case, since there’s
resource sharing and task synchronization is needed, several methods/techniques can be used for handling
such scenarios. For for sake of our topic on Priority Inversion, let us mention a synchronization method say
mutex. Just to recap on mutex, a task acquires mutex before entering critical section (CS) and releases
mutex after exiting critical section (CS). While running in CS, a task access this common resource. More
details on this can be referred here. Now, say both L and H shares a common Critical Section (CS) i.e. same
mutex is needed for this CS.
Coming to our discussion of priority inversion, let us examine some scenarios.

1) L is running but not in CS ; H needs to run; H preempts L ; H starts running ; H relinquishes or releases
control ; L resumes and starts running
2) L is running in CS ; H needs to run but not in CS; H preempts L ; H starts running ; H relinquishes
control ; L resumes and starts running.
3) L is running in CS ; H also needs to run in CS ; H waits for L to come out of CS ; L comes out of CS ; H
enters CS and starts running
Please note that the above scenarios don’t show the problem of any Priority Inversion (not even scenario 3).
Basically, so long as lower priority task isn’t running in shared CS, higher priority task can preempt it. But if
L is running in shared CS and H also needs to run in CS, H waits until L comes out of CS. The idea is that CS
should be small enough so that it doesn’t result in H waiting for long time while L was in CS. That’s why
writing CS code requires careful consideration. In any of the above scenarios, priority inversion (i.e. reversal
of priority) didn’t occur because the tasks are running as per the design.
Now let us add another task of middle priority say M. Now the task priorities are in the order of L < M < H.
In our example, M doesn’t share the same Critical Section (CS). In this case, the following sequence of task
running would result in ‘Priority Inversion’ problem.
4) L is running in CS ; H also needs to run in CS ; H waits for L to come out of CS ; M interrupts L and starts
running ; M runs till completion and relinquishes control ; L resumes and starts running till the end of CS ;
H enters CS and starts running.
Note that neither L nor H share CS with M.
Here, we can see that running of M has delayed the running of both L and H. Precisely speaking, H is of
higher priority and doesn’t share CS with M; but H had to wait for M. This is where Priority based
scheduling didn’t work as expected because priorities of M and H got inverted in spite of not sharing any CS.
This problem is called Priority Inversion. This is what the heck was Priority Inversion ! In a system with
priority based scheduling, higher priority tasks can face this problem and it can result in unexpected
behavior/result. In general purpose OS, it can result in slower performance. In RTOS, it can result in more
severe outcomes. The most famous ‘Priority Inversion’ problem was what happened at Mars Pathfinder.
If we have a problem, there has to be solution for this. For Priority Inversion as well, there’re different
solutions such as Priority Inheritance etc. This is going to be our next article
discussed above
Maximum weight transformation of a given string
Given a string consisting of only A’s and B’s. We can transform the given string to another string by toggling
any character. Thus many transformations of the given string are possible. The task is to find Weight of the
maximum weight transformation.
Weight of a sting is calculated using below formula.
Weight of string = Weight of total pairs +

weight of single characters -
Total number of toggles.
Two consecutive characters are considered as pair only if they

are different.
Weight of a single pair (both character are different) = 4
Weight of a single character = 1

Examples:
Input: str = "AA"

Output: 3
Transformations of given string are "AA", "AB" and "BA".
Maximum weight transformation is "AB" or "BA". And weight
is "One Pair - One Toggle" = 4-1 = 3.
Input: str = "ABB"

Output: 5
Transformations are "ABB", "ABA", "AAB", "AAA", "BBB",
"BBA", "BAB" and "BAA"
Maximum weight is of original string 4+1 (One Pair + 1
character)

We can recursively find maximum weight using below formula.

If (n == 1)
maxWeight(str[0..n-1]) = 1
Else If str[0] != str[1]

// Max of two cases: First character considered separately
// First pair considered separately
maxWeight(str[0..n-1]) = Max (1 + maxWeight(str[1..n-1]),
4 + getMaxRec(str[2..n-1])
Else
// Max of two cases: First character considered separately
// First pair considered separately
// Since first two characters are same and a toggle is
// required to form a pair, 3 is added for pair instead
// of 4
maxWeight(str[0..n-1]) = Max (1 + maxWeight(str[1..n-1]),
3 + getMaxRec(str[2..n-1])

If we draw the complete recursion tree, we can observer that many subproblems are solved again and again.
sum problem has both properties (see this and this) of a dynamic programming problem. Like other typical
Dynamic Programming(DP) problems.
Below is a memoization based solution. A lookup table is used to see if a problem is already computed.

// C++ program to find maximum weight transformation

// of a given string
// Returns wieght of the maximum weight

// transformation
int getMaxRec(string &str, int i, int n, int lookup[])
{
// Base case
if (i >= n) return 0;
//If this subproblem is already solved

if (lookup[i] != -1) return lookup[i];
// Don't make pair, so weight gained is 1

int ans = 1 + getMaxRec(str, i+1, n, lookup);
// If we can make pair

if (i+1 < n)
{
// If elements are dissmilar, weight gained is 4
if (str[i] != str[i+1])
ans = max(4 + getMaxRec(str, i+2, n, lookup),
ans);
// if elements are similar so for making a pair

// we toggle any of them. Since toggle cost is
// 1 so overall weight gain becomes 3
else ans = max(3 + getMaxRec(str, i+2, n, lookup),
ans);
}
// save and return maximum of above cases

return lookup[i] = ans;
}
// Initializes lookup table and calls getMaxRec()

int getMaxWeight(string str)
{
// Create and initialize lookup table

int lookup[n];
// Call recursive function

return getMaxRec(str, 0, str.length(), lookup);
}
// Driver program
int main()
{
string str = "AAAAABB";
cout << "Maximum weight of a transformation of "
<< str << " is " << getMaxWeight(str);
return 0;
}

Output:
Maximum weight of a transformation of AAAAABB is 11

discussed above
SAP Labs Interview Experience | Set 11 (On-Campus)
1. Written round
The online test was comprised of 107 MCQ questions including 2 programming codes to be done in 90
minutes
Platform: Mettl
There were 6 sections-
1. Psychometric test – 60 questions in 10 mins
2. Logical reasoning + Data interpretation – 10 questions
3. Technical questions(C, C++, DBMS, OS, CN) – 15 questions
4. Analytical + quantitative – 10 questions
5. Verbal aptitude – 10 questions

and finally 2 coding questions one for 20 marks and one for 40 marks.
Solving at least one of them is essential for getting shortlisted.

It sounds like a lot but actually it’s not.
Give stress on codes, they have more weightage.

Do practice following coding questions which were asked last year-
1. C Program to reverse each word of a sentence with starting letter to be in CAPS

Input : my nAMe is john.
Output : Ym Eman Si Nhoj.
2. http://www.careercup.com/page?pid=sap-labs-interview-questions
your task is- for a given number recognize if it is bleak or supported by some number.
You need to only make function in both coding questions and run it against test cases.
Format would be like this-
#include
#include
//Assume following return types while writing the code for this question.
char* output1[100];
void bleakNumbers(int input1[])
{
//Write code here
}

3. http://stackoverflow.com/questions/19343509/number-of-possible-ways-of-assigning-free-plots-to-
buildings-with-the-restrictio
4. Find GCD of given 2 numbers.
TIPS
-Before appearing in actual SAP’s written test, explore Mettle and give sample test onit.
-While writing test, don’t think about googling because in case you try to go away from current tab, it will
generate a red screen with a warning so Avoid clicking here and there.
-Give first priority to coding and give at least half an hour to programming.
-As soon as you see 1 hour remaining, attempt the MCQs.
#Around 850 students appeared in this round and 62 made it to the next one. (28 in R&D and 34 in
consulting)
Personal Interview Day –
2. Design Thinking
-From here they divided students in 2 groups according to role.

-I was selected in R&D so here is my experience
-We had design thinking round to check our innovative skills instead of usual GD.
‘Swachh Bharat Abhiyan’ was the topic in this round. We had to take interview of a customer (in our case,
one
of the SAP interviewer himself), understand his needs and further design an application.
-After taking interview we were given 30 mins to design 3 screens of our app on paper.
-Then everyone was called for short PI in which we had to explain our design.
TIPS
-Prepare questionnaire very well before taking interview.

-Don’t just ask interviewee but suggest your points too.
-Try to include as many valid features you can in your app.
-Presentation was also an important part, so work on your presentation skills.
-Keep PI interactive and ask if they have any questions at the end.
#15 Out of 28 were selected for the next round in R&D
Technical Interview 1
Interviewer started with common questions like:
1. Tell me something that is not on your resume
2. Projects- describe technical specifications.

Then he jumped on some basic conceptual questions:
3. What is a class and object in C++.Explain by taking an example.
4. What is method overloading? Give example
5. How is Encapsulation implemented? Give example? Write code
6. DBMS – Queries, normalization, ACID properties, joins, some question on data redundancy and
inconsistency
7. Data structure and why do we use them. Give real life example of stack and queue.
8. I have an array of numbers from 1 to 100 (both inclusive). The size of the array is 100.The numbers are
randomly added to the array, but there is one random empty slot in the array.What is the quickest way to
find that slot as well as the number that should be put in the slot?
He asked to write code and further optimize it and give one line solution. Try it, it’s easy!!
9. In the end he asked a simple puzzle to count number of squares of same size and derive a formula.
It went for 45 mins and since we had a long talk on complexity so he asked me to give my time complexity
I answered O(1) ��
Before he could ask or say something i said because these 45 mins are nothing compared to time i would be
devoting to SAP in future.
While leaving the room i asked for review and he said you are selected.
4. Technical Interview 2
In this round they were giving some scenario and we had to build and describe it.
The interviewer gave me a scene similar to what we do on flipkart.
Case 1:
A user logs into flipkart and selects products and adds it in his cart’ he can further modify his cart and then
finally make the payment.Now make class diagram, code with reference to user and administrator.
I made class diagram and some code but i was not sure about it as i had never implemented such system so i
asked him to change the scenario
Here he could have asked me to leave but he changed the scenario and gave me this one
Case 2:
There is company named abc and it is working on some old software. Sales guys of this company has to go
and first sell things and then come back to update the changes done in the whole day now this company is
thinking of including a mobile app through which sales person can update the data instantly being at
customer location. Tell me how it can be done and what technology we can use.
I had some idea about this and answered every question asked to me.
In the end he gave me a simple puzzle.

You have 3 baskets, one with apples, one with oranges and one with both apples and oranges mixed.Each
basket is closed and is labeled with ‘Apples’, ‘Oranges’ and ‘Apples and Oranges’.However, each of these
labels is always placed incorrectly.How would you pick only one fruit from a basket to place the labels
correctly on all the baskets?
I already knew the answer but i took some time and then answered him.
TIPS :
Be specific and tell the truth Don’t rush in giving answers, take your time, think and then give your answer.If
u don’t know something just let him know clearly.
5. Managerial
Basically they check your interpersonal and communicational skills here.

My managerial round went on for about an hour.
1. Tell me about yourself, your family, schooling, role model.
2. Why sap.
3. What is cloud? Private, public, hybrid.
4. Sap is focusing on becoming cloud player? What’s your take on that.
5. Simple case study on cloud computing.
6. What innovations you have done so far.
7. I am giving you 5 minutes…present me an innovative solution and sell it to me.
8. Latest gadgets, technology.
9. Future plans.
6. HR
1. Why SAP? i talked about it for 20 mins ��

2. Strengths and weaknesses. Have you ever tried to make your weakness as strength? If yes, how?
3. Are u a team player? Give instances
4. If you are leading a team and there are multiple suggestion how will u finalize the solution to a certain
problem?
5. General talks about family, environment, college life, projects, and friends
TIPS :
Be calm and true.

Prepare well for interview.
Your ‘why SAP’ should be very clear in mind.
They don’t need hard core coders but ones having strong logical reasoning.
Last but not the least, google about SAP before appearing.
Geeks.
Bitmasking and Dynamic Programming | Set 1 (Count ways to assign
unique cap to every person)
Consider the below problems statement.
There 100 different types of caps each having a unique id from 1 to 100. Also, there ‘n’ persons each having a
collection of variable number of caps. One day all of these persons decide to go in a party wearing a cap but
to look unique they decided that none them will wear the same type of cap. So, count the total number of
arrangements or ways such that none of them is wearing same type of cap.
Constraints: 1 First line contains value of n, next n lines contain collections of all the n persons. Input: 3 5
100 1 // Collection of first person. 2 // Collection of second person. 5 100 // Collection of second person.
Output: 4 Explanation: All valid possible ways are (5, 2, 100), (100, 2, 5), (1, 2, 5) and (1, 2, 100)
Since, number of ways could be large, so output modulo 1000000007
A Simple Solution is to try all possible combinations. Start by picking first element from first set, marking
it as visited and recur for remaining sets. It is basically a Backtracking based solution.
A better solution is to use Bitmasking and DP. Let us first introduce Bitmasking.
What is Bitmasking?
Suppose we have a collection of elements which are numbered from 1 to N. If we want to represent a subset
of this set than it can be encoded by a sequence of N bits (we usually call this sequence a “mask”). In our
chosen subset the i-th element belongs to it if and only if the i-th bit of the mask I set i.e., it equals to 1. For
example, the mask 10000101 means that the subset of the set [1… 8] consists of elements 1, 3 and 8. We
know that for a set of N elements there are total 2 N subsets thus 2N masks are possible, one representing
each subset. Each mask is in fact an integer number written in binary notation.
Our main methodology is to assign a value to each mask (and, therefore, to each subset) and thus calculate
the values for new masks using values of the already computed masks. Usually our main target is to calculate
value/solution for the complete set i.e., for mask 11111111. Normally, to find the value for a subset X we
remove an element in every possible way and use values for obtained subsets X’1, X’2… ,X’k to compute the
value/solution for X. This means that the values for X’i must have been computed already, so we need to
establish an ordering in which masks will be considered. It’s easy to see that the natural ordering will do: go
over masks in increasing order of corresponding numbers. Also, We sometimes, start with the empty subset
X and we add elements in every possible way and use the values of obtained subsets X’1, X’2… ,X’k to
compute the value/solution for X.
We mostly use the following notations/operations on masks:

bit(i,mask) – the i-th bit of mask
count(mask) – the number of non-zero bits in mask
first(mask) – the number of the lowest non-zero bit in mask
set(i, mask) – set the ith bit in mask
check(i, mask) – check the ith bit in mask
How is this problem solved using Bitmasking + DP?

The idea is to use the fact that there are upto 10 persons. So we can use a integer variable as a bitmask to
store which person is wearing cap and which is not.
Let i be the current cap number (caps from 1 to i-1 are already
processed). Let integer variable mask indicates the the persons w
earing and not wearing caps. If i'th bit is set in mask, then
i'th person is wearing a cap, else not.
i'th person is wearing a cap, else not.
// consider the case when ith cap is not included

// in the arrangement
countWays(mask, i) = countWays(mask, i+1) +

// when ith cap is included in the arrangement
// so, assign this cap to all possible persons
// one by one and recur for remaining persons.
&Sum; countWays(mask | (1
If we draw the complete recursion tree, we can observer that many subproblems are solved
again and again. So we use Dynamic Programming. A table dp[][] is used such that in ev
ery entry dp[i][j], i is mask and j is cap number.
Since we want to access all persons that can wear a given cap, we use an array of vector
s, capList[101]. A value capList[i] indicates the list of persons that can wear cap i.

// C++ program to find number of ways to wear hats
#define MOD 1000000007
// capList[i]'th vector contains the list of persons having a cap with id i

// id is between 1 to 100 so we declared an array of 101 vectors as indexing
// starts from 0.
vector<int> capList[101];
// dp[2^10][101] .. in dp[i][j], i denotes the mask i.e., it tells that

// how many and which persons are wearing cap. j denotes the first j caps
// used. So, dp[i][j] tells the number ways we assign j caps to mask i
// such that none of them wears the same cap
int dp[1025][101];
// This is used for base case, it has all the N bits set
// so, it tells whether all N persons are wearing a cap.
int allmask;
// Mask is the set of persons, i is the number of

// caps processed starting from first cap.
long long int countWaysUtil(int mask, int i)
{
// If all persons are wearing a cap so we
// are done and this is one way so return 1
if (mask == allmask) return 1;
// If not everyone is wearing a cap and also there are no more

// caps left to process, so there is no way, thus return 0;
if (i > 100) return 0;
// If we already have solved this subproblem, return the answer.

if (dp[mask][i] != -1) return dp[mask][i];
// Ways, when we don't include this cap in our arrangement

// or solution set.
long long int ways = countWaysUtil(mask, i+1);
// size is the total number of persons having cap with id i.

int size = capList[i].size();
// So, assign one by one ith cap to all the possible persons
// So, assign one by one ith cap to all the possible persons
// and recur for remaining caps.
for (int j = 0; j < size; j++)
{
// if person capList[i][j] is already wearing a cap so continue as
// we cannot assign him this cap
if (mask & (1 << capList[i][j])) continue;
// Else assign him this cap and recur for remaining caps with
// new updated mask vector
else ways += countWaysUtil(mask | (1 << capList[i][j]), i+1);
ways %= MOD;
}
// Save the result and return it.

return dp[mask][i] = ways;
}
// Reads n lines from standard input for current test case

void countWays(int n)
{
//----------- READ INPUT --------------------------
string temp, str;
int x;
getline(cin, str); // to get rid of newline character
{
getline(cin, str);
stringstream ss(str);
// while there are words in the streamobject ss

while (ss >> temp)
{
stringstream s;
s << temp;
s >> x;
// add the ith person in the list of cap if with id x

capList[x].push_back(i);
}
}
//----------------------------------------------------
// All mask is used to check of all persons

// are included or not, set all n bits as 1
allmask = (1 << n) - 1;
// Initialize all entries in dp as -1

// Call recursive function count ways

cout << countWaysUtil(0, 1) << endl;
}
// Driver Program
int main()
{
int n; // number of persons in every test case
cin >> n;
countWays(n);
return 0;
}

Input:

3
5 100 1
2
5 100
Output:
This article is contributed by Gaurav Ahirwar. Please write comments if you find anythin
g incorrect, or you want to share more information about the topic discussed above

Given an array of pairs, find all symmetric pairs in it
Two pairs (a, b) and (c, d) are said to be symmetric if c is equal to b and a is equal to d. For example (10, 20)
and (20, 10) are symmetric. Given an array of pairs find all symmetric pairs in it.
It may be assumed that first elements of all pairs are distinct.
Example:
Input: arr[] = {{10, 20}, {30, 40}, {5, 10}, {40, 30}, {10, 5}}
Output: Following pairs have symmetric pairs
(30, 40)
(5, 10)

A Simple Solution is to go through every pair, and check every other pair for symmetric. This solution
requires O(n2) time.
A Better Solution is to use sorting. Sort all pairs by first element. For every pair, do binary search for
second element in the given array, i.e., check if second element of this pair exists as first element in array. If
found, then compare first element of pair with second element. Time Complexity of this solution is
O(nLogn).
An Efficient Solution is to use Hashing. First element of pair is used as key and second element is used as
value. The idea is traverse all pairs one by one. For every pair, check if its second element is in hash table. If
yes, then compare the first element with value of matched entry of hash table. If the value and the first
element match, then we found symmetric pairs. Else, insert first element as key and second element as
value.
Following is Java implementation of this idea.

// A Java program to find all symmetric pairs in a given array of pairs


class SymmetricPairs {

// Print all pairs that have a symmetric counterpart
static void findSymPairs(int arr[][])
{

{
// First and second elements of current pair
int first = arr[i][0];
int sec = arr[i][1];

// Look for second element of this pair in hash
Integer val = hM.get(sec);

// If found and value in hash matches with first
// element of this pair, we found symmetry
if (val != null && val == first)
System.out.println("(" + sec + ", " + first + ")");

else // Else put sec element of this pair in hash
hM.put(first, sec);
}
}

// Drive method
{
int arr[][] = new int[5][2];
arr[0][0] = 10; arr[0][1] = 20;
arr[1][0] = 30; arr[1][1] = 40;
arr[2][0] = 5; arr[2][1] = 10;
arr[3][0] = 40; arr[3][1] = 30;
arr[4][0] = 10; arr[4][1] = 5;
findSymPairs(arr);
}
}

Output:

Following pairs have symmetric pairs
(30, 40)
(5, 10)

Time Complexity of this solution is O(n) under the assumption that hash search and insert methods work in
O(1) time.
Find maximum value of Sum( i*arr[i]) with only rotations on given array
allowed
Given an array, only rotation operation is allowed on array. We can rotate the array as many times as we
want. Return the maximum possbile of summation of i*arr[i].
Example:
Input: arr[] = {1, 20, 2, 10}

Output: 72
We can 72 by rotating array twice.
{2, 10, 1, 20}
20*3 + 1*2 + 10*1 + 2*0 = 72
Input: arr[] = {10, 1, 2, 3, 4, 5, 6, 7, 8, 9};

Output: 330
We can 330 by rotating array 9 times.
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
0*1 + 1*2 + 2*3 ... 9*10 = 330

A Simple Solution is to find all rotations one by one, check sum of every rotation and return the maximum
sum. Time complexity of this solution is O(n2).
We can solve this problem in O(n) time using an Efficient Solution.

Let Rj be value of i*arr[i] with j rotations. The idea is to calculate next rotation value from previous rotation,
i.e., calculate Rj from Rj-1. We can calculate initial value of result as R0, then keep calculating next rotation
values.
How to efficiently calculate R j from R j-1?

This can be done in O(1) time. Below are details.
Let us calculate initial value of i*arr[i] with no rotation

R0 = 0*arr[0] + 1*arr[1] +...+ (n-1)*arr[n-1]
After 1 rotation arr[n-1], becomes first element of array,

arr[0] becomes second element, arr[1] becomes third element
and so on.
R1 = 0*arr[n-1] + 1*arr[0] +...+ (n-1)*arr[n-2]
R1 - R0 = arr[0] + arr[1] + ... + arr[n-2] - (n-1)*arr[n-1]
After 2 rotations arr[n-2], becomes first element of array,

arr[n-1] becomes second element, arr[0] becomes third element
and so on.
R2 = 0*arr[n-2] + 1*arr[n-1] +...+ (n?1)*arr[n-3]
R2 - R1 = arr[0] + arr[1] + ... + arr[n-3] - (n-1)*arr[n-2] + arr[n-1]
If we take a closer look at above values, we can observe

below pattern
Rj - Rj-1 = arrSum - n * arr[n-j]
Where arrSum is sum of all array elements, i.e.,

Where arrSum is sum of all array elements, i.e.,
arrSum = &Sum; arr[i]

i
Below is complete algorithm:

1) Compute sum of all array elements. Let this sum be 'arrSum'.
2) Compute R0 by doing i*arr[i] for given array.

Let this value be currVal.
3) Initialize result: maxVal = currVal // maxVal is result.
// This loop computes Rj from Rj-1

4) Do following for j = 1 to n-1
......a) currVal = currVal + arrSum-n*arr[n-j];
......b) If (currVal > maxVal)
maxVal = currVal
5) Return maxVal

// C++ program to find max value of i*arr[i]
#include <iostream>
// Returns max possible value of i*arr[i]

int maxSum(int arr[], int n)
{
// Find array sum and i*arr[i] with no rotation
int arrSum = 0; // Stores sum of arr[i]
int currVal = 0; // Stores sum of i*arr[i]
{
arrSum = arrSum + arr[i];
currVal = currVal+(i*arr[i]);
}
// Initialize result as 0 rotation sum

int maxVal = currVal;
// Try all rotations one by one and find

// the maximum rotation sum.
{
currVal = currVal + arrSum-n*arr[n-j];
if (currVal > maxVal)
maxVal = currVal;
}
// Return result
return maxVal;
}
// Driver program
int main(void)
{
int arr[] = {10, 1, 2, 3, 4, 5, 6, 7, 8, 9};
cout << "\nMax sum is " << maxSum(arr, n);
return 0;
}

Output:

Max sum is 330
This article is contributed by Nitesh Singh. Please write comments if you find anything

Lazy Propagation in Segment Tree
Segment tree is introduced in previous post with an example of range sum problem. We have used the same
“Sum of given Range” problem to explain Lazy propagation
How does update work in Simple Segment Tree?

In the previous post, update function was called to update only a single value in array. Please note that a
single value update in array may cause multiple updates in Segment Tree as there may be many segment tree
nodes that have a single array element in their ranges.
Below is simple logic used in previous post.

1) Start with root of segment tree.
2) If array index to be updated is not in current node’s range, then return
3) Else update current node and recur for children.
Below is code taken from previous post.

/* A recursive function to update the nodes which have the given

index in their range. The following are parameters
tree[] --> segment tree
si --> index of current node in segment tree.
Initial value is passed as 0.
ss and se --> Starting and ending indexes of array elements
covered under this node of segment tree.
Initial values passed as 0 and n-1.
i --> index of the element to be updated. This index
is in input array.
diff --> Value to be added to all nodes which have array
index i in range */
void updateValueUtil(int tree[], int ss, int se, int i,
int diff, int si)
{
// Base Case: If the input index lies outside the range
// of this segment
if (i < ss || i > se)
return;
// If the input index is in range of this node, then

// update the value of the node and its children
st[si] = st[si] + diff;
if (se != ss)
{
updateValueUtil(st, ss, mid, i, diff, 2*si + 1);
updateValueUtil(st, mid+1, se, i, diff, 2*si + 2);
}
}

What if there are updates on a range of array indexes?

For example add 10 to all values at indexes from 2 to 7 in array. The above update has to be called for every
index from 2 to 7. We can avoid multiple calls by writing a function updateRange() that updates nodes
accordingly.

/* Function to update segment tree for range update in input

array.
si -> index of current node in segment tree
ss and se -> Starting and ending indexes of elements for
which current nodes stores sum.
us and eu -> starting and ending indexes of update query
ue -> ending index of update query
diff -> which we need to add in the range us to ue */
void updateRangeUtil(int si, int ss, int se, int us,
int ue, int diff)
{
// out of range
if (ss>se || ss>ue || se<us)
return ;
// Current node is a leaf node

if (ss==se)
{
// Add the difference to current node
tree[si] += diff;
return;
}
// If not a leaf node, recur for children.

int mid = (ss+se)/2;
updateRangeUtil(si*2+1, ss, mid, us, ue, diff);
updateRangeUtil(si*2+2, mid+1, se, us, ue, diff);
// Use the result of children calls to update this

// node
tree[si] = tree[si*2+1] + tree[si*2+2];
}

What is Lazy Propagation – An optimization to make range updates faster?
When there are many updates and updates are done on a range, we can postpone some updates (avoid
recursive calls in update) and do those updates only when required.
Please remember that a node in segment tree stores or represents result of a query for a range of indexes.
And if this node’s range lies within the update operation range, then all descendants of the node must also be
updated. For example consider the node with value 27 in above diagram, this node stores sum of values at
indexes from 3 to 5. If our update query is for range 2 to 5, then we need to update this node and all
descendants of this node. With Lazy propagation, we update only node with value 27 and postpone updates
to its children by storing this update information in separate nodes called lazy nodes or values. We create an
array lazy[] which represents lazy node. Size of lazy[] is same as array that represents segment tree, which is
tree[] in below code.
The idea is to initialize all elements of lazy[] as 0. A value 0 in lazy[i] indicates that there are no pending
updates on node i in segment tree. A non-zero value of lazy[i] means that this amount needs to be added to
node i in segment tree before making any query to the node.
Below is modified update method.

// To update segment tree for change in array

// values at array indexes from us to ue.
updateRange(us, ue)
1) If current segment tree node has any pending
update, then first add that pending update to
current node.
2) If current node's range lies completely in
update query range.
....a) Update current node
....b) Postpone updates to children by setting
lazy value for children nodes.
3) If current node's range overlaps with update
range, follow the same approach as above simple
update.
...a) Recur for left and right children.
...b) Update current node using results of left
and right calls.

Is there any change in Query Function also?

Since we have changed update to postpone its operations, there may be problems if a query is made to a
node that is yet to be updated. So we need to update our query method also which is getSumUtil in previous
post. The getSumUtil() now first checks if there is a pending update and if there is, then updates the node.
Once it makes sure that pending update is done, it works same as the previous getSumUtil().
Below is C++ program to demonstrate working of Lazy Propagation.
// Program to show segment tree to demonstrate lazy

// propagation
#include <stdio.h>
#include <math.h>
#define MAX 1000
// Ideally, we should not use global variables and large

// constant-sized arrays, we have done it here for simplicity.
int tree[MAX] = {0}; // To store segment tree
int lazy[MAX] = {0}; // To store pending updates
/* si -> index of current node in segment tree

ss and se -> Starting and ending indexes of elements for
which current nodes stores sum.
us and eu -> starting and ending indexes of update query
void updateRangeUtil(int si, int ss, int se, int us,
int ue, int diff)
{
// If lazy value is non-zero for current node of segment
// tree, then there are some pending updates. So we need
// to make sure that the pending updates are done before
// making new updates. Because this value may be used by
// parent after recursive calls (See last line of this
// function)
if (lazy[si] != 0)
{
// Make pending updates using value stored in lazy
// nodes
// nodes
tree[si] += (se-ss+1)*lazy[si];
// checking if it is not leaf node because if

// it is leaf node then we cannot go further
if (us != ue)
{
// We can postpone updating children we don't
// need their new values now.
// Since we are not yet updating children of si,
// we need to set lazy flags for the children
lazy[si*2 + 1] += lazy[si];
lazy[si*2 + 2] += lazy[si];
}
// Set the lazy value for current node as 0 as it

// has been updated
lazy[si] = 0;
}
// out of range
if (ss>se || ss>ue || se<us)
return ;
// Current segment is fully in range

if (ss>=us && se<=ue)
{
// Add the difference to current node
tree[si] += (se-ss+1)*diff;
// same logic for checking leaf node or not

if (ss != se)
{
// This is where we store values in lazy nodes,
// rather than updating the segment tree itelf
// Since we don't need these updated values now
// we postpone updates by storing values in lazy[]
lazy[si*2 + 1] += diff;
lazy[si*2 + 2] += diff;
}
return;
}
// If not completely in rang, but overlaps, recur for

// children,
int mid = (ss+se)/2;
updateRangeUtil(si*2+1, ss, mid, us, ue, diff);
updateRangeUtil(si*2+2, mid+1, se, us, ue, diff);
// And use the result of children calls to update this

// node
tree[si] = tree[si*2+1] + tree[si*2+2];
}
// Function to update a range of values in segment

// tree
/* us and eu -> starting and ending indexes of update query
void updateRange(int n, int us, int ue, int diff)
{
updateRangeUtil(0, 0, n-1, us, ue, diff);
}
/* A recursive function to get the sum of values in given
range of the array. The following are parameters for
this function.
si --> Index of current node in the segment tree.
Initially 0 is passed as root is always at'
index 0
ss & se --> Starting and ending indexes of the
segment represented by current node,
i.e., tree[si]
qs & qe --> Starting and ending indexes of query
range */
int getSumUtil(int ss, int se, int qs, int qe, int si)
{
// If lazy flag is set for current node of segment tree,
// then there are some pending updates. So we need to
// make sure that the pending updates are done before
// processing the sub sum query
if (lazy[si] != 0)
{
// Make pending updates to this node. Note that this
// node represents sum of elements in arr[ss..se] and
// all these elements must be increased by lazy[si]
tree[si] += (se-ss+1)*lazy[si];
// checking if it is not leaf node because if

// it is leaf node then we cannot go further
if (qs != qe)
{
// Since we are not yet updating children os si,
// we need to set lazy values for the children
lazy[si*2+1] += lazy[si];
lazy[si*2+2] += lazy[si];
}
// unset the lazy value for current node as it has

// been updated
lazy[si] = 0;
}
// Out of range
if (ss>se || ss>qe || se<qs)
return 0;
// At this point sure, pending lazy updates are done

// for current node. So we can return value (same as
// was for query in our previous post)
// If this segment lies in range

if (ss>=qs && se<=qe)
return tree[si];
// If a part of this segment overlaps with the given

// range
int mid = (ss + se)/2;
return getSumUtil(ss, mid, qs, qe, 2*si+1) +
getSumUtil(mid+1, se, qs, qe, 2*si+2);
}
// Return sum of elements in range from index qs (quey

// start) to qe (query end). It mainly uses getSumUtil()
int getSum(int n, int qs, int qe)
{
if (qs < 0 || qe > n-1 || qs > qe)
if (qs < 0 || qe > n-1 || qs > qe)
{
return -1;
}
return getSumUtil(0, n-1, qs, qe, 0);

}
// A recursive function that constructs Segment Tree for

// array[ss..se]. si is index of current node in segment
// tree st.
void constructSTUtil(int arr[], int ss, int se, int si)
{
// out of range as ss can never be greater than se
if (ss > se)
return ;
// If there is one element in array, store it in

// current node of segment tree and return
if (ss == se)
{
tree[si] = arr[ss];
return;
}
// If there are more than one elements, then recur

// for left and right subtrees and store the sum
// of values in this node
constructSTUtil(arr, ss, mid, si*2+1);
constructSTUtil(arr, mid+1, se, si*2+2);
tree[si] = tree[si*2 + 1] + tree[si*2 + 2];

}
/* Function to construct segment tree from given array.

This function allocates memory for segment tree and
calls constructSTUtil() to fill the allocated memory */
void constructST(int arr[], int n)
{
constructSTUtil(arr, 0, n-1, 0);
}

int main()
{
int arr[] = {1, 3, 5, 7, 9, 11};

constructST(arr, n);
// Print sum of values in array from index 1 to 3

printf("Sum of values in given range = %d\n",
getSum(n, 1, 3));
// Add 10 to all nodes at indexes from 1 to 5.

updateRange(n, 1, 5, 10);
// Find sum after the value is updated

printf("Updated sum of values in given range = %d\n",
getSum( n, 1, 3));
getSum( n, 1, 3));
return 0;
}

Output:

Sum of values in given range = 15
Updated sum of values in given range = 45

This article is contributed by Ankit Mittal. Please write comments if you find anything incorrect, or you
Longest Repeating Subsequence
Given a string, find length of the longest repeating subseequence such that the two subsequence don’t have
same string character at same position, i.e., any i’th character in the two subsequences shouldn’t have the
same index in the original string.
Examples:
Input: str = "abc"

Output: 0
There is no repeating subsequence
Input: str = "aab"

Output: 1
The two subssequence are 'a'(first) and 'a'(second).
Note that 'b' cannot be considered as part of subsequence
as it would be at same index in bot.
Input: str = "aabb"

Output: 2
Input: str = "axxxy"

Output: 2

This problem is just the modification of Longest Common Subsequence problem. The idea is to find the
LCS(str, str) where str is the input string with the restriction that when both the characters are same, they
shouldn’t be on the same index in the two strings.

// C++ program to find the longest repeating

// subsequence
#include <iostream>
#include<string>
int findLongestRepeatingSubSeq(string str)

{
// Create and initialize DP table

int dp[n+1][n+1];
dp[i][j] = 0;
// Fill dp table (similar to LCS loops)

{
{
// If characters match and indexes are not same
if (str[i-1] == str[j-1] && i!=j)
dp[i][j] = 1 + dp[i-1][j-1];
// If characters do not match
else
dp[i][j] = max(dp[i][j-1], dp[i-1][j]);
}
}
return dp[n][n];
}
// Driver Program
int main()
{
string str = "aabb";
cout << "The length of the largest subsequence that"
" repeats itself is : "
<< findLongestRepeatingSubSeq(str);
return 0;
}

Output:

The length of the largest subsequence that repeats itself is : 2

Given a string, print all possible palindromic partitions
Given a string, find all possible palindromic partitions of given string.
Example:
Note that this problem is different from Palindrome Partitioning Problem, there the task was to find the
partitioning with minimum cuts in input string. Here we need to print all possible partitions.
The idea is to go through every substring starting from first character, check if it is palindrome. If yes, then
add the substring to solution and recur for remaining part. Below is complete algorithm.
Below is C++ implementation of above idea
// C++ program to print all palindromic partitions of a given string

// A utility function to check if str is palindroem

bool isPalindrome(string str, int low, int high)
{
while (low < high)
{
if (str[low] != str[high])
return false;
low++;
high--;
}
return true;
}
// Recursive function to find all palindromic partitions of str[start..n-1]

// allPart --> A vector of vector of strings. Every vector inside it stores
// a partition
// currPart --> A vector of strings to store current partition
void allPalPartUtil(vector<vector<string> >&allPart, vector<string> &currPart,
int start, int n, string str)
{
// If 'start' has reached len
if (start >= n)
{
allPart.push_back(currPart);
return;
}
// Pick all possible ending points for substrings

for (int i=start; i<n; i++)
{
// If substring str[start..i] is palindrome
if (isPalindrome(str, start, i))
{
{
// Add the substring to result
currPart.push_back(str.substr(start, i-start+1));
// Recur for remaining remaining substring

allPalPartUtil(allPart, currPart, i+1, n, str);

// Remove substring str[start..i] from current
// partition
currPart.pop_back();
}
}
}
// Function to print all possible palindromic partitions of

// str. It mainly creates vectors and calls allPalPartUtil()
void allPalPartitions(string str)
{
// To Store all palindromic partitions

vector<vector<string> > allPart;
// To store current palindromic partition

vector<string> currPart;
// Call recursive function to generate all partiions

// and store in allPart
allPalPartUtil(allPart, currPart, 0, n, str);
// Print all partitions generated by above call

for (int i=0; i< allPart.size(); i++ )
{
for (int j=0; j<allPart[i].size(); j++)
cout << allPart[i][j] << " ";
cout << "\n";
}
}
// Driver program
int main()
{
string str = "nitin";
allPalPartitions(str);
return 0;
}

Output:
n i t i n
n iti n
nitin

Given a string, print all possible palindromic partitions
Given a string, find all possible palindromic partitions of given string.
Example:
Note that this problem is different from Palindrome Partitioning Problem, there the task was to find the
partitioning with minimum cuts in input string. Here we need to print all possible partitions.
The idea is to go through every substring starting from first character, check if it is palindrome. If yes, then
add the substring to solution and recur for remaining part. Below is complete algorithm.
// C++ program to print all palindromic partitions of a given string

// A utility function to check if str is palindroem

bool isPalindrome(string str, int low, int high)
{
while (low < high)
{
if (str[low] != str[high])
return false;
low++;
high--;
}
return true;
}
// Recursive function to find all palindromic partitions of str[start..n-1]

// allPart --> A vector of vector of strings. Every vector inside it stores
// a partition
// currPart --> A vector of strings to store current partition
void allPalPartUtil(vector<vector<string> >&allPart, vector<string> &currPart,
int start, int n, string str)
{
// If 'start' has reached len
if (start >= n)
{
allPart.push_back(currPart);
return;
}
// Pick all possible ending points for substrings

for (int i=start; i<n; i++)
{
// If substring str[start..i] is palindrome
if (isPalindrome(str, start, i))
{
{
// Add the substring to result
currPart.push_back(str.substr(start, i-start+1));
// Recur for remaining remaining substring

allPalPartUtil(allPart, currPart, i+1, n, str);

// Remove substring str[start..i] from current
// partition
currPart.pop_back();
}
}
}
// Function to print all possible palindromic partitions of

// str. It mainly creates vectors and calls allPalPartUtil()
void allPalPartitions(string str)
{
// To Store all palindromic partitions

vector<vector<string> > allPart;
// To store current palindromic partition

vector<string> currPart;
// Call recursive function to generate all partiions

// and store in allPart
allPalPartUtil(allPart, currPart, 0, n, str);
// Print all partitions generated by above call

for (int i=0; i< allPart.size(); i++ )
{
for (int j=0; j<allPart[i].size(); j++)
cout << allPart[i][j] << " ";
cout << "\n";
}
}
// Driver program
int main()
{
string str = "nitin";
allPalPartitions(str);
return 0;
}

Output:
n i t i n
n iti n
nitin

Print a pattern without using any loop
Given a number n, print following pattern without using any loop.
Input: n = 16
Output: 16, 11, 6, 1, -4, 1, 6, 11, 16
Input: n = 10
Output: 10, 5, 0, 5, 10

We basically first reduce 5 one by one until we reach a negative or 0. After we reach 0 or negative, we one
one add 5 until we reach n.
Source: Microsoft Interview Question.
The idea is to use recursion. It is an interesting question to try on your own.
Below is C++ Code. The code uses a flag variable to indicate whether we are moving toward 0 or we are
moving toward back to n.

// C++ program to print pattern that first reduces 5 one

// by one, then adds 5.
#include <iostream>
// Recursive function to print the pattern.

// n indicates input value
// m indicates current value to be printed
// flag indicates whether we need to add 5 or
// subtract 5. Initially flag is true.
void printPattern(int n, int m, bool flag)
{
// Print m.
cout << m << " ";

// If we are moving back toward the n and
// we have reached there, then we are done
if (flag == false && n ==m)
return;

// If we are moving toward 0 or negative.
if (flag)
{
// If m is greater, then 5, recur with true flag
if (m-5 > 0)
printPattern(n, m-5, true);
else // recur with false flag
printPattern(n, m-5, false);
}
else // If flag is false.
printPattern(n, m+5, false);
}
// Driver Program
int main()
{
int n = 16;
printPattern(n, n, true);
return 0;
}

Output:

16, 11, 6, 1, -4, 1, 6, 11, 16

This article is contributed by Gautham. Please write comments if you find anything incorrect, or you want
Count even length binary sequences with same sum of first and second half
bits
Given a number n, find count of all binary sequences of length 2n such that sum of first n bits is same as sum
of last n bits.
Examples:
Input: n = 1
Output: 2
There are 2 sequences of length 2*n, the
sequences are 00 and 11
Input: n = 2
Output: 2
There are 6 sequences of length 2*n, the
sequences are 0101, 0110, 1010, 1001, 0000
and 1111

The idea is to fix first and last bits and then recur for n-1, i.e., remaining 2(n-1) bits. There are following
possibilities when we fix first and last bits.
1) First and last bits are same, remaining n-1 bits on both sides should also have the same sum.
2) First bit is 1 and last bit is 0, sum of remaining n-1 bits on left side should be 1 less than the sum n-1 bits
on right side.
2) First bit is 0 and last bit is 1, sum of remaining n-1 bits on left side should be 1 more than the sum n-1 bits
on right side.
Based on above facts, we get below recurrence formula.
diff is the expected difference between sum of first half digits and last half digits. Initially diff is 0.
// When first and last bits are same

// there are two cases, 00 and 11
count(n, diff) = 2*count(n-1, diff) +

// When first bit is 1 and last bit is 0
count(n-1, diff-1) +
// When first bit is 0 and last bit is 1

count(n-1, diff+1)
What should be base cases?

// When n == 1 (2 bit sequences)
1) If n == 1 and diff == 0, return 2
2) If n == 1 and |diff| == 1, return 1
// We can't cover difference of more than n with 2n bits

3) If |diff| > n, return 0

Below is C++ implementation based of above Naive Recursive Solution.

// A Naive Recursive C++ program to count even

// length binary sequences such that the sum of
// first and second half bits is same
// diff is difference between sums first n bits

// and last n bits respectively
int countSeq(int n, int diff)
{
// We can't cover difference of more
// than n with 2n bits
if (abs(diff) > n)
return 0;
// n == 1, i.e., 2 bit long sequences

if (n == 1 && diff == 0)
return 2;
if (n == 1 && abs(diff) == 1)
return 1;
int res = // First bit is 0 & last bit is 1

countSeq(n-1, diff+1) +
// First and last bits are same

2*countSeq(n-1, diff) +
// First bit is 1 & last bit is 0

countSeq(n-1, diff-1);
return res;
}
// Driver program
int main()
{
int n = 2;
cout << "Count of sequences is "
<< countSeq(2, 0);
return 0;
}

Output

Count of sequences is 6

observer that many subproblems are solved again and again. For example, when we start from n = 4 and diff
= 0, we can reach (3, 0) through multiple paths. Since same suproblems are called again, this problem has
Overlapping Subprolems property. So min square sum problem has both properties (see this and this) of a
Dynamic Programming problem.
Below is a memoization based solution that uses a lookup table to compute the result.

// A memoization based C++ program to count even
// length binary sequences such that the sum of
// first and second half bits is same
#define MAX 1000
// A lookup table to store the results of subproblems

int lookup[MAX][MAX];
// diff is difference between sums of first n bits

// and last n bits i.e., diff = (Sum of first n bits) -
// (Sum of last n bits)
int countSeqUtil(int n, int diff)
{
// We can't cover difference of more
// than n with 2n bits
if (abs(diff) > n)
return 0;
// n == 1, i.e., 2 bit long sequences

if (n == 1 && diff == 0)
return 2;
if (n == 1 && abs(diff) == 1)
return 1;
// Check if this subbproblem is already solved

if (lookup[n]1 != -1)
return lookup[n]1;
int res = // First bit is 0 & last bit is 1

countSeqUtil(n-1, diff+1) +
// First and last bits are same

2*countSeqUtil(n-1, diff) +
// First bit is 1 & last bit is 0

countSeqUtil(n-1, diff-1);
// Store result in lookup table and return the result

return lookup[n]1 = res;
}
// A Wrapper over countSeqUtil(). It mainly initializes lookup

// table, then calls countSeqUtil()
int countSeq(int n)
{
// Initialize all entries of lookup table as not filled
memset(lookup, -1, sizeof(lookup));
// call countSeqUtil()
return countSeqUtil(n, 0);
}
// Driver program
int main()
{
int n = 2;
cout << "Count of sequences is "
<< countSeq(2);
return 0;
}

Output

Count of sequences is 6

Worst case time complexity of this solution is O(n2) as diff can be maximum n.
This article is contributed by Pawan. Please write comments if you find anything incorrect, or you want to
Given a Boolean Matrix, find k such that all elements in k’th row are 0 and
k’th column are 1.
Given a square boolean matrix mat[n][n], find k such that all elements in k’th row are 0 and all elements in
k’th column are 1. The value of mat[k][k] can be anything (either 0 or 1). If no such k exists, return -1.
Examples:
Input: bool mat[n][n] = { {1, 0, 0, 0},

{1, 1, 1, 0},
{1, 1, 0, 0},
{1, 1, 1, 0},
};
Output: 0
All elements in 0'th row are 0 and all elements in
0'th column are 1. mat[0][0] is 1 (can be any value)
Input: bool mat[n][n] = {{0, 1, 1, 0, 1},

{0, 0, 0, 0, 0},
{1, 1, 1, 0, 0},
{1, 1, 1, 1, 0},
{1, 1, 1, 1, 1}};
Output: 1
All elements in 1'st row are 0 and all elements in
1'st column are 1. mat[1][1] is 0 (can be any value)
Input: bool mat[n][n] = {{0, 1, 1, 0, 1},

{0, 0, 0, 0, 0},
{1, 1, 1, 0, 0},
{1, 0, 1, 1, 0},
{1, 1, 1, 1, 1}};
Output: -1
There is no k such that k'th row elements are 0 and
k'th column elements are 1.

Expected time complexity is O(n)
A Simple Solution is check all rows one by one. If we find a row ‘i’ such that all elements of this row are 0
except mat[i][i] which may be either 0 or 1, then we check all values in column ‘i’. If all values are 1 in the
column, then we return i. Time complexity of this solution is O(n 2).
An Efficient Solution can solve this problem in O(n) time. The solution is based on below facts.
1) There can be at most one k that can be qualified to be an answer (Why? Note that if k’th row has all 0’s
probably except mat[k][k], then no column can have all 1′)s.
2) If we traverse the given matrix from a corner (preferably from top right and bottom left), we can quickly
discard complete row or complete column based on below rules.
….a) If mat[i][j] is 0 and i != j, then column j cannot be the solution.
….b) If mat[i][j] is 1 and i != j, then row i cannot be the solution.
Below is complete algorithm based on above observations.

1) Start from top right corner, i.e., i = 0, j = n-1.

Initialize result as -1.
2) Do following until we find the result or reach outside the matrix.
......a) If mat[i][j] is 0, then check all elements on left of j in current row.

.........If all elements on left of j are also 0, then set result as i. Note
.........that i may not be result, but if there is a result, then it must be i
.........(Why? we reach mat[i][j] after discarding all rows above it and all
.........columns on right of it)
.........If all left side elements of i'th row are not 0, them this row cannot
.........be a solution, increment i.
......b) If mat[i][j] is 1, then check all elements below i in current column.

.........If all elements below i are 1, then set result as j. Note that j may
......... not be result, but if there is a result, then it must be j
.........If all elements of j'th column are not 0, them this row cannot be a,
.........solution increment i.
3) If result is -1, return it.
4) Else check validity of result by checking all row and column

elements of result

Below is C++ implementation based on above idea.
// C++ program to find i such that all entries in i'th row are 0
// and all entries in i't column are 1
#include <iostream>
#define n 5
int find(bool arr[n][n])

{
// Start from top-most rightmost corner
// (We could start from other corners also)
int i=0, j=n-1;
int res = -1;
// Find the index (This loop runs at most 2n times, we either

// increment row number or decrement column number)
while (i<n && j>=0)
{
// If current element is 0, then this row may be a solution
if (arr[i][j] == 0)
{
// Check for all elements in this row
while (j >= 0 && (arr[i][j] == 0 || i == j))
j--;
// If all values are 0, then store this row as result

if (j == -1)
{
{
res = i;
break;
}
// We reach here if we found a 1 in current row, so this

// row cannot be a solution, increment row number
else i++;
}
else // If current element is 1
{
// Check for all elements in this column
while (i<n && (arr[i][j] == 1 || i == j))
i++;
// If all elements are 1

if (i == n)
{
res = j;
break;
}
// We reach here if we found a 0 in current column, so this

// column cannot be a solution, increment column number
else j--;
}
}
// If we could not find result in above loop, then result doesn't exist
if (res == -1)
return res;
// Check if above computed res is valid

if (res != i && arr[i][res] != 1)
return -1;
if (res != j && arr[res][j] != 0)
return -1;
return res;
}

int main()
{
bool mat[n][n] = {{0, 0, 1, 1, 0},
{0, 0, 0, 1, 0},
{1, 1, 1, 1, 0},
{0, 0, 0, 0, 0},
{1, 1, 1, 1, 1}};
cout << find(mat);
return 0;
}

Output:

3

Time complexity of this solution is O(n). Note that we traverse at most 2n elements in the main while loop.
This article is contributed by Ashish Gupta. Please write comments if you find anything incorrect, or you
Print all non-increasing sequences of sum equal to a given number x
Given a number x, print all possible non-increasing sequences with sum equals to x.
Examples:
Input: x = 3
Output: 1 1 1
2 1
3
Input: x = 4
Output: 1 1 1 1
2 1 1
2 2
3 1
4

The idea is to use a recursive function, an array arr[] to store all sequences one by one and an index variable
curr_idx to store current next index in arr[]. Below is algorithm.
1) If current sum is equal to x, then print current sequence.

2) Place all possible numbers from 1 to x-curr_sum numbers at curr_idx in array. Here curr_sum is sum of
current elements in arr[]. After placing a number, recur for curr_sum + number and curr_idx+1,
Below is C++ implementation of above steps.

// C++ program to generate all non-increasing sequences

// of sum equals to x
// Utility function to print array arr[0..n-1]

{
cout << arr[i] << " ";
cout << endl;
}
// Recursive Function to generate all non-increasing sequences

// with sum x
// arr[] --> Elements of current sequence
// curr_sum --> Current Sum
// curr_idx --> Current index in arr[]
void generateUtil(int x, int arr[], int curr_sum, int curr_idx)
{
// If current sum is equal to x, then we found a sequence
if (curr_sum == x)
{
printArr(arr, curr_idx);
return;
}
// Try placing all numbers from 1 to x-curr_sum at current index

int num = 1;
// The placed number must also be smaller than previously placed

// numbers, i.e., arr[curr_idx-1] if there exists a pevious number
while (num<=x-curr_sum && (curr_idx==0 || num<=arr[curr_idx-1]))
{
// Place number at curr_idx
arr[curr_idx] = num;
// Recur
generateUtil(x, arr, curr_sum+num, curr_idx+1);
// Try next number

num++;
}
}
// A wrapper over generateUtil()

void generate(int x)
{
int arr[x]; // Array to store sequences on by one
generateUtil(x, arr, 0, 0);
}
// Driver program
int main()
{
int x = 5;
generate(x);
return 0;
}

Output:

1 1 1 1 1
2 1 1 1
2 2 1
3 1 1
3 2
4 1
5

Check if two given strings are isomorphic to each other
Two strings str1 and str2 are called isomorphic if there is a one to one mapping possible for every character
of str1 to every character of str2. And all occurrences of every character in ‘str1′ map to same character in
‘str2′
Examples:
Input: str1 = "aab", str2 = "xxy"

Output: True
'a' is mapped to 'x' and 'b' is mapped to 'y'.
Input: str1 = "aab", str2 = "xyz"

Output: False
One occurrence of 'a' in str1 has 'x' in str2 and
other occurrence of 'a' has 'y'.

A Simple Solution is to consider every character of ‘str1′ and check if all occurrences of it map to same
character in ‘str2′. Time complexity of this solution is O(n*n).
An Efficient Solution can solve this problem in O(n) time. The idea is to create an array to store mappings
of processed characters.
1) If lengths of str1 and str2 are not same, return false.

2) Do following for every character in str1 and str2
a) If this character is seen first time in str1,
then current of str2 must have not appeared before.
(i) If current character of str2 is seen, return false.
Mark current character of str2 as visited.
(ii) Store mapping of current characters.
b) Else check if previous occurrence of str1[i] mapped
to same character.

// C++ program to check if two strings are isomorphic

#define MAX_CHARS 256
// This function returns true if str1 and str2 are ismorphic

bool areIsomorphic(string str1, string str2)
{
int m = str1.length(), n = str2.length();
// Length of both strings must be same for one to one

// corresponance
if (m != n)
return false;
return false;
// To mark visited characters in str2

bool marked[MAX_CHARS] = {false};
// To store mapping of every character from str1 to

// that of str2. Initialize all entries of map as -1.
int map[MAX_CHARS];
memset(map, -1, sizeof(map));
// Process all characters one by on

for (int i = 0; i < n; i++)
{
// If current character of str1 is seen first
// time in it.
if (map[str1[i]] == -1)
{
// If current character of str2 is already
// seen, one to one mapping not possible
if (marked[str2[i]] == true)
return false;
// Mark current character of str2 as visited

marked[str2[i]] = true;
// Store mapping of current characters

map[str1[i]] = str2[i];
}
// If this is not first appearance of current

// character in str1, then check if previous
// appearance mapped to same character of str2
else if (map[str1[i]] != str2[i])
return false;
}
return true;
}
// Driver program
int main()
{
cout << areIsomorphic("aab", "xxy") << endl;
cout << areIsomorphic("aab", "xyz") << endl;
return 0;
}

Output:

1
0

Thanks to Gaurav and Utkarsh for suggesting above approach.
discussed above
Rearrange a given linked list in-place.
Given a singly linked list L0 -> L1 -> … -> Ln-1 -> Ln. Rearrange the nodes in the list so that the new formed
list is : L0 -> Ln -> L1 -> Ln-1 -> L2 -> Ln-2 …
You are required do this in-place without altering the nodes’ values.
Examples:
Input: 1 -> 2 -> 3 -> 4
Output: 1 -> 4 -> 2 -> 3
Input: 1 -> 2 -> 3 -> 4 -> 5

Output: 1 -> 5 -> 2 -> 4 -> 3

Simple Solution
1) Initialize current node as head.

2) While next of current node is not null, do following
a) Find the last node, remove it from end and insert it as next
of current node.
b) Move current to next to next of current

Time complexity of the above simple solution is O(n2) where n is number of nodes in linked list.
Efficient Solution:
1) Find the middle point using tortoise and hare method.

2) Split the linked list in two halves using found middle point in step 1.
3) Reverse the second half.
4) Do alternate merge of first and second halves.

Time Complexity of this solution is O(n).
// C++ program to rearrange a linked list in-place

// Linkedlist Node structure

struct Node
{
int data;
struct Node *next;
};
// Function to create newNode in a linkedlist

{
temp->data = key;
temp->next = NULL;
return temp;
}
// Function to reverse the linked list

void reverselist(Node **head)
{
// Initialize prev and current pointers
Node *prev = NULL, *curr = *head, *next;
while (curr)
{
next = curr->next;
curr->next = prev;
prev = curr;
curr = next;
}
*head = prev;
}
// Function to print the linked list

void printlist(Node *head)
{
{
if(head->next) cout << "-> ";
head = head->next;
}
cout << endl;
}
// Function to rearrange a linked list

void rearrange(Node **head)
{
// 1) Find the muddle point using tortoise and hare method
Node *slow = *head, *fast = slow->next;
while (fast && fast->next)
{
slow = slow->next;
fast = fast->next->next;
}
// 2) Split the linked list in two halves

// head1, head of first half 1 -> 2
// head2, head of second half 3 -> 4
Node *head1 = *head;
Node *head2 = slow->next;
slow->next = NULL;
// 3) Reverse the second half, i.e., 4 -> 3

reverselist(&head2);
// 4) Merge alternate nodes

*head = newNode(0); // Assign dummy Node
// curr is the pointer to this dummy Node, which will

// be used to form the new list
Node *curr = *head;
while (head1 || head2)
{
// First add the element from list
if (head1)
{
curr->next = head1;
curr = curr->next;
head1 = head1->next;
}
// Then add the element from second list

if (head2)
{
curr->next = head2;
curr = curr->next;
head2 = head2->next;
}
}
// Assign the head of the new list to head pointer

*head = (*head)->next;
}
// Driver program
int main()
{
Node *head = newNode(1);
head->next = newNode(2);
head->next->next = newNode(3);
head->next->next->next = newNode(4);
head->next->next->next->next = newNode(5);
printlist(head); // Print original list

rearrange(&head); // Modify the list
printlist(head); // Print modified list
return 0;
}

Output:
1 -> 2 -> 3 -> 4 -> 5

1 -> 5 -> 2 -> 4 -> 3

Thanks to Gaurav Ahirwar for suggesting above approach.
discussed above
Count number of ways to cover a distance
Given a distance ‘dist, count total number of ways to cover the distance with 1, 2 and 3 steps.
Examples:
Input: n = 3
Output: 4
Below are the four ways
1 step + 1 step + 1 step
1 step + 2 step
2 step + 1 step
3 step
Input: n = 4
Output: 7

// A naive recursive C++ program to count number of ways to cover

// a distance with 1, 2 and 3 steps
#include<iostream>
// Returns count of ways to cover 'dist'

int printCountRec(int dist)
{
// Base cases
if (dist<0) return 0;
if (dist==0) return 1;
// Recur for all previous 3 and add the results

return printCountRec(dist-1) +
printCountRec(dist-2) +
printCountRec(dist-3);
}
// driver program
int main()
{
int dist = 4;
cout << printCountRec(dist);
return 0;
}

Output:
n
The time complexity of above solution is exponential, a close upper bound is O(3). If we draw the complete
recursion tree, we can observer that many subproblems are solved again and again. For example, when we
start from n = 6, we can reach 4 by subtracting one 2 times and by subtracting 2 one times. So the
subproblem for 4 is called twice.
sum problem has both properties (see this and this) of a dynamic programming problem. Like other typical
Dynamic Programming(DP) problems, recomputations of same subproblems can be avoided by constructing
a temporary array count[] in bottom up manner.
Below is Dynamic Programming based C++ implementation.
// A Dynamic Programming based C++ program to count number of ways

// to cover a distance with 1, 2 and 3 steps
#include<iostream>
int printCountDP(int dist)

{
int count[dist+1];
// Initialize base values. There is one way to cover 0 and 1

// distances and two ways to cover 2 distance
count[0] = 1, count[1] = 1, count[2] = 2;
// Fill the count array in bottom up manner

for (int i=3; i<=dist; i++)
count[i] = count[i-1] + count[i-2] + count[i-3];
return count[dist];
}
// driver program
int main()
{
int dist = 4;
cout << printCountDP(dist);
return 0;
}

Output: 4
This article is contributed by Vignesh Venkatesan. Please write comments if you find anything incorrect, or
Length of the longest valid substring
Given a string consisting of opening and closing parenthesis, find length of the longest valid parenthesis
substring.
Examples:
Input : ((()
Output : 2
Explanation : ()
Input: )()())
Output : 4
Explanation: ()()
Input: ()(()))))
Output: 6
Explanation: ()(()))

A Simple Approach is to find all the substrings of given string. For every string, check if it is a valid string
or not. If valid and length is more than maximum length so far, then update maximum length. We can check
whether a substring is valid or not in linear time using a stack (See this for details). Time complexity of this
solution is O(n2.
An Efficient Solution can solve this problem in O(n) time. The idea is to store indexes of previous starting
brackets in a stack. The first element of stack is a special element that provides index before beginning of
valid substring (base for next valid string).
1) Create an empty stack and push -1 to it. The first element

of stack is used to provide base for next valid string.
3) If the character is '(' i.e. str[i] == '('), push index

'i' to the stack.

2) Else (if the character is ')')
a) Pop an item from stack (Most of the time an opening bracket)
b) If stack is not empty, then find length of current valid
substring by taking difference between current index and
top of the stack. If current length is more than result,
then update the result.
c) If stack is empty, push current index as base for next
valid substring.
3) Return result.


// C++ program to find length of the longest valid

// substring
int findMaxLen(string str)

{
// Create a stack and push -1 as initial index to it.

stack<int> stk;
stk.push(-1);
int result = 0;
// Traverse all characters of given string

{
// If opening bracket, push index of it
if (str[i] == '(')
stk.push(i);
else // If closing bracket, i.e.,str[i] = ')'

{
// Pop the previous opening bracket's index
stk.pop();
// Check if this length formed with base of

// current valid substring is more than max
// so far
if (!stk.empty())
result = max(result, i - stk.top());
// If stack is empty. push current index as

// base for next valid substring (if any)
else stk.push(i);
}
}
return result;
}
// Driver progra,
int main()
{
string str = "((()()";
cout << findMaxLen(str) << endl;
str = "()(()))))";
cout << findMaxLen(str) << endl ;
return 0;
}

Output:

4
6

Explanation with example:
Input: str = "(()()"
Initialize result as 0 and stack with one item -1.
For i = 0, str[0] = '(', we push 0 in stack
For i = 1, str[1] = '(', we push 1 in stack
For i = 2, str[2] = ')', currently stack has [-1, 0, 1], we pop

from the stack and the stack now is [-1, 0] and length of current
valid substring becomes 2 (we get this 2 by subtracting stack top
from current index).
Since current length is more than current result, we update result.
For i = 3, str[3] = '(', we push again, stack is [-1, 0, 3].
For i = 4, str[4] = ')', we pop from the stack, stack becomes

[-1, 0] and length of current valid substring becomes 2 (we get
this 4 by subtracting stack top from current index).
Since current length is more than current result, we update result.

Thanks to Gaurav Ahirwar and Ekta Goel. for suggesting above approach.
discussed above.
Hopcroft–Karp Algorithm for Maximum Matching | Set 1 (Introduction)
A matching in a Bipartite Graph is a set of the edges chosen in such a way that no two edges share an
endpoint. A maximum matching is a matching of maximum size (maximum number of edges). In a
maximum matching, if any edge is added to it, it is no longer a matching. There can be more than one
maximum matching for a given Bipartite Graph.
We have discussed importance of maximum matching and Ford Fulkerson Based approach for maximal
Bipartite Matching in previous post. Time complexity of the Ford Fulkerson based algorithm is O(V x E).
Hopcroft Karp algorithm is an improvement that runs in O(√V x E) time. Let us define few terms before we
discuss the algorithm
Free Node or Vertex: Given a matching M, a node that is not part of matching is called free node. In
below diagram, the first graph all vertices as free. In second graph, u2 and v2 are free. In third graph, no
vertex is free.
Matching and Not-Matching edges: Given a matching M, edges that are part of matching are called
Matching edges and edges that are not part of M (or connect free nodes) are called Not-Matching edges. In
first graph, all edges are non-matching. In second graph, (u0, v1), (u1, v0) and (u3, v3) are matching and
others not-matching.
Alternating Paths: Given a matching M, an alternating path is a path in which the edges belong
alternatively to the matching and not matching. All single edges paths are alternating paths. Examples of
alternating paths in middle graph are u0-v1-u2 and u2-v1-u0-v2.
Augmenting path: Given a matching M, an augmenting path is an alternating path that starts from and
ends on free vertices. All single edge paths that start and end with free vertices are augmenting paths. In
below diagram, augmenting paths are highlighted with blue color. Note that the augmenting path always has
one extra matching edge.
The Hopcroft Karp algorithm is based on below concept.
A matching M is not maximum if there exists an augmenting path and a matching is maximum if there
exist no augmenting path
So the algorithm looks for augmenting paths in every iteration and adds the found path to current matching.
It stops when there are no more augmenting paths.
Hopcroft Karp Algorithm
1) Initialize Maximal Matching M as empty.

2) While there exists an Augmenting Path p
Remove matching edges of p from M and add not-matching edges of p to M
(This increases size of M by 1 as p starts and ends with a free vertex)
3) Return M.

Below diagram shows working of the algorithm.

In the initial graph all single edges are augmenting paths and we can pick in any order. In the middle stage,
there is only one augmenting path. We remove matching edges of this path from M and add not-matching
edges. In final matching, there are no augmenting paths so the matching is maximum.
We will soon be discussing implementation of above algorithm.
References:
https://en.wikipedia.org/wiki/Hopcroft%E2%80%93Karp_algorithm
http://www.dis.uniroma1.it/~leon/tcs/lecture2.pdf
discussed above
Hopcroft–Karp Algorithm for Maximum Matching | Set 2
(Implementation)
We strongly recommend to refer below post as a prerequisite.
Hopcroft–Karp Algorithm for Maximum Matching | Set 1 (Introduction)
There are few important things to note before we start implementation.
1. We need to find an augmenting path (A path that alternates between matching and not matching
edges, and has free vertices as starting and ending points).
2. Once we find alternating path, we need to add the found path to existing Matching . Here adding
path means, making previous matching edges on this path as not-matching and previous not-
matching edges as matching.
The idea is to use BFS (Breadth First Search) to find augmenting paths. Since BFS traverses level by level, it
is used to divide the graph in layers of matching and not matching edges. A dummy vertex NIL is added that
is connected to all vertices on left side and all vertices on right side. Following arrays are used to find
augmenting path. Distance to NIL is initialized as INF (infinite). If we start from dummy vertex and come
back to it using alternating path of distinct vertices, then there is an augmenting path.
1. pairU[]: An array of size m+1 where m is number of vertices on left side of Bipartite Graph. pairU[u]
stores pair of u on right side if u is matched and NIL otherwise.
2. pairV[]: An array of size n+1 where n is number of vertices on right side of Bipartite Graph. pairU[v]
stores pair of v on left side if v is matched and NIL otherwise.
3. dist[]: An array of size m+1 where m is number of vertices on left side of Bipartite Graph. dist[u] is
initialized as 0 if u is not matching and INF (infinite) otherwise. dist[] of NIL is also initialized as INF
Once an augmenting path is found, DFS (Depth First Search) is used to add augmenting paths to current
matching. DFS simply follows the distance array setup by BFS. It fills values in pairU[u] and pairV[v] if v is
next to u in BFS.
Below is C++ implementation of above Hopkroft Karp algorithm.
// C++ implementation of Hopcroft Karp algorithm for

// maximum matching
#define NIL 0
#define INF INT_MAX
// A class to represent Bipartite graph for Hopcroft

// Karp implementation
class BipGraph
{
// m and n are number of vertices on left
// and right sides of Bipartite Graph
int m, n;
// adj[u] stores adjacents of left side

// vertex 'u'. The value of u ranges from 1 to m.
// 0 is used for dummy vertex
list<int> *adj;
// These are basically pointers to arrays needed

// for hopcroftKarp()
int *pairU, *pairV, *dist;
public:
BipGraph(int m, int n); // Constructor
void addEdge(int u, int v); // To add edge
// Returns true if there is an augmenting path

bool bfs();
// Adds augmenting path if there is one beginning

// with u
bool dfs(int u);
// Returns size of maximum matcing

int hopcroftKarp();
};
// Returns size of maximum matching

int BipGraph::hopcroftKarp()
{
// pairU[u] stores pair of u in matching where u
// is a vertex on left side of Bipartite Graph.
// If u doesn't have any pair, then pairU[u] is NIL
pairU = new int[m+1];
// pairV[v] stores pair of v in matching. If v

// doesn't have any pair, then pairU[v] is NIL
pairV = new int[n+1];
// dist[u] stores distance of left side vertices

// dist[u] is one more than dist[u'] if u is next
// to u'in augmenting path
dist = new int[m+1];
// Initialize NIL as pair of all vertices

for (int u=0; u<m; u++)
pairU[u] = NIL;
for (int v=0; v<n; v++)
pairV[v] = NIL;
int result = 0;
// Keep updating the result while there is an

// augmenting path.
while (bfs())
{
// Find a free vertex
for (int u=1; u<=m; u++)
// If current vertex is free and there is

// an augmenting path from current vertex
if (pairU[u]==NIL && dfs(u))
result++;
}
return result;
}
// Returns true if there is an augmenting path, else returns

// false
bool BipGraph::bfs()
{
queue<int> Q; //an integer queue
// First layer of vertices (set distance as 0)

{
// If this is a free vertex, add it to queue
if (pairU[u]==NIL)
{
// u is not matched
dist[u] = 0;
Q.push(u);
}
// Else set distance as infinite so that this vertex

// is considered next time
else dist[u] = INF;
}
// Initialize distance to NIL as infinite

dist[NIL] = INF;
// Q is going to contain vertices of left side only.

while (!Q.empty())
{
// Dequeue a vertex
int u = Q.front();
Q.pop();
// If this node is not NIL and can provide a shorter path to NIL
if (dist[u] < dist[NIL])
{
// Get all adjacent vertices of the dequeued vertex u
for (i=adj[u].begin(); i!=adj[u].end(); ++i)
{
int v = *i;
// If pair of v is not considered so far

// (v, pairV[V]) is not yet explored edge.
if (dist[pairV[v]] == INF)
{
// Consider the pair and add it to queue
dist[pairV[v]] = dist[u] + 1;
Q.push(pairV[v]);
}
}
}
}
// If we could come back to NIL using alternating path of distinct

// vertices then there is an augmenting path
return (dist[NIL] != INF);
}
// Returns true if there is an augmenting path beginning with free vertex u

bool BipGraph::dfs(int u)
{
if (u != NIL)
{
for (i=adj[u].begin(); i!=adj[u].end(); ++i)
{
// Adjacent to u
int v = *i;
// Follow the distances set by BFS

if (dist[pairV[v]] == dist[u]+1)
{
{
// If dfs for pair of v also returns
// true
if (dfs(pairV[v]) == true)
{
pairV[v] = u;
pairU[u] = v;
return true;
}
}
}
// If there is no augmenting path beginning with u.

dist[u] = INF;
return false;
}
return true;
}
// Constructor
BipGraph::BipGraph(int m, int n)
{
this->m = m;
this->n = n;
adj = new list<int>[m+1];
}
// To add edge from u to v and v to u

void BipGraph::addEdge(int u, int v)
{
adj[u].push_back(v); // Add u to v’s list.
adj[v].push_back(u); // Add u to v’s list.
}
// Driver Program
int main()
{
BipGraph g(4, 4);
g.addEdge(1, 2);
g.addEdge(1, 3);
g.addEdge(2, 1);
g.addEdge(3, 2);
g.addEdge(4, 2);
g.addEdge(4, 4);
cout << "Size of maximum matching is " << g.hopcroftKarp();
return 0;
}

Output:

Size of maximum matching is 4

The above implementation is mainly adopted from the algorithm provided on Wiki page of Hopcroft Karp
algorithm.
Find the longest path in a matrix with given constraints
2
Given a n*n matrix where numbers all numbers are distinct and are distributed from range 1 to n, find the
maximum length path (starting from any cell) such that all cells along the path are increasing order with a
difference of 1.
We can move in 4 directions from a given cell (i, j), i.e., we can move to (i+1, j) or (i, j+1) or (i-1, j) or (i, j-1)
with the condition that the adjacen
Example:
Input: mat[][] = {{1, 2, 9}

{5, 3, 8}
{4, 6, 7}}
Output: 4
The longest path is 6-7-8-9.

The idea is simple, we calculate longest path beginning with every cell. Once we have computed longest for
all cells, we return maximum of all longest paths. One important observation in this approach is many
overlapping subproblems. Therefore this problem can be optimally solved using Dynamic Programming.
Below is Dynamic Programming based C implementation that uses a lookup table dp[][] to check if a
problem is already solved or not.
#define n 3
// Returns length of the longest path beginning with mat[i][j].

// This function mainly uses lookup table dp[n][n]
int findLongestFromACell(int i, int j, int mat[n][n], int dp[n][n])
{
// Base case
if (i<0 || i>=n || j<0 || j>=n)
return 0;
// If this subproblem is already solved

if (dp[i][j] != -1)
return dp[i][j];
// Since all numbers are unique and in range from 1 to n*n,

// there is atmost one possible direction from any cell
if ((mat[i][j] +1) == mat[i][j+1])
return dp[i][j] = 1 + findLongestFromACell(i,j+1,mat,dp);
if (mat[i][j] +1 == mat[i][j-1])
return dp[i][j] = 1 + findLongestFromACell(i,j-1,mat,dp);
if (mat[i][j] +1 == mat[i-1][j])
return dp[i][j] = 1 + findLongestFromACell(i-1,j,mat,dp);
if (mat[i][j] +1 == mat[i+1][j])
return dp[i][j] = 1 + findLongestFromACell(i+1,j,mat,dp);
// If none of the adjacent fours is one greater

// If none of the adjacent fours is one greater
return dp[i][j] = 1;
}
// Returns length of the longest path beginning with any cell

int finLongestOverAll(int mat[n][n])
{
int result = 1; // Initialize result
// Create a lookup table and fill all entries in it as -1

int dp[n][n];
// Compute longest path beginning from all cells

{
{
if (dp[i][j] == -1)
findLongestFromACell(i, j, mat, dp);

result = max(result, dp[i][j]);
}
}
return result;
}
// Driver program
int main()
{
int mat[n][n] = {{1, 2, 9},
{5, 3, 8},
{4, 6, 7}};
cout << "Length of the longest path is "
<< finLongestOverAll(mat);
return 0;
}

Output:

Length of the longest path is 4

Time complexity of the above solution is O(n2). It may seem more at first look. If we take a closer look, we
can notice that all values of dp[i][j] are computed only once.
Find number of solutions of a linear equation of n variables
Given a linear equation of n variables, find number of non-negative integer solutions of it. For example,let
the given equation be “x + 2y = 5″, solutions of this equation are “x = 1, y = 2″, “x = 5, y = 0″ and “x = 1. It
may be assumed that all coefficients in given equation are positive integers.
Example:
Input: coeff[] = {1, 2}, rhs = 5

Output: 3
The equation "x + 2y = 5" has 3 solutions.
(x=3,y=1), (x=1,y=2), (x=5,y=0)
Input: coeff[] = {2, 2, 3}, rhs = 4

Output: 3
The equation "2x + 2y + 3z = 4" has 3 solutions.
(x=0,y=2,z=0), (x=2,y=0,z=0), (x=1,y=1,z=0)

We can solve this problem recursively. The idea is to subtract first coefficient from rhs and then recur for
remaining value of rhs.
If rhs = 0
countSol(coeff, 0, rhs, n-1) = 1
Else
countSol(coeff, 0, rhs, n-1) = &Sum;countSol(coeff, i, rhs-coeff[i], m-1)
where coeff[i]
Below is recursive C++ implementation of above solution.

// A naive recursive C++ program to find number of non-negative
// solutions for a given linear equation
// Recursive function thet returns count of solutions for given

// rhs value and coefficients coeff[start..end]
int countSol(int coeff[], int start, int end, int rhs)
{
// Base case
if (rhs == 0)
return 1;
int result = 0; // Initialize count of solutions
// One by subtract all smaller or equal coefficiants and recur

for (int i=start; i<=end; i++)
if (coeff[i] <= rhs)
result += countSol(coeff, i, end, rhs-coeff[i]);
return result;
}
// Driver program
int main()
{
int coeff[] = {2, 2, 5};
int rhs = 4;
int n = sizeof(coeff)/sizeof(coeff[0]);
cout << countSol(coeff, 0, n-1, rhs);
return 0;
}

Output:
The time complexity of above solution is exponential. We can solve this problem in Pseud
o Polynomial Time (time complexity is dependent on numeric value of input) using Dynamic
Programming. The idea is similar to Dynamic Programming solution Subset Sum problem. Be
low is Dynamic Programming based C++ implementation.

// A Dynamic programming based C++ program to find number of
// non-negative solutions for a given linear equation
// Returns counr of solutions for given rhs and coefficients

// coeff[0..n-1]
int countSol(int coeff[], int n, int rhs)
{
// Create and initialize a table to store results of
// subproblems
int dp[rhs+1];
memset(dp, 0, sizeof(dp));
dp[0] = 1;
// Fill table in bottom up manner

for (int j=coeff[i]; j<=rhs; j++)
dp[j] += dp[j-coeff[i]];
return dp[rhs];
}
// Driver program
int main()
{
int coeff[] = {2, 2, 5};
int rhs = 4;
int n = sizeof(coeff)/sizeof(coeff[0]);
cout << countSol(coeff, n, rhs);
return 0;
}

Output:
4
Time Complexity of above solution is O(n * rhs)
This article is contributed by Ashish Gupta. Please write comments if you find anything

How to check if a given array represents a Binary Heap?
Given an array, how to check if the given array represents a Binary Max-Heap.
Examples:
Input: arr[] = {90, 15, 10, 7, 12, 2}

Output: True
The given array represents below tree
90
/ \
15 10
/ \ /
7 12 2
The tree follows max-heap property as every
node is greater than all of its descendants.
Input: arr[] = {9, 15, 10, 7, 12, 11}

Output: False
The given array represents below tree
9
/ \
15 10
/ \ /
7 12 11
The tree doesn't follows max-heap property 9 is
smaller than 15 and 10, and 10 is smaller than 11.

A Simple Solution is to first check root, if it’s greater than all of its descendants. Then check for children of
root. Time complexity of this solution is O(n 2)
An Efficient Solution is to compare root only with its children (not all descendants), if root is greater than
its children and same is true for for all nodes, then tree is max-heap (This conclusion is based on transitive
property of > operator, i.e., if x > y and y > z, then x > z).

// C program to check whether a given array

// represents a max-heap or not
#include <stdio.h>
#include <limits.h>
// Function to handle array bound

int getVal(int arr[], int idx, int n)
{
if (idx < n)
return arr[idx];
else
return INT_MIN;
}
// Returns true if arr[i..n-1] represents a

// max-heap
bool isHeap(int arr[], int i, int n)
{
// Base case
if (i >= n - 1)
return true;
// If root is greate than its children and

// same is recursively true for the children
if (arr[i] >= getVal(arr, 2*i + 1, n) &&
arr[i] >= getVal(arr, 2*i + 2, n) &&
isHeap(arr, 2*i + 1, n) &&
isHeap(arr, 2*i + 2, n))
return true;
return false;
}
// Driver program
int main()
{
int arr[] = {90, 15, 10, 7, 12, 2, 7, 3};
int n = sizeof(arr) / sizeof(int);
isHeap(arr, 0, n)? printf("Yes"): printf("No");
return 0;
}

Output:

Yes

Time complexity of this solution is O(n). The solution is similar to preorder traversal of Binary Tree.
Thanks to Utkarsh Trivedi for suggesting the above solution.
discussed above
Find minimum time to finish all jobs with given constraints
Given an array of jobs with different time requirements. There are K identical assignees available and we are
also given how much time an assignee takes to do one unit of job. Find the minimum time to finish all jobs
with following constraints.
An assignee can be assigned only contiguous jobs. For example, an assignee cannot be assigned jobs 1
and 3, but not 2.
Two assignees cannot share (or co-assigned) a job, i.e., a job cannot be partially assigned to one
assignee and partially to other.
Input :
K: Number of assignees available.

T: Time taken by an assignee to finish one unit
of job
job[]: An array that represents time requirements of
different jobs.

Example:
Input: k = 2, T = 5, job[] = {4, 5, 10}

Output: 50
The minimum time required to finish all jobs is 50.
There are 2 assignees available. We get this time by
assigning {4, 5} to first assignee and {10} to second
assignee.
Input: k = 4, T = 5, job[] = {10, 7, 8, 12, 6, 8}

Output: 75
We get this time by assigning {10} {7, 8} {12} and {7, 8}

The idea is to use Binary Search. Think if we have a function (say isPossible()) that tells us if it’s possible to
finish all jobs within a given time and number of available assignees. We can solve this problem by doing a
binary search for the answer. If middle point of binary search is not possible, then search in second half, else
search in first half. Lower bound for Binary Search for minimum time can be set as 0. The upper bound can
be obtained by adding all given job times.
Now how to implement isPossible()? This function can be implemented using Greedy Approach. Since we
want to know if it is possible to finish all jobs within a given time, we traverse through all jobs and keep
assigning jobs to current assignee one by one while a job can be assigned within the given time limit. When
time taken by current assignee exceeds the given time, create a new assignee and start assigning jobs to it. If
number of assignees become more than k, then return false, else return true.
// C++ program to find minimum time to finish all jobs with

// given number of assignees
// Utility function to get maximum element in job[0..n-1]
{
int result = arr[0];
if (arr[i] > result)
result = arr[i];
return result;
}
// Returns true if it is possible to finish jobs[] within

// given time 'time'
bool isPossible(int time, int K, int job[], int n)
{
// cnt is count of current assignees required for jobs
int cnt = 1;
int curr_time = 0; // time assigned to current assignee
for (int i = 0; i < n;)

{
// If time assigned to current assignee exceeds max,
// increment count of assignees.
if (curr_time + job[i] > time) {
curr_time = 0;
cnt++;
}
else { // Else add time of job to current time and move
// to next job.
curr_time += job[i];
i++;
}
}
// Returns true if count is smaller than k

return (cnt <= K);
}
// Returns minimum time required to finish given array of jobs

// k --> number of assignees
// T --> Time required by every assignee to finish 1 unit
// m --> Number of jobs
int findMinTime(int K, int T, int job[], int n)
{
// Set start and end for binary search
// end provides an upper limit on time
int end = 0, start = 0;
for (int i = 0; i < n; ++i)
end += job[i];
int ans = end; // Initialize answer
// Find the job that takes maximum time

int job_max = getMax(job, n);
// Do binary search for minimum feasible time

while (start <= end)
{
// If it is possible to finish jobs in mid time

if (mid >= job_max && isPossible(mid, K, job, n))
{
ans = min(ans, mid); // Update answer
end = mid - 1;
}
else
start = mid + 1;
}
return (ans * T);

}
// Driver program
int main()
{
int job[] = {10, 7, 8, 12, 6, 8};
int n = sizeof(job)/sizeof(job[0]);
int k = 4, T = 5;
cout << findMinTime(k, T, job, n) << endl;
return 0;
}

Output:

75

discussed above
Sort a stack using recursion
Given a stack, sort it using recursion. Use of any loop constructs like while, for..etc is not allowed. We can
only use the following ADT functions on Stack S:

is_empty(S) : Tests whether stack is empty or not.
push(S) : Adds new element to the stack.
pop(S) : Removes top element from the stack.
top(S) : Returns value of the top element. Note that this
function does not remove element from the stack.

Example:

Input: -3 <--- Top
14
18
-5
30
Output: 30 <--- Top

18
14
-3
-5

This problem is mainly a variant of Reverse stack using recursion.
The idea of the solution is to hold all values in Function Call Stack until the stack becomes empty. When the
stack becomes empty, insert all held items one by one in sorted order. Here sorted order is important.
Algorithm
We can use below algorithm to sort stack elements:

sortStack(stack S)
if stack is not empty:
temp = pop(S);
sortStack(S);
sortedInsert(S, temp);

Below algorithm is to insert element is sorted order:

sortedInsert(Stack S, element)
if stack is empty OR element > top element
push(S, elem)
else
temp = pop(S)
sortedInsert(S, element)
push(S, temp)

Illustration:

Let given stack be
-3 <-- top of the stack
14
18
-5
30

Let us illustrate sorting of stack using above example:
First pop all the elements from the stack and store poped element in variable 'temp'. After poping all the
elements function's stack frame will look like:

temp = -3 --> stack frame #1
temp = 14 --> stack frame #2
temp = -5 --> stack frame #4

Now stack is empty and 'insert_in_sorted_order()' function is called and it inserts 30 (from stack frame #5)
at the bottom of the stack. Now stack looks like below:
30
Now next element i.e. -5 (from stack frame #4) is picked. Since -5
30 <-- top of the stack

-5
Next 18 (from stack frame #3) is picked. Since 18

18
-5
Next 14 (from stack frame #2) is picked. Since 14

18
18
14
-5
Now -3 (from stack frame #1) is picked, as -3

18
14
-3
-5
Implementation:
// C program to sort a stack using recursion

#include <stdio.h>
#include <stdlib.h>
// Stack is represented using linked list

struct stack
{
int data;
struct stack *next;
};
// Utility function to initialize stack

void initStack(struct stack **s)
{
*s = NULL;
}
// Utility function to chcek if stack is empty

int isEmpty(struct stack *s)
{
if (s == NULL)
return 1;
return 0;
}
// Utility function to push an item to stack

void push(struct stack **s, int x)
{
struct stack *p = (struct stack *)malloc(sizeof(*p));
if (p == NULL)
{
fprintf(stderr, "Memory allocation failed.\n");
return;
}
p->data = x;
p->next = *s;
*s = p;
}
// Utility function to remove an item from stack

int pop(struct stack **s)
int pop(struct stack **s)
{
int x;
struct stack *temp;
x = (*s)->data;
temp = *s;
(*s) = (*s)->next;
free(temp);
return x;
}
// Function to find top item

int top(struct stack *s)
{
return (s->data);
}
// Recursive function to insert an item x in sorted way

void sortedInsert(struct stack **s, int x)
{
// Base case: Either stack is empty or newly inserted
// item is greater than top (more than all existing)
if (isEmpty(*s) || x > top(*s))
{
push(s, x);
return;
}
// If top is smaller, remove the top item and recur

int temp = pop(s);
sortedInsert(s, x);
// Put back the top item removed earlier

push(s, temp);
}
// Function to sort stack

void sortStack(struct stack **s)
{
// If stack is not empty
if (!isEmpty(*s))
{
// Remove the top item
int x = pop(s);
// Sort remaining stack

sortStack(s);
// Push the top item back in sorted stack

sortedInsert(s, x);
}
}
// Utility function to print contents of stack

void printStack(struct stack *s)
{
while (s)
{
printf("%d ", s->data);
s = s->next;
}
printf("\n");
}
}
// Driver Program
int main(void)
{
struct stack *top;
initStack(&top);
push(&top, 30);
push(&top, -5);
push(&top, 18);
push(&top, 14);
push(&top, -3);
printf("Stack elements before sorting:\n");

printStack(top);
sortStack(&top);
printf("\n\n");
printf("Stack elements after sorting:\n");

printStack(top);
return 0;
}

Output:
Stack elements before sorting:

-3 14 18 -5 30
Stack elements after sorting:

30 18 14 -3 -5
Exercise: Modify above code to reverse stack in descending order.
This article is contributed by Narendra Kangralkar. Please write comments if you find an
ything incorrect, or you want to share more information about the topic discussed above

K Dimensional Tree | Set 2 (Find Minimum)
We strongly recommend to refer below post as a prerequisite of this.
K Dimensional Tree | Set 1 (Search and Insert)
In this post find minimum is discussed. The operation is to find minimum in the given dimension. This is
especially needed in delete operation.
For example, consider below KD Tree, if given dimension is x, then output should be 5 and if given
dimensions is t, then output should be 12. Below images are taken from this source.
kdtree
In KD tree, points are divided dimension by dimension. For example, root divides keys by dimension 0, level
next to root divides by dimension 1, next level by dimension 2 if k is more then 2 (else by dimension 0), and
so on.
To find minimum we traverse nodes starting from root. If dimension of current level is same as
given dimension, then required minimum lies on left side if there is left child. This is same as
Binary Search Tree Minimum.
Above is simple, what to do when current level’s dimension is different. When dimension of current
level is different, minimum may be either in left subtree or right subtree or current node
may also be minimum. So we take minimum of three and return. This is different from Binary Search
tree.
Below is C++ implementation of find minimum operation.

// A C++ program to demonstrate find minimum on KD tree
const int k = 2;
// A structure to represent node of kd tree

struct Node
{
int point[k]; // To store k dimensional point
Node *left, *right;
};

struct Node* newNode(int arr[])
{
struct Node* temp = new Node;

temp->point[i] = arr[i];

return temp;
}
// Inserts a new node and returns root of modified tree

Node *insertRec(Node *root, int point[], unsigned depth)
{
// Tree is empty?
if (root == NULL)
return newNode(point);
// Calculate current dimension (cd) of comparison
unsigned cd = depth % k;
// Compare the new point with root on current dimension 'cd'

// and decide the left or right subtree
if (point[cd] < (root->point[cd]))
root->left = insertRec(root->left, point, depth + 1);
else
root->right = insertRec(root->right, point, depth + 1);
return root;
}
// Function to insert a new point with given point in

// KD Tree and return new root. It mainly uses above recursive
// function "insertRec()"
Node* insert(Node *root, int point[])
{
return insertRec(root, point, 0);
}

{
return min(x, min(y, z));
}
// Recursively finds minimum of d'th dimension in KD tree

// The parameter depth is used to determine current axis.
int findMinRec(Node* root, int d, unsigned depth)
{
// Base cases
if (root == NULL)
return INT_MAX;
// Current dimension is computed using current depth and total

// dimensions (k)
// Compare point with root with respect to cd (Current dimension)

if (cd == d)
{
return root->point[d];
return findMinRec(root->left, d, depth+1);
}
// If current dimension is different then minimum can be anywhere

// in this subtree
return min(root->point[d],
findMinRec(root->left, d, depth+1),
findMinRec(root->right, d, depth+1));
}
// A wrapper over findMinRec(). Returns minimum of d'th dimension

int findMin(Node* root, int d)
{
// Pass current level or depth as 0
return findMinRec(root, d, 0);
}

int main()
{
{
int points[][k] = {{30, 40}, {5, 25}, {70, 70},
{10, 12}, {50, 30}, {35, 45}};

root = insert(root, points[i]);
cout << "Minimum of 0'th dimension is " << findMin(root, 0) << endl;
cout << "Minimum of 1'th dimension is " << findMin(root, 1) << endl;
return 0;
}

Output:

Minimum of 0'th dimension is 5
Minimum of 1'th dimension is 12

Source:
https://www.cs.umd.edu/class/spring2008/cmsc420/L19.kd-trees.pdf
Square root of an integer
Given an integer x, find square root of it. If x is not a perfect square, then return floor(√x).
Examples:
Input: x = 4
Output: 2
Input: x = 11
Output: 3

There can be many ways to solve this problem. For example Babylonian Method is one way.
A Simple Solution to find floor of square root is to try all numbers starting from 1. For every tried number
i, if i*i is smaller than x, then increment i. We stop when i*i becomes more than or equal to x. Below is C++
implementation of above idea.
// A C++ program to find floor(sqrt(x)

// Returns floor of square root of x

int floorSqrt(int x)
{
// Base cases
if (x == 0 || x == 1)
return x;
// Staring from 1, try all numbers until

// i*i is greater than or equal to x.
int i = 1, result = 1;
while (result < x)
{
if (result == x)
return result;
i++;
result = i*i;
}
return i-1;
}
// Driver program
int main()
{
int x = 11;
cout << floorSqrt(x) << endl;
return 0;
}

Output:

3

Time complexity of the above solution is O(√ n). Thanks Fattepur Mahesh for suggesting this solution.
A Better Solution to do Binary Search.
Let 's' be the answer. We know that 0 = r
If r*r > x, s
Algorithm:
1) Start with 'start' = 0, end = 'x',
2) Do following while 'start' is smaller than or equal to 'end'.
a) Compute 'mid' as (start + end)/2
b) compare mid*mid with x.
c) If x is equal to mid*mid, return mid.
d) If x is greater, do binary search between mid+1 and end. In this case, we

also update ans (Note that we need floor).
e) If x is smaller, do binary search between start and mid-1
C/C++

// A C++ program to find floor(sqrt(x)
// Returns floor of square root of x

int floorSqrt(int x)
{
// Base cases
if (x == 0 || x == 1)
return x;
// Do Binary Search for floor(sqrt(x))

int start = 1, end = x, ans;
{
// If x is a perfect square
if (mid*mid == x)
return mid;
return mid;
// Since we need floor, we update answer when mid*mid is

// smaller than x, and move closer to sqrt(x)
if (mid*mid < x)
{
start = mid + 1;
ans = mid;
}
else // If mid*mid is greater than x
end = mid - 1;
}
return ans;
}

// Driver program
int main()
{
int x = 11;
cout << floorSqrt(x) << endl;
return 0;
}

Java

// A Java program to find floor(sqrt(x)
public class Test
{
public static int floorSqrt(int x)
{
// Base Cases
if (x == 0 || x == 1)
return x;
// Do Binary Search for floor(sqrt(x))

int start = 1, end = x, ans=0;
{
// If x is a perfect square
if (mid*mid == x)
return mid;
// Since we need floor, we update answer when mid*mid is

// smaller than x, and move closer to sqrt(x)
if (mid*mid < x)
{
start = mid + 1;
ans = mid;
}
else // If mid*mid is greater than x
end = mid - 1;
}
return ans;
}
}
// Driver Method
public static void main(String args[])
{
int x = 11;
System.out.println(floorSqrt(x));
}
}
// Contributed by InnerPeace

Output:
Time Complexity: O(Log x)
Thanks to Gaurav Ahirwar for suggesting above method.
Note: The Binary Search can be further optimized to start with 'start' = 0 and 'end' = x
/2. Floor of square root of x cannot be more than x/2 when x > 1.
Thanks to vinit for suggesting above optimization.

K Dimensional Tree | Set 3 (Delete)
We strongly recommend to refer below posts as a prerequisite of this.
K Dimensional Tree | Set 1 (Search and Insert)

K Dimensional Tree | Set 2 (Find Minimum)
In this post delete is discussed. The operation is to delete a given point from K D Tree.
Like Binary Search Tree Delete, we recursively traverse down and search for the point to be deleted. Below
are steps are followed for every node visited.
1) If current node contains the point to be deleted
a. If node to be deleted is a leaf node, simply delete it (Same as BST Delete)

b. If node to be deleted has right child as not NULL (Different from BST)
i. Find minimum of current node’s dimension in right subtree.
ii. Replace the node with above found minimum and recursively delete minimum in right subtree.
c. Else If node to be deleted has left child as not NULL (Different from BST)
i. Find minimum of current node’s dimension in left subtree.
ii. Replace the node with above found minimum and recursively delete minimum in left subtree.
iii. Make new left subtree as right child of current node.
2) If current doesn’t contain the point to be deleted
a. If node to be deleted is smaller than current node on current dimension, recur for left subtree.
b. Else recur for right subtree.
Why 1.b and 1.c are different from BST?

In BST delete, if a node’s left child is empty and right is not empty, we replace the node with right child. In K
D Tree, doing this would violate the KD tree property as dimension of right child of node is different from
node’s dimension. For example, if node divides point by x axis values. then its children divide by y axis, so we
can’t simply replace node with right child. Same is true for the case when right child is not empty and left
child is empty.
Why 1.c doesn’t find max in left subtree and recur for max like 1.b?
Doing this violates the property that all equal values are in right subtree. For example, if we delete (!0, 10) in
below subtree and replace if with
Wrong Way (Equal key in left subtree after deletion)

(5, 6) (4, 10)
/ Delete(5, 6) /
(4, 10) ------------> (4, 20)
\
(4, 20)
Right way (Equal key in right subtree after deletion)

(5, 6) (4, 10)
/ Delete(5, 6) \
(4, 10) ------------> (4, 20)
\
(4, 20)

Example of Delete:
Delete (30, 40): Since right child is not NULL and dimension of node is x, we find the node with minimum x
value in right child. The node is (35, 45), we replace (30, 40) with (35, 45) and delete (35, 45).
Delete (70, 70): Dimension of node is y. Since right child is NULL, we find the node with minimum y value in
left child. The node is (50, 30), we replace (70, 70) with (50, 30) and recursively delete (50, 30) in left
subtree. Finally we make the modified left subtree as right subtree of (50, 30).
Below is C++ implementation of K D Tree delete.
// A C++ program to demonstrate delete in K D tree

const int k = 2;
// A structure to represent node of kd tree

struct Node
{
int point[k]; // To store k dimensional point
Node *left, *right;
};

struct Node* newNode(int arr[])
{
struct Node* temp = new Node;

temp->point[i] = arr[i];

return temp;
}
// Inserts a new node and returns root of modified tree

{
// Tree is empty?
if (root == NULL)
return newNode(point);
// Calculate current dimension (cd) of comparison

// Compare the new point with root on current dimension 'cd'

// and decide the left or right subtree
if (point[cd] < (root->point[cd]))
root->left = insertRec(root->left, point, depth + 1);
else
root->right = insertRec(root->right, point, depth + 1);
return root;
}
// Function to insert a new point with given point in

// KD Tree and return new root. It mainly uses above recursive
// function "insertRec()"
Node* insert(Node *root, int point[])
{
return insertRec(root, point, 0);
}

Node *minNode(Node *x, Node *y, Node *z, int d)
{
Node *res = x;
if (y != NULL && y->point[d] < res->point[d])
res = y;
if (z != NULL && z->point[d] < res->point[d])
res = z;
return res;
}
// Recursively finds minimum of d'th dimension in KD tree

// The parameter depth is used to determine current axis.
Node *findMinRec(Node* root, int d, unsigned depth)
{
// Base cases
if (root == NULL)
return NULL;
// Current dimension is computed using current depth and total

// dimensions (k)
// Compare point with root with respect to cd (Current dimension)

if (cd == d)
{
return root;
return findMinRec(root->left, d, depth+1);
}
// If current dimension is different then minimum can be anywhere

// in this subtree
return minNode(root,
findMinRec(root->left, d, depth+1),
findMinRec(root->right, d, depth+1), d);
}
// A wrapper over findMinRec(). Returns minimum of d'th dimension
Node *findMin(Node* root, int d)
{
// Pass current level or depth as 0
return findMinRec(root, d, 0);
}
// A utility method to determine if two Points are same

// in K Dimensional space
bool arePointsSame(int point1[], int point2[])
{
// Compare individual pointinate values
for (int i = 0; i < k; ++i)
if (point1[i] != point2[i])
return false;
return true;
}
// Copies point p2 to p1
void copyPoint(int p1[], int p2[])
{
p1[i] = p2[i];
}
// Function to delete a given point 'point[]' from tree with root

// as 'root'. depth is current depth and passed as 0 initially.
// Returns root of the modified tree.
Node *deleteNodeRec(Node *root, int point[], int depth)
{
// Given point is not present
if (root == NULL)
return NULL;
// Find dimension of current node

int cd = depth % k;
// If the point to be deleted is present at root

if (arePointsSame(root->point, point))
{
// 2.b) If right child is not NULL
if (root->right != NULL)
{
// Find minimum of root's dimension in right subtree
Node *min = findMin(root->right, cd);
// Copy the minimum to root

copyPoint(root->point, min->point);
// Recursively delete the minimum

root->right = deleteNodeRec(root->right, min->point, depth+1);
}
else if (root->left != NULL) // same as above
{
Node *min = findMin(root->left, cd);
copyPoint(root->point, min->point);
root->right = deleteNodeRec(root->left, min->point, depth+1);
}
else // If node to be deleted is leaf node
{
delete root;
return NULL;
}
}
return root;
}
// 2) If current node doesn't contain point, search downward

if (point[cd] < root->point[cd])
root->left = deleteNodeRec(root->left, point, depth+1);
else
root->right = deleteNodeRec(root->right, point, depth+1);
return root;
}
// Function to delete a given point from K D Tree with 'root'

Node* deleteNode(Node *root, int point[])
{
// Pass depth as 0
return deleteNodeRec(root, point, 0);
}

int main()
{
int points[][k] = {{30, 40}, {5, 25}, {70, 70},
{10, 12}, {50, 30}, {35, 45}};

root = insert(root, points[i]);
// Delet (30, 40);

root = deleteNode(root, points[0]);
cout << "Root after deletion of (30, 40)\n";

cout << root->point[0] << ", " << root->point[1] << endl;
return 0;
}
Output:

Root after deletion of (30, 40)
35, 45

Source:
https://www.cs.umd.edu/class/spring2008/cmsc420/L19.kd-trees.pdf
Find three closest elements from given three sorted arrays
Given three sorted arrays A[], B[] and C[], find 3 elements i, j and k from A, B and C respectively such that
max(abs(A[i] – B[j]), abs(B[j] – C[k]), abs(C[k] – A[i])) is minimized. Here abs() indicates absolute value.
Example :

Input: A[] = {1, 4, 10}
B[] = {2, 15, 20}
C[] = {10, 12}
Output: 10 15 10
10 from A, 15 from B and 10 from C
Input: A[] = {20, 24, 100}

B[] = {2, 19, 22, 79, 800}
C[] = {10, 12, 23, 24, 119}
Output: 24 22 23
24 from A, 22 from B and 23 from C

A Simple Solution is to run three nested loops to consider all triplets from A, B and C. Compute the value
of max(abs(A[i] – B[j]), abs(B[j] – C[k]), abs(C[k] – A[i])) for every triplet and return minimum of all values.
Time complexity of this solution is O(n 3)
A Better Solution is to us Binary Search.

1) Iterate over all elements of A[],
a) Binary search for element just smaller than or equal to in B[] and C[], and note the difference.
2) Repeat step 1 for B[] and C[].
3) Return overall minimum.
Time complexity of this solution is O(nLogn)
Efficient Solution Let ‘p’ be size of A[], ‘q’ be size of B[] and ‘r’ be size of C[]

1) Start with i=0, j=0 and k=0 (Three index variables for A,
B and C respectively)
// p, q and r are sizes of A[], B[] and C[] respectively.

2) Do following while i < p and j < q and k < r
a) Find min and maximum of A[i], B[j] and C[k]
b) Compute diff = max(X, Y, Z) - min(A[i], B[j], C[k]).
c) If new result is less than current result, change
it to the new result.
d) Increment the pointer of the array which contains
the minimum.

Note that we increment the pointer of the array which has the minimum, because our goal is to decrease the
difference. Increasing the maximum pointer increases the difference. Increase the second maximum pointer
can potentially increase the difference.

void findClosest(int A[], int B[], int C[], int p, int q, int r)
{
int diff = INT_MAX;

int res_i =0, res_j = 0, res_k = 0;

int i=0,j=0,k=0;
while (i < p && j < q && k < r)
{

int minimum = min(A[i], min(B[j], C[k]));
int maximum = max(A[i], max(B[j], C[k]));

if (maximum-minimum < diff)
{
res_i = i, res_j = j, res_k = k;
diff = maximum - minimum;
}

if (diff == 0) break;

if (A[i] == minimum) i++;
else if (B[j] == minimum) j++;
else k++;
}

cout << A[res_i] << " " << B[res_j] << " " << C[res_k];
}
int main()
{
int A[] = {1, 4, 10};
int B[] = {2, 15, 20};
int C[] = {10, 12};
int p = sizeof A / sizeof A[0];

int q = sizeof B / sizeof B[0];
int r = sizeof C / sizeof C[0];
findClosest(A, B, C, p, q, r);
return 0;
}

Output:

10 15 10

Time complexity of this solution is O(p + q + r) where p, q and r are sizes of A[], B[] and C[] respectively.
Thanks to Gaurav Ahirwar for suggesting above solutions.
discussed above.
Find four elements a, b, c and d in an array such that a+b = c+d
Given an array of distinct integers, find if there are two pairs (a, b) and (c, d) such that a+b = c+d, and a, b, c
and d are distinct elements. If there are multiple answers, then print any of them.
Example:

Input: {3, 4, 7, 1, 2, 9, 8}
Output: (3, 8) and (4, 7)
Explanation: 3+8 = 4+7
Input: {3, 4, 7, 1, 12, 9};

Output: (4, 12) and (7, 9)
Explanation: 4+12 = 7+9
Input: {65, 30, 7, 90, 1, 9, 8};

Output: No pairs found

Expected Time Complexity: O(n2)
A Simple Solution is to run four loops to generate all possible quadruples of array element. For every
quadruple (a, b, c, d), check if (a+b) = (c+d). Time complexity of this solution is O(n2).
An Efficient Solution can solve this problem in O(n2) time. The idea is to use hashing. We use sum as key
and pair as value in hash table.

Loop i = 0 to n-1 :
Loop j = i + 1 to n-1 :
calculate sum
If in hash table any index already exist
Then print (i, j) and previous pair
from hash table
Else update hash table
EndLoop;
EndLoop;

Below is C++ implementation of above idea. In below implementation, map is used instead of hash. Time
complexity of map insert and search is actually O(Log n) instead of O(1). So below implementation is O(n 2
Log n).

bool findPairs(int arr[], int n)

{

map<int, pair<int, int> > Hash;

for (int i = 0; i < n; ++i)
{
for (int j = i + 1; j < n; ++j)
{

int sum = arr[i] + arr[j];
if (Hash.find(sum) == Hash.end())
Hash[sum] = make_pair(i, j);
else
{

pair<int, int> pp = Hash[sum];

cout << "(" << arr[pp.first] << ", " << arr[pp.second]
<< ") and (" << arr[i] << ", " << arr[j] << ")\n";
return true;
}
}
}
cout << "No pairs found";

return false;
}
int main()
{
int arr[] = {3, 4, 7, 1, 2, 9, 8};
findPairs(arr, n);
return 0;
}

Output:

(3, 8) and (4, 7)

Thanks to Gaurav Ahirwar for suggesting above solutions.
Exercise:
1) Extend the above solution with duplicates allowed in array.
2) Further extend the solution to print all quadruples in output instead of just one. And all quadruples
should be printed printed in lexicographical order (smaller values before greater ones). Assume we have two
solutions S1 and S2.

S1 : a1 b1 c1 d1 ( these are values of indices int the array )
S2 : a2 b2 c2 d2
S1 is lexicographically smaller than S2 iff

a1 < a2 OR
a1 = a2 AND b1 < b2 OR
a1 = a2 AND b1 = b2 AND c1 < c2 OR
a1 = a2 AND b1 = b2 AND c1 = c2 AND d1 < d2

See this for solution of exercise.
discussed above
Generate Pythagorean Triplets
A Pythagorean triplet is a set of three integers a, b and c such that a2 + b2 = c2.
Given a limit, generate all positive Pythagorean triplets such that all values in triplets are smaller than given
limit.
Example:

Input: limit = 10
Output: 3 4 -> 5
8 6 -> 10
Input: limit = 25
Output: 3 4 -> 5
8 6 -> 10
5 12 -> 13
15 8 -> 17
12 16 -> 20
7 24 -> 25

A Simple Solution is to run generate all triplets smaller than given limit using three nested loop. For every
triplet, check if Pythagorean condition is true, if true, then print the triplet. Time complexity of this solution
is O(limit 3).
An Efficient Solution can print all triplets in O(limit2) time. The idea is to observe use square sum
relation of Pythagorean triplet, i.t., addition of squares of a and b is equal to square of c, we can write these
number in terms of m and n such that,

a = m2 - n2
b = 2 * m * n
c = m2 + n2
because,
a2 = m^4 + n^4 – 2 * m2 * n2
b 2 = 4 * m2 * n2
c2 = m^4 + n^4 + 2* m 2 * n2

by above we can see that a2 + b2 = c2

so instead of iterating for a, b and c we can iterate for m and n and can generate these triplets and as we are
iterating for m and n only
above algorithm will generate Pythagorean triplets in O(limit2) time complexity.

// A O(n^2) C program to generate all pythagorean
// triplets smaller than a given limit
#include <stdio.h>
#include <math.h>
// Function to generate pythagorean triplets

// smaller than limit
void pythagoreanTriplets(int limit)
{
// triplet: a^2 + b^2 = c^2
int a, b, c=0;
// loop from 2 to max_limitit

int m = 2;
// Limiting c would limit all a, b and c

while (c < limit)
{
// now loop on j from 1 to i-1
for (int n = 1; n < m; ++n)
{
// Evaluate and print triplets using
// the relation between a, b and c
a = m*m - n*n;
b = 2*m*n;
c = m*m + n*n;
if (c > limit)
break;
printf("%d %d %d\n", a, b, c);

}
m++;
}
}
// Driver program
int main()
{
int limit = 20;
pythagoreanTriplets(limit);
return 0;
}

Output:

3 4 5
8 6 10
5 12 13
15 8 17
12 16 20
7 24 25

References:
https://en.wikipedia.org/wiki/Formulas_for_generating_Pythagorean_triples
Find Minimum Depth of a Binary Tree
Given a binary tree, find its minimum depth. The minimum depth is the number of nodes along the shortest
path from root node down to the nearest leaf node.
For example, minimum height of below Binary Tree is 2.
Note that the path must end on a leaf node. For example, minimum height of below Binary Tree is also 2.

10
/
5

The idea is to traverse the given Binary Tree. For every node, check if it is a leaf node. If yes, then return 1. If
not leaf node then if left subtree is NULL, then recur for right subtree. And if right subtree is NULL, then
recur for left subtree. If both left and right subtrees are NULL, then take the minimum of two heights.

// C++ program to find minimum depth of a given Binary Tree
// A BT Node
struct Node
{
int data;
};
int minDepth(Node *root)

{
// Corner case. Should never be hit unless the code is
// called on root = NULL
if (root == NULL)
return 0;
// Base case : Leaf Node. This accounts for height = 1.

return 1;
// If left subtree is NULL, recur for right subtree

if (!root->left)
return minDepth(root->right) + 1;
// If right subtree is NULL, recur for right subtree

if (!root->right)
return minDepth(root->left) + 1;
return min(minDepth(root->left), minDepth(root->right)) + 1;

}
// Utility function to create new Node

{
temp->data = data;
return (temp);
}
// Driver program
int main()
{
// Let us construct the Tree shown in the above figure
cout << minDepth(root);
return 0;
}

Output:

2

Time complexity of above solution is O(n) as it traverses the tree only once.
discussed above
Compare two strings represented as linked lists
Given two linked lists, represented as linked lists (every character is a node in linked list). Write a function
compare() that works similar to strcmp(), i.e., it returns 0 if both strings are same, 1 if first linked list is
lexicographically greater, and -1 if second string is lexicographically greater.
Examples:

Input: list1 = g->e->e->k->s->a
list2 = g->e->e->k->s->b
Output: -1
Input: list1 = g->e->e->k->s->a

list2 = g->e->e->k->s
Output: 1
Input: list1 = g->e->e->k->s

list2 = g->e->e->k->s
Output: 0


// C++ program to compare two strings represented as linked
// lists

// Linked list Node structure
struct Node
{
char c;
struct Node *next;
};

Node* newNode(char c)
{
temp->c = c;
temp->next = NULL;
return temp;
};
int compare(Node *list1, Node *list2)

{
// Traverse both lists. Stop when either end of a linked
// list is reached or current characters don't match
while (list1 && list2 && list1->c == list2->c)
{
list1 = list1->next;
list2 = list2->next;
}

// If both lists are not empty, compare mismatching
// characters
if (list1 && list2)
return (list1->c > list2->c)? 1: -1;
// If either of the two lists has reached end

// If either of the two lists has reached end
if (list1 && !list2) return 1;
if (list2 && !list1) return -1;

// If none of the above conditions is true, both
// lists have reached end
return 0;
}
// Driver program
int main()
{
Node *list1 = newNode('g');
list1->next = newNode('e');
list1->next->next = newNode('e');
list1->next->next->next = newNode('k');
list1->next->next->next->next = newNode('s');
list1->next->next->next->next->next = newNode('b');
Node *list2 = newNode('g');

list2->next = newNode('e');
list2->next->next = newNode('e');
list2->next->next->next = newNode('k');
list2->next->next->next->next = newNode('s');
list2->next->next->next->next->next = newNode('a');
cout << compare(list1, list2);

return 0;
}

Output:
Thanks to Gaurav Ahirwar for suggesting above implementation.
discussed above
Symmetric Tree (Mirror Image of itself)
Given a binary tree, check whether it is a mirror of itself.
For example, this binary tree is symmetric:

1
/ \
2 2
/ \ / \
3 4 4 3

But the following is not:

1
/ \
2 2
\ \
3 3

The idea is to write a recursive function isMirror() that takes two trees as argument and returns true if trees
are mirror and false if trees are not mirror. The isMirror() function recursively checks two roots and
subtrees under the root.

// C++ program to check if a given Binary Tree is symmetric or not

struct Node
{
int key;
};

{
temp->key = key;
return (temp);
}
// Returns true if trees with roots as root1 and root2 are mirror
bool isMirror(struct Node *root1, struct Node *root2)
{
// If both trees are emptu, then they are mirror images
if (root1 == NULL && root2 == NULL)
return true;
// For two trees to be mirror images, the following three

// For two trees to be mirror images, the following three
// conditions must be true
// 1 - Their root node's key must be same
// 2 - left subtree of left tree and right subtree
// of right tree have to be mirror images
// 3 - right subtree of left tree and left subtree
// of right tree have to be mirror images
if (root1 && root2 && root1->key == root2->key)
return isMirror(root1->left, root2->right) &&
isMirror(root1->right, root2->left);
// if neither of above conditions is true then root1

// and root2 are not mirror images
return false;
}
// Returns true if a tree is symmetric i.e. mirror image of itself

bool isSymmetric(struct Node* root)
{
// Check if tre is mirror of itself
return isMirror(root, root);
}
// Driver program
int main()
{
cout << isSymmetric(root);

return 0;
}

Output:
This article is contributed by Muneer Ahmed. Please write comments if you find anything incorrect, or
Find all shortest unique prefixes to represent each word in a given list
Given an array of words, find all shortest unique prefixes to represent each word in the given array. Assume
that no word is prefix of another.
Examples:

Input: arr[] = {"zebra", "dog", "duck", "dove"}
Output: dog, dov, du, z
Explanation: dog => dog
dove = dov
duck = du
z => zebra
Input: arr[] = {"geeksgeeks", "geeksquiz", "geeksforgeeks"};

Output: geeksf, geeksg, geeksq}

A Simple Solution is to consider every prefix of every word (starting from the shortest to largest), and if a
prefix is not prefix of any other string, then print it.
An Efficient Solution is to use Trie. The idea is to maintain a count in every node. Below are steps.
1) Construct a Trie of all words. We also maintain frequency of every node (Here frequency is number of
times node is visited during insertion). Time complexity of this step is O(N) where N is total number of
characters in all words.
2) Now, for every word, we find the character nearest to the root with frequency as 1. The prefix that the path
from root to this character corresponds to, is unique prefix for the word. To do this, we can traverse tree
starting from root. For every node being traversed, we check its frequency and if frequency is one we print all
characters from root to this node and don’t go down this node.
Time complexity if this step also is O(N) where N is total number of characters in all words.

root
/ \
(d, 3)/ \(z, 1)
/ \
Node1 Node2
/ \ \
(o,2)/ \(u,1) \(e,1)
/ \ \
Node1.1 Node1.2 Node2.1
/ \ \ \
(g,1)/ \ (t,1) \(c,1) \(b,1)
/ \ \ \
Leaf Leaf Node1.2.1 Node2.1.1
(dog) (dot) \ \
\(k, 1) \(r, 1)
\ \
Leaf Node2.1.1.1
(duck) \
\(a,1)
\
Leaf
(zebra)

// C++ program to print all prefixes that
// uniquely reprsent words.
// Maximum length of a valid URL

#define MAX 256
#define MAX_WORD_LEN 500
// Trie Node.
struct trieNode
{
struct trieNode *child[MAX];
int freq; // To store frequency
};

{
newNode->freq = 1;
for (int i = 0; i<MAX; i++)
return newNode;
}
// Method to insert a new string into Trie

void insert(struct trieNode *root, string str)
{
// Length of the URL
// Traversing over the length of given str.

{
{
// in str.
int index = str[level];

else
(pCrawl->child[index]->freq)++;

}
}
// This function prints unique prefix for every word stored

// in Trie. Prefixes one by one are stored in prefix[].
// 'ind' is current index of prefix[]
void findPrefixesUtil(struct trieNode *root, char prefix[],
int ind)
{
// Corner case
if (root == NULL)
return;
// Base case
if (root->freq == 1)
{
prefix[ind] = '\0';
cout << prefix << " ";
return;
}
for (int i=0; i<MAX; i++)

{
if (root->child[i] != NULL)
{
prefix[ind] = i;
findPrefixesUtil(root->child[i], prefix, ind+1);
}
}
}
// Function to print all prefixes that uniquely

// represent all words in arr[0..n-1]
void findPrefixes(string arr[], int n)
{
// Construct a Trie of all words
root->freq = 0;
insert(root, arr[i]);
// Create an array to store all prefixes

char prefix[MAX_WORD_LEN];
findPrefixesUtil(root, prefix, 0);
}
// Driver function.
int main()
{
string arr[] = {"zebra", "dog", "duck", "dove"};
findPrefixes(arr, n);
findPrefixes(arr, n);
return 0;
}

Output:

dov dov du z

http://qa.geeksforgeeks.org/3977/find-shortest-unique-prefix-represent-each-word-list-google
discussed above.
Find minimum possible size of array with given rules for removal
Given an array of numbers and a constant k, minimize size of array with following rules for removing
elements.
Exactly three elements can be removed at one go.

The removed three elements must be adjacent in array, i.e., arr[i], arr[i+1], arr[i+2]. The second
element must be k greater than first and third element must be k greater than second, i.e., arr[i+1] –
arr[i] = k and arr[i+2]-arr[i+1] = k.
Example:

Input: arr[] = {2, 3, 4, 5, 6, 4}, k = 1
Output: 0
We can actually remove all elements.
First remove 4, 5, 6 => We get {2, 3, 4}
Now remove 2, 3, 4 => We get empty array {}
Input: arr[] = {2, 3, 4, 7, 6, 4}, k = 1

Output: 3
We can only remove 2 3 4

For every element arr[i] there are two possibilities
1) Either the element is not removed.
2) OR element is removed (if it follows rules of removal). When an element is removed, there are again two
possibilities.
…..a) It may be removed directly, i.e., initial arr[i+1] is arr[i]+k and arr[i+2] is arr[i] + 2*k.
…..b) There exist x and y such that arr[x] – arr[i] = k, arr[y] – arr[x] = k, and subarrays “arr[i+1…j-1]” &
“arr[j+1…k-1]” can be completely removed.
Below is recursive algorithm based on above idea.

// Returns size of minimum possible size of arr[low..high]
// after removing elements according to given rules
findMinSize(arr[], low, high, k)
// If there are less than 3 elements in arr[low..high]

1) If high-low+1 2) result = 1 + findMinSize(arr, low+1, high)
// Case when 'arr[low]' is part of some triplet and removed

// Try all possible triplets that have arr[low]
3) For all i from low+1 to high
For all j from i+1 to high
Update result if all of the following conditions are met
a) arr[i] - arr[low] = k
b) arr[j] - arr[i] = k
c) findMinSize(arr, low+1, i-1, k) returns 0
d) findMinSize(arr, i+1, j-1, k) also returns 0
e) Result calculated for this triplet (low, i, j)
is smaller than existing result.
4) Return result

observer that many subproblems are solved again and again. Since same suproblems are called again, this
problem has Overlapping Subprolems property. Like other typical Dynamic Programming(DP) problems,
recomputations of same subproblems can be avoided by constructing a temporary array dp[][] to store
results of the subproblems. Below is Dynamic Programming based solution
Below is C++ implementation of above idea. The implementation is memoization based, i.e., it is recursive
and uses a lookup table dp[][] to check if a subproblem is already solved or not.

// C++ program to find size of minimum possible array after
// removing elements according to given rules
#define MAX 1000
// dp[i][j] denotes the minimum number of elements left in

// the subarray arr[i..j].
int dp[MAX][MAX];
int minSizeRec(int arr[], int low, int high, int k)

{
// If already evaluated
if (dp[low][high] != -1)
return dp[low][high];
// If size of array is less than 3

if ( (high-low + 1) < 3)
return high-low +1;
// Initialize result as the case when first element is

// separated (not removed using given rules)
int res = 1 + minSizeRec(arr, low+1, high, k);
// Now consider all cases when first element forms a triplet

// and removed. Check for all possible triplets (low, i, j)
for (int i = low+1; i<=high; i++)
{
for (int j = i+1; j <= high; j++ )
{
// Check if this triplet follows the given rules of
// removal. And elements between 'low' and 'i' , and
// between 'i' and 'j' can be recursively removed.
if (arr[i] == (arr[low] + k) &&
arr[j] == (arr[low] + 2*k) &&
minSizeRec(arr, low+1, i-1, k) == 0 &&
minSizeRec(arr, i+1, j-1, k) == 0)
{
res = min(res, minSizeRec(arr, j+1, high, k));
}
}
}
// Insert value in table and return result

return (dp[low][high] = res);
}
// This function mainlu initializes dp table and calls

// recursive function minSizeRec
int minSize(int arr[], int n, int k)
{
memset(dp, -1, sizeof(dp));
return minSizeRec(arr, 0, n-1, k);
}
// Driver prrogram to test above function

int main()
{
int arr[] = {2, 3, 4, 5, 6, 4};
int k = 1;
cout << minSize(arr, n, k) << endl;
return 0;
}

Output:
Print all Jumping Numbers smaller than or equal to a given value
A number is called as a Jumping Number if all adjacent digits in it differ by 1. The difference between ‘9’ and
‘0’ is not considered as 1.
All single digit numbers are considered as Jumping Numbers. For example 7, 8987 and 4343456 are
Jumping numbers but 796 and 89098 are not.
Given a positive number x, print all Jumping Numbers smaller than or equal to x. The numbers can be
printed in any order.
Example:

Input: x = 20
Output: 0 1 2 3 4 5 6 7 8 9 10 12
Input: x = 105
Output: 0 1 2 3 4 5 6 7 8 9 10 12
21 23 32 34 43 45 54 56 65
67 76 78 87 89 98
Note: Order of output doesn't matter,

i,e., numbers can be printed in any order

One Simple Solution is to traverse all numbers from 0 to x. For every traversed number, check if it is a
Jumping number. If yes, then print it. Otherwise ignore it. Time Complexity of this solution is O(x).
An Efficient Solution can solve this problem in O(k) time where k is number of Jumping Numbers smaller
than or equal to x. The idea is use BFS or DFS.
Assume that we have a graph where the starting node is 0 and we need to traverse it from the start node to
all the reachable nodes.
With the restrictions given in the graph about the jumping numbers, what do you think should be the
restrictions defining the next transitions in the graph.

Lets take a example for input x = 90
Start node = 0
From 0, we can move to 1 2 3 4 5 6 7 8 9
[these are not in our range so we don't add it]
Now from 1, we can move to 12 and 10

From 2, 23 and 21
From 3, 34 and 32
.
.
.
.
.
.
and so on.

Below is BFS based C++ implementation of above idea.

// Finds and prints all jumping numbers smaller than or
// equal to x.
// Prints all jumping numbers smaller than or equal to x

// starting with i. It mainly does BFS starting from i.
void bfs(int x, int i)
{
// Create a queue and enqueue 'i' to it
queue<int > q;
q.push(i);
// Do BFS starting from i

while (!q.empty())
{
int num = q.front();
q.pop();
if (num <= x)
{
cout << num << " ";
int last_dig = num % 10;
// If last digit is 0, move only to next digit

if (last_dig == 0)
q.push((num*10) + (last_dig+1));
// If last digit is 9, move only to previous digit

else if (last_dig == 9)
q.push( (num*10) + (last_dig-1) );
// If last digit is neighter 0 nor 9, move both ways

else
{
q.push((num*10) + (last_dig-1));
q.push((num*10) + (last_dig+1));
}
}
}
}
// Prints all jumping numbers smaller than or equal to

// a positive number x
void printJumping(int x)
{
cout << 0 << " ";
for (int i=1; i<=9 && i<=x; i++)
bfs(x, i);
}
// Driver program
int main()
{
int x = 90;
printJumping(x);
return 0;
}

Output:

0 1 10 12 2 21 23 3 32 34 4 5 6 7 8 9

Exercise:
1. Change the above solution to use DFS instead of BFS.

2. Extend your solution to print all numbers in sorted order instead of any order.
3. Further extend the solution to print all numbers in a given range.
See this for solution of exercise.
Geeks.
Construct Binary Tree from given Parent Array representation
Given an array that represents a tree in such a way array indexes are values in tree nodes array values give
the parent node of that particular index (or node). The value of the root node index would always be -1 as
there is no parent for root. Construct the standard linked representation of given Binary Tree from this given
representation.

Input: parent[] = {1, 5, 5, 2, 2, -1, 3}
Output: root of below tree
5
/ \
1 2
/ / \
0 3 4
/
6
Explanation:
Index of -1 is 5. So 5 is root.
5 is present at indexes 1 and 2. So 1 and 2 are
children of 5.
1 is present at index 0, so 0 is child of 1.
2 is present at indexes 3 and 4. So 3 and 4 are
children of 2.
3 is present at index 6, so 6 is child of 3.
Input: parent[] = {-1, 0, 0, 1, 1, 3, 5};

Output: root of below tree
0
/ \
1 2
/ \
3 4
/
5
/
6

Expected time complexity is O(n) where n is number of elements in given array.
A Simple Solution to recursively construct by first searching the current root, then recurring for the found
indexes (there can be at most two indexes) and making them left and right subtrees of root. This solution
takes O(n2) as we have to linearly search for every node.
An Efficient Solution can solve the above problem in O(n) time. The idea is to use extra space. An array
created[0..n-1] is used to keep track of created nodes.
createTree(parent[], n)
1. Create an array of pointers say created[0..n-1]. The value of created[i] is NULL if node for index i is
not created, else value is pointer to the created node.
2. Do following for every index i of given array
createNode(parent, i, created)
createNode(parent[], i, crated[])
1. If created[i] is not NULL, then node is already created. So return.
2. Create a new node with value ‘i’.
3. If parent[i] is -1 (i is root), make created node as root and return.
4. Check if parent of ‘i’ is created (We can check this by checking if created[parent[i]] is NULL or not.
5. If parent is not created, recur for parent and create the parent first.
6. Let the pointer to parent be p. If p->left is NULL, then make the new node as left child. Else make the
new node as right child of parent.

// C++ program to construct a Binary Tree from parent array
// A tree node
struct Node
{
int key;
};

{
temp->key = key;
return (temp);
}
// Creates a node with key as 'i'. If i is root, then it changes

// root. If parent of i is not created, then it creates parent first
void createNode(int parent[], int i, Node *created[], Node **root)
{
// If this node is already created
if (created[i] != NULL)
return;
// Create a new node and set created[i]

created[i] = newNode(i);
// If 'i' is root, change root pointer and return

{
*root = created[i];
return;
}
// If parent is not created, then create parent first

if (created[parent[i]] == NULL)
createNode(parent, parent[i], created, root);
// Find parent pointer

Node *p = created[parent[i]];
// If this is first child of parent

if (p->left == NULL)
p->left = created[i];
else // If second child
p->right = created[i];
}
}
// Creates tree from parent[0..n-1] and returns root of the created tree
Node *createTree(int parent[], int n)
{
// Create an array created[] to keep track
// of created nodes, initialize all entries
// as NULL
Node *created[n];
created[i] = NULL;
Node *root = NULL;

createNode(parent, i, created, &root);
return root;
}
// Utility function to do inorder traversal

void inorder(Node *root)
{
if (root != NULL)
{
}
}
// Driver method
int main()
{
int parent[] = {-1, 0, 0, 1, 1, 3, 5};
int n = sizeof parent / sizeof parent[0];
Node *root = createTree(parent, n);
inorder(root);
return 0;
}

Output:

6 5 3 1 4 0 2

Similar Problem: Find Height of Binary Tree represented by Parent array
discussed above
Check if a number can be expressed as x^y (x raised to power y)
y
Given a positive integer n, find if it can be expressed as x where y > 1 and x > 0. x and y both are integers.
Examples:

Input: n = 8
Output: true
8 can be expressed as 23
Input: n = 49
Output: true
49 can be expressed as 72
Input: n = 48
Output: false
48 can't be expressed as xy

The idea is simple try all numbers x starting from 2 to square root of n (given number). For every x, try x^y
where y starts from 2 and increases one by one until either x^y becomes n or greater than n.

// C++ program to check if a given number can be expressed
// as power
// Returns true if n can be written as x^y

bool isPower(unsigned n)
{
if (n==1) return true;
// Try all numbers from 2 to sqrt(n) as base

for (int x=2; x<=sqrt(n); x++)
{
unsigned y = 2;
unsigned p = pow(x, y);
// Keep increasing y while power 'p' is smaller

// than n.
while (p<=n && p>0)
{
if (p==n)
return true;
y++;
p = pow(x, y);
}
}
return false;
}
// Driver Program
int main()
{
for (int i =2; i<100; i++)
if (isPower(i))
cout << i << " ";
return 0;
}

Output:

4 8 9 16 25 27 32 36 49 64 81

One optimization in above solution is to avoid call to pow() by multiplying p with x one by one.

// C++ program to check if a given number can be expressed
// as power
// Returns true if n can be written as x^y

bool isPower(unsigned int n)
{
// Base case
if (n <= 1) return true;
// Try all numbers from 2 to sqrt(n) as base

for (int x=2; x<=sqrt(n); x++)
{
unsigned p = x;
// Keep multiplying p with x while is smaller

// than or equal to x
while (p <= n)
{
p *= x;
if (p == n)
return true;
}
}
return false;
}
// Driver Program
int main()
{
for (int i =2; i<100; i++)
if (isPower(i))
cout << i << " ";
return 0;
}

Output:

4 8 9 16 25 27 32 36 49 64 81

This article is contributed by Vaibhav Gupta. Please write comments if you find anything incorrect, or you
G-Fact 20 (Cayley’s formula for Number of Labelled Trees)
Consider below questions.
1. How many spanning trees can be there in a complete graph with n vertices?
2. How many labelled Trees (please note trees, not binary trees) can be there with n vertices?
The answer is same for both questions.
For n = 2, there is 1 tree.
For n = 3, there are 3 trees.
For n = 4, there are 16 trees
The formula states that for a positive integer n, the number of trees on n labeled vertices is
n n-2
Source:
https://en.wikipedia.org/wiki/Cayley%27s_formula
This article is contributed by Vaibhav Gupta. Please write comments if you find anything incorrect, or you
Find XOR of two number without using XOR operator
Given two integers, find XOR of them without using XOR operator, i.e., without using ^ in C/C++.
Examples:

Input: x = 1, y = 2
Output: 3
Input: x = 3, y = 5
Output: 6

A Simple Solution is to traverse all bits one by one. For every pair of bits, check if both are same, set the
corresponding bit as 0 in output, otherwise set as 1.

// C++ program to find XOR without using ^
#include <iostream>
// Returns XOR of x and y

int myXOR(int x, int y)
{

// Assuming 32-bit Integer
for (int i = 31; i >= 0; i--)
{
// Find current bits in x and y
bool b1 = x & (1 << i);
bool b2 = y & (1 << i);

// If both are 1 then 0 else xor is same as OR
bool xoredBit = (b1 & b2) ? 0 : (b1 | b2);
// Update result
res <<= 1;
res |= xoredBit;
}
return res;
}

int main()
{
int x = 3, y = 5;
cout << "XOR is " << myXOR(x, y);
return 0;
}

Output:

XOR is 6

Thanks to Utkarsh Trivedi for suggesting this solution.
A Better Solution can find XOR without using loop.
1) Find bitwise OR of x and y (Result has set bits where either x has set or y has set bit). OR of x = 3 (011) and
y = 5 (101) is 7 (111)
2) To remove extra set bits find places where both x and y have set bits. The value of expression “~x | ~y” has
0 bits wherever x and y both have set bits.
3) bitwise AND of “(x | y)” and “~x | ~y” produces the required result.

// C++ program to find XOR without using ^
#include <iostream>
// Returns XOR of x and y

int myXOR(int x, int y)
{
return (x | y) & (~x | ~y);
}

int main()
{
int x = 3, y = 5;
cout << "XOR is " << myXOR(x, y);
return 0;
}

Output:

XOR is 6

Thanks to jitu_the_best for suggesting this solution.
discussed above
Treap (A Randomized Binary Search Tree)
Like Red-Black and AVL Trees, Treap is a Balanced Binary Search Tree, but not guaranteed to have height as
O(Log n). The idea is to use Randomization and Binary Heap property to maintain balance with high
probability. The expected time complexity of search, insert and delete is O(Log n).
Every node of Treap maintains two values.

1) Key Follows standard BST ordering (left is smaller and right is greater)
2) Priority Randomly assigned value that follows Max-Heap property.
Basic Operation on Treap:

Like other self-balancing Binary Search Trees, Treap uses rotations to maintain Max-Heap property during
insertion and deletion.

T1, T2 and T3 are subtrees of the tree rooted with y (on left side)
or x (on right side)
y x
/ \ Right Rotation / \
x T3 – – – – – – – > T1 y
/ \ < - - - - - - - / \
T1 T2 Left Rotation T2 T3
Keys in both of the above trees follow the following order
keys(T1) < key(x) < keys(T2) < key(y) < keys(T3)
So BST property is not violated anywhere.

search(x)
Perform standard BST Search to find x.
Insert(x):
1) Create new node with key equals to x and value equals to a random value.
2) Perform standard BST insert.
3) Use rotations to make sure that inserted node's priority follows max heap property.
Delete(x):
1) If node to be deleted is a leaf, delete it.
2) Else replace node's priority with minus infinite ( -INF ), and do appropriate rotations to bring the node
down to a leaf.
References:
https://en.wikipedia.org/wiki/Treap
https://courses.cs.washington.edu/courses/cse326/00wi/handouts/lecture19/sld017.htm
discussed above.
Treap | Set 2 (Implementation of Search, Insert and Delete)
We strongly recommend to refer set 1 as a prerequisite of this post.
Treap (A Randomized Binary Search Tree)
In this post, implementations of search, insert and delete are discussed.
Search:
Same as standard BST search. Priority is not considered for search.

// C function to search a given key in a given BST
TreapNode* search(TreapNode* root, int key)
{
// Base Cases: root is null or key is present at root
return root;

// Key is greater than root's key
if (root->key < key)
return search(root->right, key);

// Key is smaller than root's key
return search(root->left, key);
}

Insert
1) Create new node with key equals to x and value equals to a random value.
2) Perform standard BST insert.
3) A newly inserted node gets a random priority, so Max-Heap property may be violated.. Use rotations to
make sure that inserted node’s priority follows max heap property.
During insertion, we recursively traverse all ancestors of the inserted node.

a) If new node is inserted in left subtree and root of left subtree has higher priority, perform right rotation.
b) If new node is inserted in right subtree and root of right subtree has higher priority, perform left rotation.

/* Recursive implementation of insertion in Treap */
TreapNode* insert(TreapNode* root, int key)
{
// If root is NULL, create a new node and return it
if (!root)
// If key is smaller than root

if (key <= root->key)
{
// Insert in left subtree
// Fix Heap property if it is violated

if (root->left->priority > root->priority)
}
else // If key is greater
{
// Insert in right subtree

if (root->right->priority > root->priority)
}
return root;
}

Delete:
The delete implementation here is slightly different from the steps discussed in previous post.
1) If node is a leaf, delete it.
2) If node has one child NULL and other as non-NULL, replace node with the non-empty child.
3) If node has both children as non-NULL, find max of left and right children.
….a) If priority of right child is greater, perform left rotation at node
….b) If priority of left child is greater, perform right rotation at node.
The idea of step 3 is to move the node to down so that we end up with either case 1 or case 2.

/* Recursive implementation of Delete() */
TreapNode* deleteNode(TreapNode* root, int key)
{
// Base case
if (root == NULL) return root;
// IF KEYS IS NOT AT ROOT

// IF KEY IS AT ROOT
// If left is NULL
else if (root->left == NULL)
{
TreapNode *temp = root->right;
delete(root);
root = temp; // Make right child as root
}
// If Right is NULL
{
TreapNode *temp = root->left;
delete(root);
root = temp; // Make left child as root
}
// If ksy is at root and both left and right are not NULL
else if (root->left->priority < root->right->priority)
{
}
else
{
}
return root;
}

A Compete Program to Demonstrate All Operations

// C++ program to demosntrate search, insert and delete in Treap
// A Treap Node
struct TreapNode
{
int key, priority;
TreapNode *left, *right;
};
/* T1, T2 and T3 are subtrees of the tree rooted with y

/* T1, T2 and T3 are subtrees of the tree rooted with y
(on left side) or x (on right side)
y x
/ \ Right Rotation / \
x T3 – – – – – – – > T1 y
/ \ < - - - - - - - / \
T1 T2 Left Rotation T2 T3 */

TreapNode *rightRotate(TreapNode *y)
{
TreapNode *x = y->left, *T2 = x->right;
// Perform rotation
x->right = y;
y->left = T2;
// Return new root

return x;
}

TreapNode *leftRotate(TreapNode *x)
{
TreapNode *y = x->right, *T2 = y->left;
// Perform rotation
y->left = x;
x->right = T2;
// Return new root

return y;
}
/* Utility function to add a new key */

TreapNode* newNode(int key)
{
TreapNode* temp = new TreapNode;
temp->key = key;
temp->priority = rand()%100;
return temp;
}
// C function to search a given key in a given BST

TreapNode* search(TreapNode* root, int key)
{
// Base Cases: root is null or key is present at root
return root;
// Key is greater than root's key

if (root->key < key)
return search(root->right, key);
// Key is smaller than root's key

return search(root->left, key);
}
/* Recursive implementation of insertion in Treap */

TreapNode* insert(TreapNode* root, int key)
{
if (!root)
// If key is smaller than root

if (key <= root->key)
{
// Insert in left subtree

if (root->left->priority > root->priority)
}
else // If key is greater
{
// Insert in right subtree

if (root->right->priority > root->priority)
}
return root;
}
/* Recursive implementation of Delete() */

TreapNode* deleteNode(TreapNode* root, int key)
{
if (root == NULL)
return root;

// IF KEY IS AT ROOT
// If left is NULL
else if (root->left == NULL)
{
TreapNode *temp = root->right;
delete(root);
root = temp; // Make right child as root
}
// If Right is NULL
{
TreapNode *temp = root->left;
delete(root);
root = temp; // Make left child as root
}
// If ksy is at root and both left and right are not NULL
else if (root->left->priority < root->right->priority)
{
}
else
{
}
return root;
}
// A utility function to print tree

void inorder(TreapNode* root)
{
if (root)
{
cout << "key: "<< root->key << " | priority: %d "
<< root->priority;
if (root->left)
cout << " | left child: " << root->left->key;
if (root->right)
cout << " | right child: " << root->right->key;
cout << endl;
}
}

int main()
{
srand(time(NULL));
struct TreapNode *root = NULL;

cout << "Inorder traversal of the given tree \n";

inorder(root);
cout << "\nDelete 20\n";

cout << "Inorder traversal of the modified tree \n";
inorder(root);

inorder(root);

inorder(root);
TreapNode *res = search(root, 50);

(res == NULL)? cout << "\n50 Not Found ":
cout << "\n50 found";
return 0;
}

Output:

key: 20 | priority: %d 92 | right child: 50
key: 40 | priority: %d 21
key: 50 | priority: %d 73 | left child: 30 | right child: 60
Delete 20
Delete 30
Delete 50
50 Not Found

Explanation of above output:

Every node is written as key(priority)
The above code constructs below tree

20(92)
\
50(73)
/ \
30(48) 60(55)
\ \
40(21) 70(50)
\
80(44)
After deleteNode(20)
50(73)
/ \
30(48) 60(55)
\ \
40(21) 70(50)
\
80(44)

50(73)
/ \
40(21) 60(55)
\
70(50)
\
80(44)

60(55)
/ \
40(21) 70(50)
\
80(44)
Thanks to Jai Goyal for providing initial implementation. Please write comments if you find anything
Number of paths with exactly k coins
Given a matrix where every cell has some number of coins. Count number of ways to reach bottom right from
top left with exactly k coins. We can move to (i+1, j) and (i, j+1) from a cell (i, j).
Example:

Input: k = 12
mat[][] = { {1, 2, 3},
{4, 6, 5},
{3, 2, 1}
};
Output: 2
There are two paths with 12 coins
1 -> 2 -> 6 -> 2 -> 1
1 -> 2 -> 3 -> 5 -> 1

The above problem can be recursively defined as below:

pathCount(m, n, k): Number of paths to reach mat[m][n] from mat[0][0]
with exactly k coins
If (m == 0 and n == 0)
return 1 if mat[0][0] == k else return 0
Else:
pathCount(m, n, k) = pathCount(m-1, n, k - mat[m][n]) +
pathCount(m, n-1, k - mat[m][n])

Below is C++ implementation of above recursive algorithm.

// A Naive Recursive C++ program to count paths with exactly
// 'k' coins
#define R 3
#define C 3
// Recursive function to count paths with sum k from

// (0, 0) to (m, n)
int pathCountRec(int mat[][C], int m, int n, int k)
{
// Base cases
if (m < 0 || n < 0) return 0;
if (m==0 && n==0) return (k == mat[m][n]);
// (m, n) can be reached either through (m-1, n) or

// through (m, n-1)
return pathCountRec(mat, m-1, n, k-mat[m][n]) +
pathCountRec(mat, m, n-1, k-mat[m][n]);
}
// A wrapper over pathCountRec()

int pathCount(int mat[][C], int k)
{
return pathCountRec(mat, R-1, C-1, k);
}
// Driver program
int main()
{
int k = 12;
int mat[R][C] = { {1, 2, 3},
{4, 6, 5},
{3, 2, 1}
};
cout << pathCount(mat, k);
return 0;
}

Output:
The time complexity of above solution recursive is exponential. We can solve this problem in Pseudo
Polynomial Time (time complexity is dependent on numeric value of input) using Dynamic Programming.
The idea is to use a 3 dimensional table dp[m][n][k] where m is row number, n is column number and k is
number of coins. Below is Dynamic Programming based C++ implementation.

// A Dynamic Programming based C++ program to count paths with
// exactly 'k' coins
#define R 3
#define C 3
#define MAX_K 1000
int dp[R][C][MAX_K];
int pathCountDPRecDP(int mat[][C], int m, int n, int k)

{
// Base cases
if (m < 0 || n < 0) return 0;
if (m==0 && n==0) return (k == mat[m][n]);
// If this subproblem is already solved

if (dp[m][n][k] != -1) return dp[m][n][k];
// (m, n) can be reached either through (m-1, n) or

// through (m, n-1)
dp[m][n][k] = pathCountDPRecDP(mat, m-1, n, k-mat[m][n]) +
pathCountDPRecDP(mat, m, n-1, k-mat[m][n]);
return dp[m][n][k];
}
// This function mainly initializes dp[][][] and calls

// pathCountDPRecDP()
int pathCountDP(int mat[][C], int k)
{
return pathCountDPRecDP(mat, R-1, C-1, k);
}

int main()
{
int k = 12;
int mat[R][C] = { {1, 2, 3},
{4, 6, 5},
{3, 2, 1}
};
cout << pathCountDP(mat, k);
return 0;
}

Output:
Time complexity of this solution is O(m*n*k).
discussed above
Iterative Depth First Traversal of Graph
Depth First Traversal (or Search) for a graph is similar to Depth First Traversal (DFS) of a tree. The only
catch here is, unlike trees, graphs may contain cycles, so we may come to the same node again. To avoid
processing a node more than once, we use a boolean visited array.
For example, a DFS of below graph is “0 3 4 2 1″, other possible DFS is “0 2 1 3 4″.
We have discussed recursive implementation of DFS in previous in previous post. In the post, iterative DFS
is discussed. The recursive implementation uses function call stack. In iterative implementation, an explicit
stack is used to hold visited vertices.
Below is C++ implementation of Iterative DFS. The implementation is similar to BFS, the only
difference is queue is replaced by stack.

// An Iterative C++ program to do DFS traversal from
// a given source vertex. DFS(int s) traverses vertices
// reachable from s.
// This class represents a directed graph using adjacency

// list representation
class Graph
{
list<int> *adj; // adjacency lists
public:
void DFS(int s); // prints DFS from a given source s
};
Graph::Graph(int V)
{
this->V = V;
}

{
}
// Function to print all vertices reachable from 's'

// using iterative DFS.
void Graph::DFS(int s)
{
{
for(int i = 0; i < V; i++)
visited[i] = false;
// Create a stack for DFS

stack<int> stack;
// Mark the current node as visited and push it

visited[s] = true;
stack.push(s);
// 'i' will be used to get all adjacent vertices

// of a vertex
while (!stack.empty())
{
// Pop a vertex from stack and print it
s = stack.top();
cout << s << " ";
stack.pop();
// Get all adjacent vertices of the popped vertex s

// If a adjacent has not been visited, then mark it
// visited and push it to the stack
{
if (!visited[*i])
{
visited[*i] = true;
stack.push(*i);
}
}
}
}

int main()
{
Graph g(5); // Total 5 vertices in graph
g.addEdge(1, 0);
g.addEdge(0, 2);
g.addEdge(2, 1);
g.addEdge(0, 3);
g.addEdge(3, 4);
g.addEdge(4, 0);
cout << "Following is Depth First Traversal "

"(starting from vertex 0) \n";
g.DFS(0);
return 0;
}

Output:

Following is Depth First Traversal (starting from vertex 0)
0 3 4 2 1

Note that the above implementation prints only vertices that are reachable from a given vertex. For example,
if we remove edges 0-3 and 0-2, the above program would only print 0. To print all vertices of a graph, we
need to call DFS for every vertex. Below is C++ implementation for the same.

// An Iterative C++ program to do DFS traversal from
// a given source vertex. DFS(int s) traverses vertices
// reachable from s.
// This class represents a directed graph using adjacency

// list representation
class Graph
{
list<int> *adj; // adjacency lists
public:
void DFS(); // prints all vertices in DFS manner
// prints all not yet visited vertices reachable from s

void DFSUtil(int s, bool visited[]);
};
Graph::Graph(int V)
{
this->V = V;
}

{
}
// prints all not yet visited vertices reachable from s

void Graph::DFSUtil(int s, bool visited[])
{
// Create a stack for DFS
stack<int> stack;
// Mark the current node as visited and push it

visited[s] = true;
stack.push(s);
// 'i' will be used to get all adjacent vertices

// of a vertex
while (!stack.empty())
{
// Pop a vertex from stack and print it
s = stack.top();
cout << s << " ";
stack.pop();
// Get all adjacent vertices of the popped vertex s

// If a adjacent has not been visited, then mark it
// visited and push it to the stack
{
if (!visited[*i])
{
visited[*i] = true;
stack.push(*i);
}
}
}
}
// prints all vertices in DFS manner

void Graph::DFS()
{
for (int i = 0; i < V; i++)
visited[i] = false;
for (int i = 0; i < V; i++)

if (!visited[i])
}

int main()
{
// Let us create a disconnected graph without
// edges 0-2 and 0-3 in above graph
Graph g(5); // Total 5 vertices in graph
g.addEdge(1, 0);
g.addEdge(2, 1);
g.addEdge(3, 4);
g.addEdge(4, 0);
cout << "Following is Depth First Traversal\n";

g.DFS();
return 0;
}

Output:

Following is Depth First Traversal
0 1 2 3 4

Like recursive traversal, time complexity of iterative implementation is O(V + E).
Find the element before which all the elements are smaller than it, and after
which all are greater
Given an array, find an element before which all elements are smaller than it, and after which all are greater
than it. Return index of the element if there is such an element, otherwise return -1.
Examples:

Input: arr[] = {5, 1, 4, 3, 6, 8, 10, 7, 9};
Output: Index of element is 4
All elements on left of arr[4] are smaller than it
and all elements on right are greater.

Input: arr[] = {5, 1, 4, 4};
Output: Index of element is -1

A Simple Solution is to consider every element one by one. For every element, compare it with all
elements on left and all elements on right. Time complexity of this solution is O(n2).
An Efficient Solution can solve this problem in O(n) time using O(n) extra space. Below is detailed
solution.
1) Create two arrays leftMax[] and rightMin[].

2) Traverse input array from left to right and fill leftMax[] such that leftMax[i] contains maximum element
from 0 to i-1 in input array.
3) Traverse input array from right to left and fill rightMin[] such that rightMin[i] contains minimum
element from to n-1 to i+1 in input array.
4) Traverse input array. For every element arr[i], check if arr[i] is greater than leftMax[i] and smaller than
rightMin[i]. If yes, return i.
Further Optimization to above approach is to use only one extra array and traverse input array only
twice. First traversal is same as above and fills leftMax[]. Next traversal traverses from right and keeps track
of minimum. The second traversal also finds the required element.
Below is C++ implementation of above approach.

// C++ program to find the element which is greater than
// all left elements and smaller than all right elements.
int findElement(int arr[], int n)

{
// leftMax[i] stores maximum of arr[0..i-1]
int leftMax[n];
leftMax[0] = INT_MIN;
// Fill leftMax[]1..n-1]
for (int i = 1; i < n; i++)
leftMax[i] = max(leftMax[i-1], arr[i-1]);
// Initialize minimum from right

int rightMin = INT_MAX;
// Traverse array from right

for (int i=n-1; i>=0; i--)
{
// Check if we found a required element
if (leftMax[i] < arr[i] && rightMin > arr[i])
return i;
// Update right minimum

rightMin = min(rightMin, arr[i]);
}
// If there was no element matching criteria

return -1;
}
// Driver program
int main()
{
int arr[] = {5, 1, 4, 3, 6, 8, 10, 7, 9};
cout << "Index of the element is " << findElement(arr, n);
return 0;
}

Index of the element is 4.

discussed above
Succinct Encoding of Binary Tree
A succinct encoding of Binary Tree takes close to minimum possible space. The number of structurally
different binary trees on n nodes is n’th Catalan number. For large n, this is about 4n; thus we need at least
about log2 4 n = 2n bits to encode it. A succinct binary tree therefore would occupy 2n+o(n) bits.
One simple representation which meets this bound is to visit the nodes of the tree in preorder, outputting “1”
for an internal node and “0” for a leaf. If the tree contains data, we can simply simultaneously store it in a
consecutive array in preorder.
Below is algorithm for encoding:

function EncodeSuccinct(node n, bitstring structure, array data) {
if n = nil then
append 0 to structure;
else
append 1 to structure;
append n.data to data;
EncodeSuccinct(n.left, structure, data);
EncodeSuccinct(n.right, structure, data);
}

And below is algorithm for decoding

function DecodeSuccinct(bitstring structure, array data) {
remove first bit of structure and put it in b
if b = 1 then
create a new node n
remove first element of data and put it in n.data
n.left = DecodeSuccinct(structure, data)
n.right = DecodeSuccinct(structure, data)
return n
else
return nil
}

Source: https://en.wikipedia.org/wiki/Binary_tree#Succinct_encodings
Example:

Input:
10
/ \
20 30
/ \ \
40 50 70
Data Array (Contains preorder traversal)

10 20 40 50 30 70
Structure Array
1 1 1 0 0 1 0 0 1 0 1 0 0
1 indicates data and 0 indicates NULL

Below is C++ implementation of above algorithms.

// C++ program to demonstrate Succinct Tree Encoding and decoding

struct Node
{
int key;
};

{
temp->key = key;
return (temp);
}
// This function fills lists 'struc' and 'data'. 'struc' list

// stores structure information. 'data' list stores tree data
void EncodeSuccinct(Node *root, list<bool> &struc, list<int> &data)
{
// If root is NULL, put 0 in structure array and return
if (root == NULL)
{
struc.push_back(0);
return;
}
// Else place 1 in structure array, key in 'data' array

// and recur for left and right children
struc.push_back(1);
data.push_back(root->key);
EncodeSuccinct(root->left, struc, data);
EncodeSuccinct(root->right, struc, data);
}
// Constructs tree from 'struc' and 'data'

Node *DecodeSuccinct(list<bool> &struc, list<int> &data)
{
if (struc.size() <= 0)
if (struc.size() <= 0)
return NULL;
// Remove one item from from structure list

bool b = struc.front();
struc.pop_front();
// If removed bit is 1,
if (b == 1)
{
// remove an item from data list
int key = data.front();
data.pop_front();
// Create a tree node with the removed data

Node *root = newNode(key);
// And recur to create left and right subtrees

root->left = DecodeSuccinct(struc, data);
root->right = DecodeSuccinct(struc, data);
return root;
}
return NULL;
}
// A utility function to print tree

void preorder(Node* root)
{
if (root)
{
cout << "key: "<< root->key;
if (root->left)
cout << " | left child: " << root->left->key;
if (root->right)
cout << " | right child: " << root->right->key;
cout << endl;
}
}
// Driver program
int main()
{
cout << "Given Tree\n";

preorder(root);
list<bool> struc;
list<int> data;
EncodeSuccinct(root, struc, data);
cout << "\nEncoded Tree\n";

cout << "Structure List\n";
list<bool>::iterator si; // Structure iterator
for (si = struc.begin(); si != struc.end(); ++si)
cout << *si << " ";
cout << "\nData List\n";
list<int>::iterator di; // Data iIterator
for (di = data.begin(); di != data.end(); ++di)
cout << *di << " ";
Node *newroot = DecodeSuccinct(struc, data);
cout << "\n\nPreorder traversal of decoded tree\n";

preorder(newroot);
return 0;
}

Output:
Given Tree
key: 10 | left child: 20 | right child: 30
key: 40
key: 50
key: 30 | right child: 70
key: 70
Encoded Tree
Structure List
1 1 1 0 0 1 0 0 1 0 1 0 0
Data List
10 20 40 50 30 70
Preorder traversal of decoded tree

key: 40
key: 50
key: 30 | right child: 70
key: 70

This article is contribute by Shivam. Please write comments if you find anything incorrect, or you want to
Mirror of n-ary Tree
Given a Tree where every node contains variable number of children, convert the tree to its mirror. Below
diagram shows an example.
Node of tree is represented as a key and a variable sized array of children pointers. The idea is similar to
mirror of Binary Tree. For every node, we first recur for all of its children and then reverse array of children
pointers. We can also do these steps in other way, i.e., reverse array of children pointers first and then recur
for children.

// C++ program to mirror an n-ary tree
// Represents a node of an n-ary tree

struct Node
{
int key;
vector<Node *>child;
};
// Function to convert a tree to its mirror

void mirrorTree(Node * root)
{
// Base case: Nothing to do if root is NULL
if (root==NULL)
return;
// Number of children of root

int n = root->child.size();
// If number of child is less than 2 i.e.

// 0 or 1 we do not need to do anything
if (n < 2)
return;
// Calling mirror function for each child

mirrorTree(root->child[i]);
// Reverse vector (variable sized array) of child

// pointers
for (int i=0; i<n/2; i++)
{
Node *temp = root->child[i];
Node *temp = root->child[i];
root->child[i] = root->child[n-i-1];
root->child[n-i-1] = temp;
}
}

{
temp->key = key;
return temp;
}
// Prints the n-ary tree level wise

void printNodeLevelWise(Node * root)
{
if (root==NULL)
return;

// Create a queue and enqueue root to it
queue<Node *>q;
q.push(root);
// Do level order traversal. Two loops are used

// to make sure that different levels are printed
// in different lines
while (!q.empty())
{
int n = q.size();
while (n>0)
{
// Dequeue an item from queue and print it
Node * p = q.front();
q.pop();
cout << p->key << " ";
// Enqueue all childrent of the dequeued item

for (int i=0; i<p->child.size(); i++)
q.push(p->child[i]);
n--;
}
cout << endl; // Separator between levels

}
}
// Driver program
int main()
{
/* Let us create below tree
* 10
* / / \ \
* 2 34 56 100
* | / | \
* 1 7 8 9
*/
(root->child).push_back(newNode(2));
(root->child[2]->child).push_back(newNode(1));
cout << "Level order traversal Before Mirroring\n";

printNodeLevelWise(root);
mirrorTree(root);
cout << "\nLevel order traversal After Mirroring\n";

printNodeLevelWise(root);
return 0;
}

Output:

Level order traversal Before Mirroring
10
2 34 56 100
1 7 8 9
Level order traversal After Mirroring

10
100 56 34 2
9 8 7 1

Thanks to Nitin Agrawal for providing initial implementation. Please write comments if you find anything
Reverse an array without affecting special characters
Given a string, that contains special character together with alphabets (‘a’ to ‘z’ and ‘A’ to ‘Z’), reverse the
string in a way that special characters are not affected.
Examples:

Input: str = "a,b$c"
Output: str = "c,b$a"
Note that $ and , are not moved anywhere.
Only subsequence "abc" is reversed
Input: str = "Ab,c,de!$"

Output: str = "ed,c,bA!$"

Simple Solution:
1) Create a temporary character array say temp[].
2) Copy alphabetic characters from given array to temp[].
3) Reverse temp[] using standard string reversal algorithm.
4) Now traverse input string and temp in a single loop. Wherever there is alphabetic character is input
string, replace it with current character of temp[].
Efficient Solution:
Time complexity of above solution is O(n), but it requires extra space and it does two traversals of input
string.
We can reverse with one traversal and without extra space. Below is algorithm.

1) Let input string be 'str[]' and length of string be 'n'
2) l = 0, r = n-1
3) While l is smaller than r, do following
a) If str[l] is not an alphabetic character, do l++
b) Else If str[r] is not an alphabetic character, do r--
c) Else swap str[l] and str[r]


// C++ program to reverse a string with special characters
// Returns true if x is an aplhabatic character, false otherwise

bool isAlphabet(char x)
{
return ( (x >= 'A' && x <= 'Z') ||
(x >= 'a' && x <= 'z') );
}
void reverse(char str[])

{
// Initialize left and right pointers
int r = strlen(str) - 1, l = 0;
// Traverse string from both ends until

// 'l' and 'r'
while (l < r)
{
// Ignore special characters
if (!isAlphabet(str[l]))
l++;
else if(!isAlphabet(str[r]))
r--;
else // Both str[l] and str[r] are not spacial

{
swap(str[l], str[r]);
l++;
r--;
}
}
}
// Driver program
int main()
{
char str[] = "a!!!b.c.d,e'f,ghi";
cout << "Input string: " << str << endl;
reverse(str);
cout << "Output string: " << str << endl;
return 0;
}

Output:

Input string: a!!!b.c.d,e'f,ghi
Output string: i!!!h.g.f,e'd,cba

Thanks to anonymous user for suggesting above solution here.
discussed above
Minimum number of bracket reversals needed to make an expression
balanced
Given an expression with only ‘}’ and ‘{‘. The expression may not be balanced. Find minimum number of
bracket reversals to make the expression balanced.
Examples:

Input: exp = "}{"
Output: 2
We need to change '}' to '{' and '{' to
'}' so that the expression becomes balanced,
the balanced expression is '{}'
Input: exp = "{{{"

Output: Can't be made balanced using reversals
Input: exp = "{{{{"

Output: 2
Input: exp = "{{{{}}"

Output: 1
Input: exp = "}{{}}{{{"

Output: 3

One simple observation is, the string can be balanced only if total number of brackets is even (there must be
equal no of ‘{‘ and ‘}’)
A Naive Solution is to consider every bracket and recursively count number of reversals by taking two
cases (i) keeping the bracket as it is (ii) reversing the bracket. If we get a balanced expression, we update
result if number of steps followed for reaching here is smaller than the minimum so far. Time complexity of
this solution is O(2n).
An Efficient Solution can solve this problem in O(n) time. The idea is to first remove all balanced part of
expression. For example, convert “}{{}}{{{” to “}{{{” by removing highlighted part. If we take a closer look,
we can notice that, after removing balanced part, we always end up with an expression of the form }}…}{{…{,
an expression that contains 0 or more number of closing brackets followed by 0 or more numbers of opening
brackets.
How many minimum reversals are required for an expression of the form “}}..}{{..{” ?. Let m be the total
number of closing brackets and n be the number of opening brackets. We need m/2 + n/2
reversals. For example }}}}{{ requires 2+1 reversals.

// C++ program to find minimum number of
// reversals required to balance an expression
// Returns count of minimum reversals for making

// expr balanced. Returns -1 if expr cannot be
// balanced.
// balanced.
int countMinReversals(string expr)
{
int len = expr.length();
// length of expression must be even to make

// it balanced by using reversals.
if (len%2)
return -1;
// After this loop, stack contains unbalanced

// part of expression, i.e., expression of the
// form "}}..}{{..{"
stack<char> s;
for (int i=0; i<len; i++)
{
if (expr[i]=='}' && !s.empty())
{
if (s.top()=='{')
s.pop();
else
s.push(expr[i]);
}
else
s.push(expr[i]);
}
// Length of the reduced expression

// red_len = (m+n)
int red_len = s.size();
// count opening brackets at the end of

// stack
int n = 0;
while (!s.empty() && s.top() == '{')
{
s.pop();
n++;
}
// return ceil(m/2) + ceil(n/2) which is

// actually equal to (m+n)/2 + n%2 when
// m+n is even.
return (red_len/2 + n%2);
}
// Driver program to test above f

int main()
{
string expr = "}}{{";
cout << countMinReversals(expr);
return 0;
}

Output:

Thanks to Utkarsh Trivedi for suggesting above approach here.
discussed above
Check if a given Binary Tree is Heap
Given a binary tree we need to check it has heap property or not, Binary tree need to fulfill following two
conditions for being a heap –
1. It should be a complete tree (i.e. all levels except last should be full).
2. Every node’s value should be greater than or equal to its child node (considering max-heap).
For example this tree contains heap property –
While this doesn’t –
We check each of the above condition separately, for checking completeness isComplete and for checking
heap isHeapUtil function are written.
Detail about isComplete function can be found here.
isHeapUtil function is written considering following things –
1. Every Node can have 2 children, 0 child (last level nodes) or 1 child (there can be at most one such
node).
2. If Node has No child then it’s a leaf node and return true (Base case)
3. If Node has one child (it must be left child because it is a complete tree) then we need to compare this
node with its single child only.
4. If Node has both child then check heap property at Node at recur for both subtrees.
Complete code.
Below is C implementation.

/* C program to checks if a binary tree is max heap ot not */
/* C program to checks if a binary tree is max heap ot not */
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>

struct Node
{
int key;
struct Node *left;
struct Node *right;
};
/* Helper function that allocates a new node */

struct Node *newNode(int k)
{
node->key = k;
return node;
}
/* This function counts the number of nodes in a binary tree */

unsigned int countNodes(struct Node* root)
{
if (root == NULL)
return (0);
return (1 + countNodes(root->left) + countNodes(root->right));
}
/* This function checks if the binary tree is complete or not */

bool isCompleteUtil (struct Node* root, unsigned int index,
unsigned int number_nodes)
{
// An empty tree is complete
if (root == NULL)
return (true);
// If index assigned to current node is more than

// number of nodes in tree, then tree is not complete
if (index >= number_nodes)
return (false);

return (isCompleteUtil(root->left, 2*index + 1, number_nodes) &&
isCompleteUtil(root->right, 2*index + 2, number_nodes));
}
// This Function checks the heap property in the tree.

bool isHeapUtil(struct Node* root)
{
// Base case : single node satisfies property
return (true);
// node will be in second last level

if (root->right == NULL)
{
// check heap property at Node
// No recursive call , because no need to check last level
return (root->key >= root->left->key);
}
else
{
// Check heap property at Node and
// Check heap property at Node and
// Recursive check heap property at left and right subtree
if (root->key >= root->left->key &&
root->key >= root->right->key)
return ((isHeapUtil(root->left)) &&
(isHeapUtil(root->right)));
else
return (false);
}
}
// Function to check binary tree is a Heap or Not.

bool isHeap(struct Node* root)
{
// These two are used in isCompleteUtil()
unsigned int node_count = countNodes(root);
unsigned int index = 0;
if (isCompleteUtil(root, index, node_count) && isHeapUtil(root))

return true;
return false;
}
// Driver program
int main()
{
root = newNode(10);
if (isHeap(root))
printf("Given binary tree is a Heap\n");
else
printf("Given binary tree is not a Heap\n");
return 0;
}

Output:

Given binary tree is a Heap

This article is contributed by Utkarsh Trivedi. Please write comments if you find anything incorrect, or you
Reorder a array according to given indexes
Given two integer arrays of same size, “arr[]” and “index[]”, reorder elements in “arr[]” according to given
index array. It is not allowed to given array arr’s length.
Example:

Input: arr[] = [10, 11, 12];
index[] = [1, 0, 2];
Output: arr[] = [11, 10, 12]
index[] = [0, 1, 2]
Input: arr[] = [50, 40, 70, 60, 90]

index[] = [3, 0, 4, 1, 2]
Output: arr[] = [40, 60, 90, 50, 70]
index[] = [0, 1, 2, 3, 4]

Expected time complexity O(n) and auxiliary space O(1)
A Simple Solution is to use an auxiliary array temp[] of same size as given arrays. Traverse the given array
and put all elements at their correct place in temp[] using index[]. Finally copy temp[] to arr[] and set all
values of index[i] as i.

// C++ program to sort an array according to given
// indexes
#include<iostream>
// Function to reorder elements of arr[] according

// to index[]
void reorder(int arr[], int index[], int n)
{
int temp[n];
// arr[i] should be present at index[i] index

temp[index[i]] = arr[i];
// Copy temp[] to arr[]

{
arr[i] = temp[i];
index[i] = i;
}
}
// Driver program
int main()
{
int arr[] = {50, 40, 70, 60, 90};
int index[] = {3, 0, 4, 1, 2};
reorder(arr, index, n);
cout << "Reordered array is: \n";

cout << arr[i] << " ";
cout << "\nModified Index array is: \n";

cout << index[i] << " ";
return 0;
}

Output:

Reordered array is:
40 60 90 50 70
Modified Index array is:
0 1 2 3 4

Thanks to gccode for suggesting above solution.
We can solve it Without Auxiliary Array. Below is algorithm.

1) Do following for every element arr[i]
a) While index[i] is not equal to i
(i) Store array and index values of the target (or
correct) position where arr[i] should be placed.
The correct position for arr[i] is index[i]
(ii) Place arr[i] at its correct position. Also
update index value of correct position.
(iii) Copy old values of correct position (Stored in
step (i)) to arr[i] and index[i] as the while
loop continues for i.


// A O(n) time and O(1) extra space C++ program to
// sort an array according to given indexes
#include<iostream>
// Function to reorder elements of arr[] according

// to index[]
void reorder(int arr[], int index[], int n)
{
// Fix all elements one by one
{
// While index[i] and arr[i] are not fixed
while (index[i] != i)
{
// Store values of the target (or correct)
// position before placing arr[i] there
int oldTargetI = index[index[i]];
char oldTargetE = arr[index[i]];
// Place arr[i] at its target (or correct)

// position. Also copy corrected index for
// new position
arr[index[i]] = arr[i];
index[index[i]] = index[i];
// Copy old target values to arr[i] and

// index[i]
index[i] = oldTargetI;
arr[i] = oldTargetE;
}
}
}
// Driver program
int main()
{
int arr[] = {50, 40, 70, 60, 90};
int index[] = {3, 0, 4, 1, 2};
reorder(arr, index, n);
cout << "Reordered array is: \n";

cout << arr[i] << " ";
cout << "\nModified Index array is: \n";

cout << index[i] << " ";
return 0;
}

Output:

Reordered array is:
40 60 90 50 70
Modified Index array is:
0 1 2 3 4

Thanks to shyamala_lokre for suggesting above solution.
discussed above
Check if a given array can represent Preorder Traversal of Binary Search
Tree
Given an array of numbers, return true if given array can represent preorder traversal of a Binary Search
Tree, else return false. Expected time complexity is O(n).
Examples:

Input: pre[] = {2, 4, 3}
Output: true
Given array can represent preorder traversal
of below tree
2
\
4
/
3
Input: pre[] = {2, 4, 1}

Output: false
Given array cannot represent preorder traversal
of a Binary Search Tree.
Input: pre[] = {40, 30, 35, 80, 100}

Output: true
Given array can represent preorder traversal
of below tree
40
/ \
30 80
\ \
35 100
Input: pre[] = {40, 30, 35, 20, 80, 100}

Output: false
Given array cannot represent preorder traversal
of a Binary Search Tree.

A Simple Solution is to do following for every node pre[i] starting from first one.

1) Find the first greater value on right side of current node.
Let the index of this node be j. Return true if following
conditions hold. Else return false
(i) All values after the above found greater value are
greater than current node.
(ii) Recursive calls for the subarrays pre[i+1..j-1] and
pre[j+1..n-1] also return true.

Time Complexity of the above solution is O(n2)
An Efficient Solution can solve this problem in O(n) time. The idea is to use a stack. This problem is
similar to Next (or closest) Greater Element problem. Here we find next greater element and after finding
next greater, if we find a smaller element, then return false.

1) Create an empty stack.
2) Initialize root as INT_MIN.
3) Do following for every element pre[i]
a) If pre[i] is greater than current root, return false.
b) Keep removing elements from stack while pre[i] is greater
then stack top. Make the last removed item as new root (to
be compared next).
At this point, pre[i] is greater than the removed root
(That is why if we see a smaller element in step a), we
return false)
c) push pre[i] to stack (All elements in stack are in decreasing
order)


// C++ program for an efficient solution to check if
// a given array can represent Preorder traversal of
// a Binary Search Tree
bool canRepresentBST(int pre[], int n)

{
// Create an empty stack
stack<int> s;
// Initialize current root as minimum possible

// value
int root = INT_MIN;
// Traverse given array

{
// If we find a node who is on right side
// and smaller than root, return false
if (pre[i] < root)
return false;
// If pre[i] is in right subtree of stack top,

// Keep removing items smaller than pre[i]
// and make the last removed item as new
// root.
while (!s.empty() && s.top()<pre[i])
{
root = s.top();
s.pop();
}
// At this point either stack is empty or

// pre[i] is smaller than root, push pre[i]
s.push(pre[i]);
}
return true;
}
// Driver program
int main()
{
int pre1[] = {40, 30, 35, 80, 100};
int n = sizeof(pre1)/sizeof(pre1[0]);
canRepresentBST(pre1, n)? cout << "true\n":
cout << "false\n";
int pre2[] = {40, 30, 35, 20, 80, 100};

n = sizeof(pre2)/sizeof(pre2[0]);
canRepresentBST(pre2, n)? cout << "true\n":
cout << "false\n";
return 0;
}

Output:

true
false

This article is contributed by Romil Punetha. Please write comments if you find anything incorrect, or you
Find the maximum subarray XOR in a given array
Given an array of integers. find the maximum XOR subarray value in given array. Expected time complexity
O(n).
Examples:

Input: arr[] = {1, 2, 3, 4}
Output: 7
The subarray {3, 4} has maximum XOR value
Input: arr[] = {8, 1, 2, 12, 7, 6}

Output: 15
The subarray {1, 2, 12} has maximum XOR value
Input: arr[] = {4, 6}

Output: 6
The subarray {6} has maximum XOR value

A Simple Solution is to use two loops to find XOR of all subarrays and return the maximum.

// A simple C++ program to find max subarray XOR
int maxSubarrayXOR(int arr[], int n)

{
int ans = INT_MIN; // Initialize result
// Pick starting points of subarrays

{
int curr_xor = 0; // to store xor of current subarray
// Pick ending points of subarrays starting with i

for (int j=i; j<n; j++)
{
curr_xor = curr_xor ^ arr[j];
ans = max(ans, curr_xor);
}
}
return ans;
}

int main()
{
int arr[] = {8, 1, 2, 12};
cout << "Max subarray XOR is " << maxSubarrayXOR(arr, n);
return 0;
}

Output:

Max subarray XOR is 15

Time Complexity of above solution is O(n2).
An Efficient Solution can solve the above problem in O(n) time under the assumption that integers take
fixed number of bits to store. The idea is to use Trie Data Structure. Below is algorithm.

1) Create an empty Trie. Every node of Trie is going to
contain two children, for 0 and 1 value of bit.
2) Initialize pre_xor = 0 and insert into the Trie.
3) Initialize result = minus infinite
4) Traverse the given array and do following for every
array element arr[i].
a) pre_xor = pre_xor ^ arr[i]
pre_xor now contains xor of elements from
arr[0] to arr[i].
b) Query the maximum xor value ending with arr[i]
from Trie.
c) Update result if the value obtained in step
4.b is more than current value of result.

How does 4.b work?

We can observe from above algorithm that we build a Trie that contains XOR of all prefixes of given array. To
find the maximum XOR subarray ending with arr[i], there may be two cases.
i) The prefix itself has the maximum XOR value ending with arr[i]. For example if i=2 in {8, 2, 1, 12}, then
the maximum subarray xor ending with arr[2] is the whole prefix.
ii) We need to remove some prefix (ending at index from 0 to i-1). For example if i=3 in {8, 2, 1, 12}, then the
maximum subarray xor ending with arr[3] starts with arr[1] and we need to remove arr[0].
To find the prefix to be removed, we find the entry in Trie that has maximum XOR value with current prefix.
If we do XOR of such previous prefix with current prefix, we get the maximum XOR value ending with arr[i].
If there is no prefix to be removed (case i), then we return 0 (that’s why we inserted 0 in Trie).

// C++ program for a Trie based O(n) solution to find max
// subarray XOR
// Assumed int size

#define INT_SIZE 32
// A Trie Node
struct TrieNode
{
int value; // Only used in leaf nodes
TrieNode *arr[2];
};
// Utility function tp create a Trie node

TrieNode *newNode()
{
TrieNode *temp = new TrieNode;
TrieNode *temp = new TrieNode;
temp->value = 0;
temp->arr[0] = temp->arr[1] = NULL;
return temp;
}
// Inserts pre_xor to trie with given root

void insert(TrieNode *root, int pre_xor)
{
TrieNode *temp = root;
// Start from the msb, insert all bits of

// pre_xor into Trie
for (int i=INT_SIZE-1; i>=0; i--)
{
// Find current bit in given prefix
bool val = pre_xor & (1<<i);
// Create a new node if needed

if (temp->arr[val] == NULL)
temp->arr[val] = newNode();
temp = temp->arr[val];
}
// Store value at leaf node

temp->value = pre_xor;
}
// Finds the maximum XOR ending with last number in

// prefix XOR 'pre_xor' and returns the XOR of this maximum
// with pre_xor which is maximum XOR ending with last element
// of pre_xor.
int query(TrieNode *root, int pre_xor)
{
TrieNode *temp = root;
for (int i=INT_SIZE-1; i>=0; i--)
{
// Find current bit in given prefix
bool val = pre_xor & (1<<i);
// Traverse Trie, first look for a

// prefix that has opposite bit
if (temp->arr[1-val]!=NULL)
temp = temp->arr[1-val];
// If there is no prefix with opposite

// bit, then look for same bit.
else if (temp->arr[val] != NULL)
temp = temp->arr[val];
}
return pre_xor^(temp->value);
}
// Returns maximum XOR value of a subarray in arr[0..n-1]

int maxSubarrayXOR(int arr[], int n)
{
// Create a Trie and insert 0 into it
TrieNode *root = newNode();
insert(root, 0);
// Initialize answer and xor of current prefix

int result = INT_MIN, pre_xor =0;
// Traverse all input array element

// Traverse all input array element
{
// update current prefix xor and insert it into Trie
pre_xor = pre_xorârr[i];
insert(root, pre_xor);
// Query for current prefix xor in Trie and update

// result if required
result = max(result, query(root, pre_xor));
}
return result;
}

int main()
{
int arr[] = {8, 1, 2, 12};
cout << "Max subarray XOR is " << maxSubarrayXOR(arr, n);
return 0;
}

Output:

Max subarray XOR is 15

Exercise: Extend the above solution so that it also prints starting and ending indexes of subarray with
maximum value (Hint: we can add one more field to Trie node to achieve this)
This article is contributed by Romil Punetha. Please write comments if you find anything incorrect, or you
Count number of subsets of a set with GCD equal to a given number
Given a set of positive integer elements, find count of subsets with GCDs equal to given numbers.
Examples:

Input: arr[] = {2, 3, 4}, gcd[] = {2, 3}
Output: Number of subsets with gcd 2 is 2
Number of subsets with gcd 3 is 1
The two subsets with GCD equal to 2 are {2} and {2, 4}.
The one subset with GCD equal to 3 ss {3}.
Input: arr[] = {6, 3, 9, 2}, gcd = {3, 2}

Output: Number of subsets with gcd 3 is 5
The five subsets with GCD equal to 3 are {3}, {6, 3},
{3, 9}, {6, 9) and {6, 3, 9}.
The two subsets with GCD equal to 2 are {2} and {2, 6}

A Simple Solution is to generate all subsets of given set and find GCD of every subset.
Below is an Efficient Solution For small numbers, i,e, the maximum of all numbers is not very high.

1) Find the maximum number of given numbers. Let the
maximum be arrMax.
2) Count occurrences of all numbers using a hash. Let
this hash be 'freq'
3) The maximum possible GCD can be arrMax. Run a loop
for i = arrMax to 1
a) Count number of subsets for current GCD.
4) Now we have counts for all possible GCDs, return
count for given gcds.

How does step 3.b work?

How to get number of subsets for a given GCD ‘i’ where i lies in range from 1 to arrMax. The idea is to count
all multiples of i using ‘freq’ built in step 2. Let there be ‘add’ multiples of i. The number of all possible
subsets with ‘add’ numbers would be “pow(2, add) – 1″, excluding the empty set. For example, if given array
is {2, 3, 6} and i = 3, there are 2 multiples of 3 (3 and 6). So there will be 3 subsets {3}, {3, 6} and {6} which
have a multiple of i as GCD. These subsets also include {6} which doesn’t have 3 as GCD, but a multiple of 3.
So we need to subtract such subsets. We store subset counts for every GCD in another hash map ‘subset’. Let
‘sub’ be the number of subsets which have multiple of ‘i’ as GCD. The value of ‘sub’ for any multiple of ‘i’ can
directly be obtained from subset[] as we are evaluating counts from arrMax to 1.

// C++ program to count number of subsets with given GCDs
// n is size of arr[] and m is sizeof gcd[]

void ccountSubsets(int arr[], int n, int gcd[], int m)
{
// Map to store frequency of array elements
// Map to store frequency of array elements
map<int, int> freq;
// Map to store number of subsets with given gcd

map<int, int> subsets;
// Initialize maximum element. Assumption: all array

// elements are positive.
int arrMax = 0;
// Find maximum element in array and fill frequency

// map.
{
arrMax = max(arrMax, arr[i]);
freq[arr[i]]++;
}
// Run a loop from max element to 1 to find subsets

// with all gcds
for (int i=arrMax; i>=1; i--)
{
int sub = 0;
int add = freq[i];
// Run a loop for all multiples of i

for (int j = 2; j*i <= arrMax; j++)
{
// Sum the frequencies of every element which
// is a multiple of i
add += freq[j*i];
// Excluding those subsets which have gcd > i but

// not i i.e. which have gcd as multiple of i in
// the subset for ex: {2,3,4} cnsidering i = 2 and
// subset we need to exclude are those havng gcd as 4
sub += subsets[j*i];
}

// Number of subsets with GCD equal to 'i' is pow(2, add)
// - 1 - sub
subsets[i] = (1<<add) - 1 - sub;
}

cout << "Number of subsets with gcd " << gcd[i] << " is "
<< subsets[gcd[i]] << endl;
}
// Driver program
int main()
{
int gcd[] = {2, 3};
int arr[] = {9, 6, 2};
int m = sizeof(gcd)/sizeof(gcd[0]);
ccountSubsets(arr, n, gcd, m);
return 0;
}

Output:


Exercise: Extend the above solution so that all calculations are done under modulo 1000000007 to avoid
overflows.
Modular Exponentiation (Power in Modular Arithmetic)
Given three numbers x, y and p, compute (xy) % p.
Examples

Input: x = 2, y = 3, p = 5
Output: 3
Explanation: 2^3 % 5 = 8 % 5 = 3.
Input: x = 2, y = 5, p = 13
Output: 6
Explanation: 2^5 % 13 = 32 % 13 = 6.

We have discussed recursive and iterative solutions for power.
Below is discussed iterative solution.

/* Iterative Function to calculate (x^y) in O(logy) */
int power(int x, unsigned int y)
{

while (y > 0)
{
// If y is odd, multiply x with result
if (y & 1)
res = res*x;

// n must be even now
y = y>>1; // y = y/2
x = x*x; // Change x to x^2
}
return res;
}

The problem with above solutions is, overflow may occur for large value of n or x. Therefore, power is
generally evaluated under modulo of a large number.
Below is the fundamental modular property that is used for efficiently computing power under modular
arithmetic.

(x mod p) (y mod p) ≡ (xy) mod p
or equivalently
( (x mod p) (y mod p) ) mod p = (xy) mod p
For example x = 50, y = 100, p = 13

50 mod 13 = 11
100 mod 13 = 9
11*9 ≡ 1500 mod 13

or
11*9 mod 13 = 1500 mod 13

Below is C implementation based on above property.

// Iterative C program to compute modular power
#include <stdio.h>
/* Iterative Function to calculate (x^n)%p in O(logy) */

int power(int x, unsigned int y, int p)
{
x = x % p; // Update x if it is more than or

// equal to p
while (y > 0)
{
if (y & 1)
res = (res*x) % p;
// y must be even now

y = y>>1; // y = y/2
x = (x*x) % p;
}
return res;
}

int main()
{
int x = 2;
int y = 5;
int p = 13;
printf("Power is %u", power(x, y, p));
return 0;
}

Output:

Power is 6

Check if an array can be divided into pairs whose sum is divisible by k
Given an array of integers and a number k, write a function that returns true if given array can be divided
into pairs such that sum of every pair is divisible by k.
Examples:

Input: arr[] = {9, 7, 5, 3}, k = 6
Output: True
We can divide array into (9, 3) and (7, 5).
Sum of both of these pairs is a multiple of 6.
Input: arr[] = {92, 75, 65, 48, 45, 35}, k = 10

Output: True
We can divide array into (92, 48), (75, 65) and
(45, 35). Sum of all these pairs is a multiple of 10.
Input: arr[] = {91, 74, 66, 48}, k = 10

Output: False

A Simple Solution is to iterate through every element arr[i]. Find if there is another not yet visited
element that has remainder as (k – arr[i]%k). If there is no such element, return false. If a pair is found, then
mark both elements as visited. Time complexity of this solution is O(n 2 and it requires O(n) extra space.
An Efficient Solution is to use Hashing.

1) If length of given array is odd, return false. An odd
length array cannot be divided in pairs.
2) Traverse input array array and count occurrences of
all remainders.
freq[arr[i] % k]++
3) Traverse input array again.
a) Find remainder of current element.
b) If remainder divides k into two halves, then
there must be even occurrences of it as it forms
pair with itself only.
c) Else, number of occurrences of current remainder
must be equal to number of occurrences of "k -
current remainder".

Time complexity of above algorithm is O(n).
Below implementation uses map in C++ STL. The map is typically implemented using Red-Black Tree and
takes O(Log n) time for access. Therefore time complexity of below implementation is O(n Log n), but the
algorithm can be easily implemented in O(n) time using hash table.

// A C++ program to check if arr[0..n-1] can be divided
// in pairs such that every pair is divisible by k.
// Returns true if arr[0..n-1] can be divided into pairs

// with sum equal to k.
bool canPairs(int arr[], int n, int k)
{
// An odd length array cannot be divided into pairs
if (n & 1)
return false;
// Create a frequency array to count occurrences

// of all remainders when divided by k.
map<int, int> freq;
// Count occurrences of all remainders

for (int i = 0; i < n; i++)
freq[arr[i] % k]++;
// Traverse input array and use freq[] to decide

// if given array can be divided in pairs
for (int i = 0; i < n; i++)
{
// Remainder of current element
int rem = arr[i] % k;
// If remainder with current element divides

// k into two halves.
if (2*rem == k)
{
// Then there must be even occurrences of
// such remainder
if (freq[rem] % 2 != 0)
return false;
}
// Else number of occurrences of remainder

// must be equal to number of occurrences of
// k - remainder
else if (freq[rem] != freq[k - rem])
return false;
}
return true;
}

int main()
{
int arr[] = {92, 75, 65, 48, 45, 35};
int k = 10;
canPairs(arr, n, k)? cout << "True": cout << "False";
return 0;
}

Output:

True

This article is contributed by Priyanka. Please write comments if you find anything incorrect, or you want
Collect maximum coins before hitting a dead end
Given a character matrix where every cell has one of the following values.

'C' --> This cell has coin
'#' --> This cell is a blocking cell.

We can not go anywhere from this.
'E' --> This cell is empty. We don't get

a coin, but we can move from here.

Initial position is cell (0, 0) and initial direction is right.
Following are rules for movements across cells.
If face is Right, then we can move to below cells
1. Move one step ahead, i.e., cell (i, j+1) and direction remains right.
2. Move one step down and face left, i.e., cell (i+1, j) and direction becomes left.
If face is Left, then we can move to below cells
1. Move one step ahead, i.e., cell (i, j-1) and direction remains left.
2. Move one step down and face right, i.e., cell (i, j-1) and direction becomes right.
Final position can be anywhere and final direction can also be anything. The target is to collect
maximum coins.
Example:
The above problem can be recursively defined as below:

maxCoins(i, j, d): Maximum number of coins that can be
collected if we begin at cell (i, j)
and direction d.
d can be either 0 (left) or 1 (right)
// If this is a blocking cell, return 0. isValid() checks

// if i and j are valid row and column indexes.
If (arr[i][j] == '#' or isValid(i, j) == false)
return 0
If (arr[i][j] == 'C')
result = 1;
Else
result = 0;
If (d == 0) // Left direction
return result + max(maxCoins(i+1, j, 1), // Down
maxCoins(i, j+1, 0)); // Ahead in left
If (d == 1) // Right direction
return result + max(maxCoins(i+1, j, 1), // Down
maxCoins(i, j-1, 0)); // Ahead in right

Below is C++ implementation of above recursive algorithm.

// A Naive Recursive C++ program to find maximum number of coins
// that can be collected before hitting a dead end
#define R 5
#define C 5
// to check whether current cell is out of the grid or not

bool isValid(int i, int j)
{
return (i >=0 && i < R && j >=0 && j < C);
}
// dir = 0 for left, dir = 1 for facing right. This function returns
// number of maximum coins that can be collected starting from (i, j).
int maxCoinsRec(char arr[R][C], int i, int j, int dir)
{
// If this is a invalid cell or if cell is a blocking cell
if (isValid(i,j) == false || arr[i][j] == '#')
return 0;
// Check if this cell contains the coin 'C' or if its empty 'E'.
int result = (arr[i][j] == 'C')? 1: 0;
// Get the maximum of two cases when you are facing right in this cell
if (dir == 1) // Direction is right
return result + max(maxCoinsRec(arr, i+1, j, 0), // Down
maxCoinsRec(arr, i, j+1, 1)); // Ahead in right
// Direction is left
// Get the maximum of two cases when you are facing left in this cell
return result + max(maxCoinsRec(arr, i+1, j, 1), // Down
maxCoinsRec(arr, i, j-1, 0)); // Ahead in left
}

int main()
{
char arr[R][C] = { {'E', 'C', 'C', 'C', 'C'},
{'C', '#', 'C', '#', 'E'},
{'#', 'C', 'C', '#', 'C'},
{'C', 'E', 'E', 'C', 'E'},
{'C', 'E', '#', 'C', 'E'}
};
// As per the question initial cell is (0, 0) and direction is

// right
cout << "Maximum number of collected coins is "
<< maxCoinsRec(arr, 0, 0, 1);
return 0;
}

Output:

Maximum number of collected coins is 8

The time complexity of above solution recursive is exponential. We can solve this problem in
Polynomial Time using Dynamic Programming. The idea is to use a 3 dimensional table dp[R][C][k]
where R is number of rows, C is number of columns and d is direction. Below is Dynamic
Programming based C++ implementation.

// A Dynamic Programming based C++ program to find maximum
// number of coins that can be collected before hitting a
// dead end
#define R 5
#define C 5
// to check whether current cell is out of the grid or not

bool isValid(int i, int j)
{
return (i >=0 && i < R && j >=0 && j < C);
}
// dir = 0 for left, dir = 1 for right. This function returns

// number of maximum coins that can be collected starting from
// (i, j).
int maxCoinsUtil(char arr[R][C], int i, int j, int dir,
int dp[R][C][2])
{
// If this is a invalid cell or if cell is a blocking cell
if (isValid(i,j) == false || arr[i][j] == '#')
return 0;
// If this subproblem is already solved than return the

// already evaluated answer.
if (dp[i][j][dir] != -1)
return dp[i][j][dir];
// Check if this cell contains the coin 'C' or if its 'E'.

dp[i][j][dir] = (arr[i][j] == 'C')? 1: 0;
// Get the maximum of two cases when you are facing right
// in this cell
if (dir == 1) // Direction is right
dp[i][j][dir] += max(maxCoinsUtil(arr, i+1, j, 0, dp), // Down
maxCoinsUtil(arr, i, j+1, 1, dp)); // Ahead in rught
// Get the maximum of two cases when you are facing left
// in this cell
if (dir == 0) // Direction is left
dp[i][j][dir] += max(maxCoinsUtil(arr, i+1, j, 1, dp), // Down
maxCoinsUtil(arr, i, j-1, 0, dp)); // Ahead in left
// return the answer

return dp[i][j][dir];
}
// This function mainly creates a lookup table and calls

// maxCoinsUtil()
int maxCoins(char arr[R][C])
{
// Create lookup table and initialize all values as -1
int dp[R][C][2];
// As per the question initial cell is (0, 0) and direction

// As per the question initial cell is (0, 0) and direction
// is right
return maxCoinsUtil(arr, 0, 0, 1, dp);
}

int main()
{
char arr[R][C] = { {'E', 'C', 'C', 'C', 'C'},
{'C', '#', 'C', '#', 'E'},
{'#', 'C', 'C', '#', 'C'},
{'C', 'E', 'E', 'C', 'E'},
{'C', 'E', '#', 'C', 'E'}
};
cout << "Maximum number of collected coins is "

<< maxCoins(arr);
return 0;
}

Output:

Maximum number of collected coins is 8

Time Complexity of above solution is O(R x C x d). Since d is 2, time complexity can be written as O(R
x C).
Please write comments if you find anything incorrect, or you want to share more information about
Find Next Sparse Number
A number is Sparse if there are no two adjacent 1s in its binary representation. For example 5 (binary
representation: 101) is sparse, but 6 (binary representation: 110) is not sparse.
Given a number x, find the smallest Sparse number which greater than or equal to x.
Examples:

Input: x = 6
Output: Next Sparse Number is 8
Input: x = 4
Input: x = 38
Input: x = 44

A Simple Solution is to do following:

1) Write a utility function isSparse(x) that takes a number
and returns true if x is sparse, else false. This function
can be easily written by traversing the bits of input number.
2) Start from x and do following
while(1)
{
if (isSparse(x))
return x;
else
x++
}

Time complexity of isSparse() is O(Log x). Time complexity of this solution is O(x Log x). The next sparse
number can be at most O(x) distance away.
Thanks to kk_angel for suggesting above solution.
An Efficient Solution can solve this problem without checking all numbers on by one. Below are steps.

1) Find binary of the given number and store it in a
boolean array.
2) Initialize last_finalized bit position as 0.
2) Start traversing the binary from least significant bit.
a) If we get two adjacent 1's such that next (or third)
bit is not 1, then
(i) Make all bits after this 1 to last finalized
bit (including last finalized) as 0.
(ii) Update last finalized bit as next bit.

For example, let binary representation be 01010001011101, we change it to 01010001100000 (all bits after
highlighted 11 are set to 0). Again two 1’s are adjacent, so change binary representation to
01010010000000. This is our final answer.
Below is C++ implementation of above solution.

// C++ program to find next sparse number
int nextSparse(int x)
{
// Find binary representation of x and store it in bin[].
// bin[0] contains least significant bit (LSB), next
// bit is in bin[1], and so on.
vector<bool> bin;
while (x != 0)
{
bin.push_back(x&1);
x >>= 1;
}
// There my be extra bit in result, so add one extra bit

bin.push_back(0);
int n = bin.size(); // Size of binary representation
// The position till which all bits are finalized

int last_final = 0;
// Start from second bit (next to LSB)

{
// If current bit and its previous bit are 1, but next
// bit is not 1.
if (bin[i] == 1 && bin[i-1] == 1 && bin[i+1] != 1)
{
// Make the next bit 1
bin[i+1] = 1;
// Make all bits before current bit as 0 to make

// sure that we get the smallest next number
for (int j=i; j>=last_final; j--)
bin[j] = 0;
// Store position of the bit set so that this bit

// and bits before it are not changed next time.
last_final = i+1;
}
}
// Find decimal equivalent of modified bin[]

int ans = 0;
ans += bin[i]*(1<<i);
return ans;
}
// Driver program
int main()
{
int x = 38;
cout << "Next Sparse Number is " << nextSparse(x);
return 0;
}

Output:

Next Sparse Number is 40

Time complexity of this solution is O(Log x).
Thanks to gccode for suggesting above solution here.
discussed above.
Find the most frequent digit without using array/string
Given an integer, find the most occurring digit in it. If two or more digits occur same number of times, then
return the highest of them. Input integer is given as an int variable, not as a string or array. Use of hash or
array or string is not allowed.
Example:

Input: x = 12234
Output: The most frequent digit is 2
Input: x = 1223377
Input: x = 5
Input: x = 1000

We could create a map of size 10 and store count of all digits, but use of any array/string is not allowed.
The idea is simple, we write a function that counts occurrences of a given digit in a given integer. Then we
count all digits from 0 to 9 in given integer. We keep updating maximum count whenever count becomes
more or same as previous count. Below is C++ implementation.

// Finds maximum occurring digit without using any array/string
#include <iostream>
// Simple function to count occurrences of digit d in x

int countOccurrences(long int x, int d)
{
int count = 0; // Initialize count of digit d
while (x)
{
// Increment count if current digit is same as d
if (x%10 == d)
count++;
x = x/10;
}
return count;
}
// Returns the max occurring digit in x

int maxOccurring(long int x)
{
// Handle negative number
if (x < 0)
x = -x;
int result = 0; // Initialize result which is a digit

int max_count = 1; // Initialize count of result
// Traverse through all digits

for (int d=0; d<=9; d++)
{
// Count occurrences of current digit
int count = countOccurrences(x, d);
// Update max_count and result if needed

if (count >= max_count)
{
max_count = count;
result = d;
}
}
return result;
}
// Driver program
int main()
{
long int x = 1223355;
cout << "Max occurring digit is " << maxOccurring(x);
return 0;
}

Output:

Max occurring digit is 5

discussed above.
Bell Numbers (Number of ways to partition a Set)
Given a set of n elements, find number of ways of partitioning it.
Examples:

Input: n = 2
Output: Number of ways = 2
Explanation: Let the set be {1, 2}
{ {1}, {2} }
{ {2, 2} }
Input: n = 3
Output: Number of ways = 5
Explanation: Let the set be {1, 2, 3}
{ {1}, {2}, {3} }
{ {1}, {2, 3} }
{ {2}, {1, 3} }
{ {3}, {1, 2} }
{ {1, 2, 3} }.

Solution to above questions is Bell Number. First few Bell numbers are 1, 1, 2, 5, 15, 52, 203, ….
One method to compute Bell Numbers is to use Bell Triangle. Below is a sample Bell Triangle.

1
1 2
2 3 5
5 7 10 15
15 20 27 37 52

The triangle is constructed using below formula.

// If this is first column of current row 'i'
If j == 0
// Then copy last entry of previous row
// Note that i'th row has i entries
Bell(i, j) = Bell(i-1, i-1)
// If this is not first column of current row

Else
// Then this element is sum of previous element
// in current row and the element just above the
// previous element
Bell(i, j) = Bell(i-1, j-1) + Bell(i, j-1)

Interpretation
Then Bell(n, k) counts the number of partitions of the set {1, 2, …, n + 1} in which the element k + 1 is the
largest element that can be alone in its set.
For example, Bell(3, 2) is 3, it is count of number of partitions of {1, 2, 3, 4} in which 3 is the largest singleton
element. There are three such partitions:

{1}, {2, 4}, {3}
{1, 4}, {2}, {3}
{1, 2, 4}, {3}.

Below is Dynamic Programming based implementation of above recursive formula.

// A C++ program to find n'th Bell number
#include<iostream>
int bellNumber(int n)
{
int bell[n+1][n+1];
bell[0][0] = 1;
{
// Explicitly fill for j = 0
bell[i][0] = bell[i-1][i-1];
// Fill for remaining values of j

for (int j=1; j<=i; j++)
bell[i][j] = bell[i-1][j-1] + bell[i][j-1];
}
return bell[n][0];
}
// Driver program
int main()
{
for (int n=0; n<=5; n++)
cout << "Bell Number " << n << " is "
<< bellNumber(n) << endl;
return 0;
}

Output:

Bell Number 0 is 1
Bell Number 1 is 1
Bell Number 2 is 2
Bell Number 3 is 5
Bell Number 4 is 15
Bell Number 5 is 52

Time Complexity of above solution is O(n2). We will soon be discussing other more efficient methods of
computing Bell Numbers.
Another problem that can be solved by Bell Numbers .

A number is squarefree if it is not divisible by a perfect square other than 1. For example, 6 is a square free
number but 12 is not as it is divisible by 4.
Given a squarefree number x, find the number of different multiplicative partitions of x. The number of
multiplicative partitions is Bell(n) where n is number of prime factors of x. For example x = 30, there are 3
prime factors of 2, 3 and 5. So the answer is Bell(3) which is 5. The 5 partitions are 1 x 30, 2 x15, 3 x 10, 5 x 6
and 2 x 3 x 5.
Exercise:
The above implementation causes arithmetic overflow for slightly larger values of n. Extend the above
program so that results are computed under modulo 1000000007 to avoid overflows.
Reference:
https://en.wikipedia.org/wiki/Bell_number
https://en.wikipedia.org/wiki/Bell_triangle
This article is contributed by Rajeev Agrawal. Please write comments if you find anything incorrect, or
Find zeroes to be flipped so that number of consecutive 1’s is maximized
Given a binary array and an integer m, find the position of zeroes flipping which creates maximum number
of consecutive 1s in array.
Examples:

Input: arr[] = {1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1}
m = 2
Output: 5 7
We are allowed to flip maximum 2 zeroes. If we flip
arr[5] and arr[7], we get 8 consecutive 1's which is
maximum possible under given constraints
Input: arr[] = {1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1}

m = 1
Output: 7
We are allowed to flip maximum 1 zero. If we flip
arr[7], we get 4 consecutive 1's which is maximum
possible under given constraints.
Input: arr[] = {0, 0, 0, 1}

m = 4
Output: 0 1 2
Since m is more than number of zeroes, we can flip
all zeroes.

Source: http://www.careercup.com/question?id=5106425965576192
A Simple Solution is to consider every subarray by running two loops. For every subarray, count number
of zeroes in it. Return the maximum size subarray with m or less zeroes. Time Complexity of this solution is
O(n2).
A Better Solution is to use auxiliary space to solve the problem in O(n) time.
For all positions of 0’s calculate left[] and right[] which defines the number of consecutive 1’s to the left of i
and right of i respectively.
For example, for arr[] = {1, 1, 0, 1, 1, 0, 0, 1, 1, 1} and m = 1, left[2] = 2 and right[2] = 2, left[5] = 2 and
right[5] = 0, left[6] = 6 and right[6] = 3.
left[] and right[] can be filled in O(n) time by traversing array once and keeping track of last seen 1 and last
seen 0. While filling left[] and right[], we also store indexes of all zeroes in a third array say zeroes[]. For
above example, this third array stores {2, 5, 6}
Now traverse zeroes[] and for all consecutive m entries in this array, compute the sum of 1s that can be
produced. This step can be done in O(n) using left[] and right[].
An Efficient Solution can solve the problem in O(n) time and O(1) space. The idea is to use Sliding
Window for the given array. The solution is taken from here.
Let us use a window covering from index wL to index wR. Let the number of zeros inside the window be
zeroCount. We maintain the window with at most m zeros inside.
The main steps are:

– While zeroCount is no more than m: expand the window to the right (wR++) and update the count
zeroCount.
– While zeroCount exceeds m, shrink the window from left (wL++), update zeroCount;
– Update the widest window along the way. The positions of output zeros are inside the best window.
void findZeroes(int arr[], int n, int m)

{

int wL = 0, wR = 0;

int bestL = 0, bestWindow = 0;

int zeroCount = 0;

while (wR < n)
{

if (zeroCount <= m)
{
if (arr[wR] == 0)
zeroCount++;
wR++;
}

if (zeroCount > m)
{
if (arr[wL] == 0)
zeroCount--;
wL++;
}

if (wR-wL > bestWindow)
{
bestWindow = wR-wL;
bestL = wL;
}
}

for (int i=0; i<bestWindow; i++)
{
if (arr[bestL+i] == 0)
cout << bestL+i << " ";
}
}
int main()
{
int arr[] = {1, 0, 0, 1, 1, 0, 1, 0, 1, 1};
int m = 2;
cout << "Indexes of zeroes to be flipped are ";
findZeroes(arr, n, m);
return 0;
}

Output:

Indexes of zeroes to be flipped are 5 7

Check if a given number is Fancy
A fancy number is one which when rotated 180 degrees is the same. Given a number, find whether it is fancy
or not.
180 degree rotations of 6, 9, 1, 0 and 8 are 9, 6, 1, 0 and 8 respectively
Examples:

Input: num = 96
Output: Yes
If we rotate given number by 180, we get same number
Input: num = 916

Output: Yes
If we rotate given number by 180, we get same number
Input: num = 996

Output: No
Input: num = 121

Output: No

The idea is to create a map to store fancy pair mappings. After creating map, traverse given number from
both ends and if at any point characters at current ends are not fancy pairs, return false. This algorithm is
similar to palindrome check algorithm.

// C++ program to find if a given number is fancy or not.
bool isFancy(string& num)

{
// To store mappings of fancy pair characters. For example
// 6 is paired with 9 and 9 is paired with 6.
map<char, char> fp;
fp['0'] = '0';
fp['1'] = '1';
fp['6'] = '9';
fp['8'] = '8';
fp['9'] = '6';
// Find number of digits in given number

int n = num.length();
// Traverse from both ends, and compare characters one by one

int l = 0, r = n-1;
while (l<=r)
{
// If current characters at both ends are not fancy pairs
if (fp.find(num[l]) == fp.end() || fp[num[l]] != num[r])
return false;
l++;
r--;
}
return true;
}
// Driver program
int main()
{
string str = "9088806";
isFancy(str)? cout << "Yes": cout << "No";
return 0;
}

Output:

Yes

discussed above.
Count number of ways to partition a set into k subsets
Given two numbers n and k where n represents number of elements in a set, find number of ways to
partition the set into k subsets.
Example:

Input: n = 3, k = 2
Output: 3
Explanation: Let the set be {1, 2, 3}, we can partition
it into 2 subsets in following ways
{{1,2}, {3}}, {{1}, {2,3}}, {{1,3}, {2}}
Input: n = 3, k = 1
Output: 1
Explanation: There is only one way {{1, 2, 3}}

Let S(n, k) be total number of partitions of n elements into k sets. Value of S(n, k) can be defined recursively
as,

S(n, k) = k*S(n-1, k) + S(n-1, k-1)

S(n, k) is called Stirling numbers of the second kind
How does above recursive formula work?

When we add a (n+1)’th element to k partitions, there are two possibilities.
1) It is added as a single element set to existing partitions, i.e, S(n, k-1)
2) It is added to all sets of every partition, i.e., k*S(n, k)
Therefore S(n+1, k) = k*S(n, k) + S(n, k-1) which means S(n, k) = k*S(n-1, k) + S(n-1, k-1)
Below is recursive solution based on above formula.

// A C++ program to count number of partitions
// of a set with n elements into k subsets
#include<iostream>
// Returns count of different partitions of n

// elements in k subsets
int countP(int n, int k)
{
// Base cases
if (n == 0 || k == 0 || k > n)
return 0;
if (k == 1 || k == n)
return 1;
// S(n+1, k) = k*S(n, k) + S(n, k-1)

return k*countP(n-1, k) + countP(n-1, k-1);
}
// Driver program
int main()
{
cout << countP(3, 2);
return 0;
}

Output:
The time complexity of above recursive solution is exponential. The solution can be optimized as there are
overlapping subproblems. For example, below is recursion tree of countP(10,7). The subproblem countP(8,6)
or CP(8,6) is called multiple times.

CP() represents countP()
CP(10,7)
/ \
CP(9,7) CP(9,6)
/ \ / \
CP(8,7) CP(8,6) CP(8,6) CP(8,5)
/ \ / \ / \ / \
Partial Recursion Tree for countP(10, 7)

to highlight overlapping subproblems.

So this problem has both properties (see this and this) of a dynamic programming problem. Like other
constructing a temporary array dp[][] in bottom up manner using the above recursive formula.
Below is C++ implementation of Dynamic Programming Solution.

// A Dynamic Programming based C++ program to count
// number of partitions of a set with n elements
// into k subsets
#include<iostream>
// Returns count of different partitions of n

// elements in k subsets
int countP(int n, int k)
{
// Table to store results of subproblems
int dp[n+1][k+1];
// Base cases
dp[i][0] = 0;
for (int i=0; i<=k; i++)
dp[0][k] = 0;
// Fill rest of the entries in dp[][]

// in bottom up manner
for (int j=1; j<=i; j++)
if (j == 1 || i == j)
dp[i][j] = 1;
else
dp[i][j] = j*dp[i-1][j] +
dp[i-1][j-1];
return dp[n][k];
}
// Driver program
int main()
{
cout << countP(5, 2);
return 0;
}

Output:
Time Complexity: O(n x k)

Auxiliary Space: O(n x k)
Similar Article: Bell Numbers
Count triplets with sum smaller that a given value
Given an array of distinct integers and a sum value. Find count of triplets with sum smaller than given sum
value. Expected Time Complexity is O(n2).
Examples:

Input : arr[] = {-2, 0, 1, 3}
sum = 2.
Output : 2
Explanation : Below are triplets with sum less than 2
(-2, 0, 1) and (-2, 0, 3)
Input : arr[] = {5, 1, 3, 4, 7}

sum = 12.
Output : 4
Explanation : Below are triplets with sum less than 4
(1, 3, 4), (1, 3, 5), (1, 3, 7) and
(1, 4, 5)

A Simple Solution is to run three loops to consider all triplets one by one. For every triplet, compare the
sums and increment count if triplet sum is smaller than given sum.

// A Simple C++ program to count triplets with sum smaller
// than a given value
int countTriplets(int arr[], int n, int sum)

{
int ans = 0;
// Fix the first element as A[i]

for (int i = 0; i < n-2; i++)
{
// Fix the second element as A[j]
for (int j = i+1; j < n-1; j++)
{
// Now look for the third number
for (int k = j+1; k < n; k++)
if (arr[i] + arr[j] + arr[k] < sum)
ans++;
}
}
return ans;
}
// Driver program
int main()
{
int arr[] = {5, 1, 3, 4, 7};
int sum = 12;
cout << countTriplets(arr, n, sum) << endl;
return 0;
}

Output:
Time complexity of above solution is O(n3). An Efficient Solution can count triplets in O(n2) by sorting
the array first, and then using method 1 of this post in a loop.

1) Sort the input array in increasing order.
3) Run a loop from i = 0 to n-2. An iteration of this loop finds all
triplets with arr[i] as first element.
a) Initialize other two elements as corner elements of subarray
arr[i+1..n-1], i.e., j = i+1 and k = n-1
b) Move j and k toward each other until they meet, i.e., while (j < k)
(i) if (arr[i] + arr[j] + arr[k] >= sum), then do k--
// Else for current i and j, there can (k-j) possible third elements
// that satisfy the constraint.
(ii) Else Do ans += (k - j) followed by j++


// C++ program to count triplets with sum smaller than a given value
int countTriplets(int arr[], int n, int sum)

{
// Sort input array
sort(arr, arr+n);
int ans = 0;
// Every iteration of loop counts triplet with

// first element as arr[i].
for (int i = 0; i < n - 2; i++)
{
// Initialize other two elements as corner elements
// of subarray arr[j+1..k]
int j = i + 1, k = n - 1;
// Use Meet in the Middle concept

while (j < k)
{
// If sum of current triplet is more or equal,
// move right corner to look for smaller values
if (arr[i] + arr[j] + arr[k] >= sum)
k--;
// Else move left corner

else
{
// This is important. For current i and j, there
// can total k-j third elements.
ans += (k - j);
j++;
}
}
}
return ans;
}
// Driver program
int main()
{
int arr[] = {5, 1, 3, 4, 7};
int sum = 12;
cout << countTriplets(arr, n, sum) << endl;
return 0;
}

Output:

discussed above
Find Count of Single Valued Subtrees
Given a binary tree, write a program to count the number of Single Valued Subtrees. A Single Valued Subtree
is one in which all the nodes have same value. Expected time complexity is O(n).
Example:

Input: root of below tree
5
/ \
1 5
/ \ \
5 5 5
Output: 4
There are 4 subtrees with single values.
Input: root of below tree

5
/ \
4 5
/ \ \
4 4 5
Output: 5
There are five subtrees with single values.

A Simple Solution is to traverse the tree. For every traversed node, check if all values under this node are
same or not. If same, then increment count. Time complexity of this solution is O(n 2).
An Efficient Solution is to traverse the tree in bottom up manner. For every subtree visited, return true if
subtree rooted under it is single valued and increment count. So the idea is to use count as a reference
parameter in recursive calls and use returned values to find out if left and right subtrees are single valued or
not.
struct Node
{
int data;
};

{
temp->data = data;
return (temp);
}
bool countSingleRec(Node* root, int &count)
{

if (root == NULL)
return true;

bool left = countSingleRec(root->left, count);
bool right = countSingleRec(root->right, count);

if (left == false || right == false)
return false;

if (root->left && root->data != root->left->data)
return false;

if (root->right && root->data != root->right->data)
return false;

count++;
return true;
}
int countSingle(Node* root)

{

int count = 0;

countSingleRec(root, count);
return count;
}
int main()
{

Node* root = newNode(5);
cout << "Count of Single Valued Subtrees is "
<< countSingle(root);
return 0;
}

Output:

Count of Single Valued Subtrees is 5

Time complexity of this solution is O(n) where n is number of nodes in given binary tree.
Thanks to Gaurav Ahirwar fir suggesting above solution.
discussed above.
Randomized Algorithms | Set 1 (Introduction and Analysis)
What is a Randomized Algorithm?

A Randomized Algorithm uses random numbers to decide what to do next at certain point(s). For example,
in Randomized Quick Sort, we use random number to pick the next pivot (or we randomly shuffle the array).
How do we analyze Randomized Algorithms?

Randomized algorithms are typically analyzed for expected worst case. To compute time taken in expected
worst case, we consider all possible values of the random number generated in worst case, evaluate time
taken by every possible value and compute average of all.
For example consider below a randomized version of QuickSort. A Central Pivot is a pivot that divides the
array in such a way that one side has at-least 1/4 elements.

// Sorts an array arr[low..high]
randQuickSort(arr[], low, high)
1. If low >= high, then EXIT.
2. While pivot 'x' is not a Central Pivot.

(i) Choose uniformly at random a number from [low..high].
Let the randomly picked number number be x.
(ii) Count elements in arr[low..high] that are smaller
than arr[x]. Let this count be sc.
(iii) Count elements in arr[low..high] that are greater
than arr[x]. Let this count be gc.
(iv) Let n = (high-low+1). If sc >= n/4 and
gc >= n/4, then x is a central pivot.
3. Partition arr[low..high] around the pivot x.
4. // Recur for smaller elements

randQuickSort(arr, low, sc-1)
5. // Recur for greater elements

randQuickSort(arr, high-gc+1, high)

The important thing in our analysis is, time taken by step 2 is O(n).
How many times while loop is run before finding a central pivot?
The probability that the randomly chosen element is central pivot is 1/2.
Therefore, expected number of times the while loop is run is 2 (See this for details)
Thus, the expected time complexity of step 2 is O(n).
What is overall Time Complexity in Worst Case?

In worst case, each partition divides array such that one side has n/4 elements and other side has 3n/4
elements. The worst case height of recursion tree is Log3/4n which is O(Log n).

T(n) < T(n/4) + T(3n/4) + O(n)

T(n) < 2T(3n/4) + O(n)
The above recurrence has solution as O(n Log n)

Note that the above randomized algorithm is not the best way to implement randomized Quick Sort. The
idea here is to simplify the analysis as it is simple to analyze.
Typically, randomized Quick Sort is implemented by randomly picking a pivot (no loop). Or by shuffling
array elements. Expected worst case time complexity of this algorithm is also O(n Log n), but analysis is
complex, the MIT prof himself mentions same in his lecture here.
We will soon be discussing Classification and Applications of Randomized Algorithms in next set.
References:
http://www.tcs.tifr.res.in/~workshop/nitrkl_igga/randomized-lecture.pdf
This article is contributed by Ashish Sharma. Please write comments if you find anything incorrect, or you
Euler’s Totient function for all numbers smaller than or equal to n
Euler’s Totient function Φ(n) for an input n is count of numbers in {1, 2, 3, …, n} that are relatively prime to
n, i.e., the numbers whose GCD (Greatest Common Divisor) with n is 1.
For example, Φ(4) = 2, Φ(3) = 2 and Φ(5) = 4. There are 2 numbers smaller or equal to 4 that are relatively
prime to 4, 2 numbers smaller or equal to 3 that are relatively prime to 3. And 4 numbers smaller than or
equal to 5 that are relatively prime to 5.
We have discussed different methods for computation of Φ(n) in previous post.
How to compute Φ for all numbers smaller than or equal to n?

Example:

Input: n = 5
Output: Totient of 1 is 1
Totient of 2 is 1
Totient of 3 is 2
Totient of 4 is 2
Totient of 5 is 4

A Simple Solution is to call Φ(i) for i = 1 to n.
An Efficient Solution is to use idea similar to Sieve of Eratosthenes to precompute all values/. The
method is based on below product formula.
The formula basically says that the value of Φ(n) is equal to n multiplied by product of (1 – 1/p) for all prime
factors p of n. For example value of Φ(6) = 6 * (1-1/2) * (1 – 1/3) = 2.
Below is complete algorithm:

1) Create an array phi[1..n] to store Φ values of all numbers
from 1 to n.
2) Initialize all values such that phi[i] stores i. This

initialization serves two purposes.
a) To check if phi[i] is already evaluated or not. Note that
the maximum possible phi value of a number i is i-1.
b) To initialize phi[i] as i is a multiple in above product
formula.
3) Run a loop for p = 2 to n

a) If phi[p] is p, means p is not evaluated yet and p is a
prime number (slimier to Sieve), otherwise phi[p] must
have been updated in step 3.b
b) Traverse through all multiples of p and update all
multiples of p by multiplying with (1-1/p).
4) Run a loop from i = 1 to n and print all Ph[i] values.

#include<iostream>
void computeTotient(int n)
{

long long phi[n+1];
phi[i] = i;

for (int p=2; p<=n; p++)
{

if (phi[p] == p)
{

phi[p] = p-1;

for (int i = 2*p; i<=n; i += p)
{

phi[i] = (phi[i]/p) * (p-1);
}
}
}

cout << "Totient of " << i << " is "
<< phi[i] << endl;
}
int main()
{
int n = 12;
computeTotient(n);
return 0;
}

Output:

Totient of 1 is 1
Totient of 2 is 1
Totient of 3 is 2
Totient of 4 is 2
Totient of 5 is 4
Totient of 6 is 2
Totient of 7 is 6
Totient of 8 is 4
Totient of 9 is 6
Totient of 10 is 4
Totient of 11 is 10
Totient of 12 is 4

The same solution can be used when we have large number queries for computing totient function.
Randomized Algorithms | Set 2 (Classification and Applications)
Randomized Algorithms | Set 1 (Introduction and Analysis)
Classification
Randomized algorithms are classified in two categories.
Las Vegas: Always produce correct or optimum result. Running time of these algorithms is a random value.
For example, expected time complexity of QuickSort is O(nLogn).
Monte Carlo: Produce correct or optimum result with some probability. These algorithms have
deterministic running time and it is generally easier to find out worst case time complexity. Example this
implementation of Karger’s Algorithm has worst case time complexity of Karger’s Algorithm is O()
Example to Understand Classification:

Consider a binary array where exactly half elements are 0
and half are 1. The task is to find index of any 1.

A Las Vegas algorithm for this task is to keep picking a random element until we find a 1. A Monte Carlo
algorithm for the same is to keep picking a random element until we either find 1 or we have tried maximum
allowed times say k.
The Las Vegas algorithm always finds an index of 1, but time complexity is determined as expect value. The
expected number of trials before success is 2, therefore time complexity is O(1).
The Monte Carlo Algorithm finds a 1 with probability [1 – (1/2)k]. Time complexity of Monte Carlo is O(k)
which is deterministic
Applications and Scope:

Consider a tool that basically does sorting. Let the tool be used by many users and there are few users
who always use tool for already sorted array. If the tool uses simple (not randomized) QuickSort, then
those few users are always going to face worst case situation. On the other hand if the tool uses
Randomized QuickSort, then there is no user that always gets worst case. Everybody gets expected
O(n Log n) time.
Randomized algorithms have huge applications in Cryptography.
Load Balancing.
Number-Theoretic Applications: Primality Testing
Data Structures: Hashing, Sorting, Searching, Order Statistics and Computational Geometry.
Algebraic identities: Polynomial and matrix identity verification. Interactive proof systems.
Mathematical programming: Faster algorithms for linear programming, Rounding linear program
solutions to integer program solutions
Graph algorithms: Minimum spanning trees, shortest paths, minimum cuts.
Counting and enumeration: Matrix permanent Counting combinatorial structures.
Parallel and distributed computing: Deadlock avoidance distributed consensus.
Probabilistic existence proofs: Show that a combinatorial object arises with non-zero probability
among objects drawn from a suitable probability space.
Derandomization: First devise a randomized algorithm then argue that it can be derandomized to
yield a deterministic algorithm.
Sources:
http://theory.stanford.edu/people/pragh/amstalk.pdf
https://en.wikipedia.org/wiki/Randomized_algorithm
This article is contributed by Ashish Sharma. Please write comments if you find anything incorrect, or you
Count number of paths with at-most k turns
Given three numbers m, n and k where m and n represent number of rows and columns respectively in a
grid. Count number of paths to reach bottom right from top left with maximum k turns allowed.
What is a turn? A movement is considered turn, if we were moving along row and now move along
column. OR we were moving along column and now move along row.

There are two possible scenarios when a turn can occur
at point (i, j):
Turns Right: (i-1, j) -> (i, j) -> (i, j+1)

Down Right
Turns Down: (i, j-1) -> (i, j) -> (i+1, j)

Right Down

Examples:

Input: m = 3, n = 3, k = 2
Output: 4
See below diagram for four paths with
maximum 2 turns.
Input: m = 3, n = 3, k = 1
Output: 2

Source: http://qa.geeksforgeeks.org/1993/no-of-paths-with-k-turns
This problem can be recursively computed using below recursive formula.

countPaths(i, j, k): Count of paths to reach (i,j) from (0, 0)
countPathsDir(i, j, k, 0): Count of paths if we reach (i, j)
along row.
countPathsDir(i, j, k, 1): Count of paths if we reach (i, j)
along column.
The fourth parameter in countPathsDir() indicates direction.
Value of countPaths() can be written as:

countPaths(i, j, k) = countPathsDir(i, j, k, 0) +
countPathsDir(i, j, k, 1)
And value of countPathsDir() can be recursively defined as:
// Base cases
// If current direction is along row

If (d == 0)
// Count paths for two cases
// 1) We reach here through previous row.
// 2) We reach here through previous column, so number of
// turns k reduce by 1.
countPathsDir(i, j, k, d) = countPathsUtil(i, j-1, k, d) +
countPathsUtil(i-1, j, k-1, !d);
// If current direction is along column

Else
// Similar to above
countPathsDir(i, j, k, d) = countPathsUtil(i-1, j, k, d) +
countPathsUtil(i, j-1, k-1, !d);

We can solve this problem in Polynomial Time using Dynamic Programming. The idea is to use a 4
dimensional table dp[m][n][k][d] where m is number of rows, n is number of columns, k is number of
allowed turns and d is direction.
Below is Dynamic Programming based C++ implementation.
#define MAX 100
int dp[MAX][MAX][MAX][2];
int countPathsUtil(int i, int j, int k, int d)

{

if (i < 0 || j < 0)
return 0;

if (i == 0 && j == 0)
return 1;
return 1;

if (k == 0)
{

if (d == 0 && i == 0) return 1;

if (d == 1 && j == 0) return 1;
return 0;
}

if (dp[i][j][k][d] != -1)
return dp[i][j][k][d];

if (d == 0)
return dp[i][j][k][d] = countPathsUtil(i, j-1, k, d) +
countPathsUtil(i-1, j, k-1, !d);

return dp[i][j][k][d] = countPathsUtil(i-1, j, k, d) +
countPathsUtil(i, j-1, k-1, !d);
}
int countPaths(int i, int j, int k)

{

if (i == 0 && j == 0)
return 1;


return countPathsUtil(i-1, j, k, 1) +
countPathsUtil(i, j-1, k, 0);
}
int main()
{
int m = 3, n = 3, k = 2;
cout << "Number of paths is "
<< countPaths(m-1, n-1, k) << endl;
return 0;
}

Output:

Number of paths is 4

Time complexity of above solution is O(m*n*k)
discussed above.
Check if edit distance between two strings is one
An edit between two strings is one of the following changes.
a. Add a character
b. Delete a character
c. Change a character
Given two string s1 and s2, find if s1 can be converted to s2 with exactly one edit. Expected time complexity is
O(m+n) where m and n are lengths of two strings.
Examples:

Input: s1 = "geeks", s2 = "geek"
Output: yes
Input: s1 = "geeks", s2 = "geeks"

Output: no
Input: s1 = "geaks", s2 = "geeks"

Output: yes

A Simple Solution is to find Edit Distance using Dynamic programming. If distance is 1, then return true,
else return false. Time complexity of this solution is O(n2)
An Efficient Solution is to simultaneously traverse both strings and keep track of count of different
characters. Below is complete algorithm.

Let the input strings be s1 and s2 and lengths of input
strings be m and n respectively.
1) If difference between m an n is more than 1, return false.

2) Initialize count of edits as 1.
3) Start traversing both strings from their first characters
a) If current characters don't match, then
(i) Increment count of edits
(ii) If count becomes more than 1, return false
(iii) If length of one string is more, then only possible
edit is to remove a character. Therefore, move ahead
in larger string.
(iv) If length is same, then only possible edit is to
change a character. Therefore, move ahead in both
strings.
b) Else, move ahead in both strings.


// C++ program to check if given two strings are
// at distance one.
// Returns true if edit distance between s1 and

// s2 is one, else false
// s2 is one, else false
bool isEditDistanceOne(string s1, string s2)
{
// Find lengths of given strings
int m = s1.length(), n = s2.length();
// If difference between lengths is more than

// 1, then strings can't be at one distance
if (abs(m - n) > 1)
return false;
int count = 0; // Count of edits
int i = 0, j = 0;
{
// If current characters don't match
if (s1[i] != s2[j])
{
if (count == 1)
return false;
// If length of one string is

// more, then only possible edit
// is to remove a character
if (m > n)
i++;
else if (m< n)
j++;
else //Iflengths of both strings is same
{
i++;
j++;
}

// Increment count of edits
count++;
}
else // If current characters match
{
i++;
j++;
}
}
// If last character is extra in any string

if (i < m || j < n)
count++;
return count == 1;
}
// Driver program
int main()
{
string s1 = "gfg";
string s2 = "gf";
isEditDistanceOne(s1, s2)?
cout << "Yes": cout << "No";
return 0;
}

Output:

Yes


discussed above
Count Derangements (Permutation such that no element appears in its
original position)
A Derangement is a permutation of n elements, such that no element appears in its original position.
Given a number n, find total number of Derangements of n elements.
Examples:

Input: n = 2
Output: 1
For two elements say {0, 1}, there is only one
possible derangement {1, 0}
Input: n = 3
Output: 2
For three elements say {0, 1, 2}, there are two
possible derangements {2, 0, 1} and {1, 2, 0}
Input: n = 4
Output: 9
For four elements say {0, 1, 2, 3}, there are 9
possible derangements {1, 0, 3, 2} {1, 2, 3, 0}
{1, 3, 0, 2}, {2, 3, 0, 1}, {2, 0, 3, 1}, {2, 3,
1, 0}, {3, 0, 1, 2}, {3, 2, 0, 1} and {3, 2, 1, 0}

Let countDer(n) be count of derangements for n elements. Below is recursive relation for it.

countDer(n) = (n-1)*[countDer(n-1) + countDer(n-2)]

How does above recursive relation work?

There are n – 1 ways for element 0 (this explains multiplication with n-1).
Let 0 be placed at index i . There are now two possibilities, depending on whether or not element i is
placed at 0 in return.
1. i is placed at 0: This case is equivalent to solving the problem for n-2 elements as two elements
have just swapped their positions.
2. i is not placed at 0: This case is equivalent to solving the problem for n-1 elements as now there
are n-1 elements, n-1 positions and every element has n-2 choices
Below is Simple Solution based on above recursive formula.

int countDer(int n)
{


return (n-1)*(countDer(n-1) + countDer(n-2));
}

int main()
{
int n = 4;
cout << "Count of Derangements is "
<< countDer(n) << endl;
return 0;
}

Output:

Count of Derangements is 9

Time Complexity: T(n) = T(n-1) + T(n-2) which is exponential.

We can observe that this implementation does repeated work. For example see recursion tree for
countDer(5), countDer(3) is being being evaluated twice.

cdr() ==> countDer()
cdr(5)
/ \
cdr(4) cdr(3)
/ \ / \
cdr(3) cdr(2) cdr(2) cdr(1)

An Efficient Solution is to use Dynamic Programming to store results of subproblems in an array and
build the array in bottom up manner.

int countDer(int n)
{

int der[n + 1];

der[0] = 1;
der[1] = 0;
der[2] = 1;

for (int i=3; i<=n; ++i)
der[i] = (i-1)*(der[i-1] + der[i-2]);

return der[n];
}
int main()
{
int n = 4;
cout << "Count of Derangements is "
<< countDer(n) << endl;
return 0;
}

Output:

Count of Derangements is 9


Thanks to Utkarsh Trivedi for suggesting above solution.
References:
https://en.wikipedia.org/wiki/Derangement
discussed above
Search a Word in a 2D Grid of characters
Given a 2D grid of characters and a word, find all occurrences of given word in given grid. A word can be
found in all 8 directions at a point and all characters should be match in one direction (not in zig-zag form)
only.
The 8 directions are, Horizontally Left, Horizontally Right, Vertically Up and 4 Diagonal directions.
Example:

Input: grid[][] = {"GEEKSFORGEEKS",
"GEEKSQUIZGEEK",
"IDEQAPRACTICE"};
word = "GEEKS"
Output: pattern found at 0, 0

pattern found at 0, 8
Input: grid[][] = {"GEEKSFORGEEKS",

"GEEKSQUIZGEEK",
"IDEQAPRACTICE"};
word = "EEE"
Output: pattern found at 0, 2


Below diagram shows a bigger grid and presence of different words in it.
The idea used here is simple, we check every cell. If cell has first character, then we one by one try all 8
directions from that cell for a match. Implementation is interesting though. We use two arrays x[] and y[] to
find next move in all 8 directions.
Below is C++ implementation of the same.

#define R 3
#define C 14
int x[] = { -1, -1, -1, 0, 0, 1, 1, 1 };

int y[] = { -1, 0, 1, -1, 1, -1, 0, 1 };
bool search2D(char grid[R][C], int row, int col, string word)

{

if (grid[row][col] != word[0])
return false;
int len = word.length();

for (int dir = 0; dir < 8; dir++)
{

int k, rd = row + x[dir], cd = col + y[dir];

for (k = 1; k < len; k++)
{

if (rd >= R || rd < 0 || cd >= C || cd < 0)
break;

if (grid[rd][cd] != word[k])
break;

rd += x[dir], cd += y[dir];
}

if (k == len)
return true;
}
return false;
}
void patternSearch(char grid[R][C], string word)

{

for (int row = 0; row < R; row++)
for (int col = 0; col < C; col++)
if (search2D(grid, row, col, word))
cout << "pattern found at " << row << ", "
<< col << endl;
}
int main()
{
char grid[R][C] = {"GEEKSFORGEEKS",
"GEEKSQUIZGEEK",
"IDEQAPRACTICE"
};
patternSearch(grid, "GEEKS");
cout << endl;
patternSearch(grid, "EEE");
return 0;
}

Output:


Exercise: The above solution only print locations of word. Extend it to print the direction where word is
present.
Find the smallest twins in given range
Given a range [low..high], print the smallest twin numbers in given range (low and high inclusive). Two
numbers are twins if they are primes and there difference is 2.
Example:

Input: low = 10, high = 100
Output: Smallest twins in given range: [11, 13]
Input: low = 50, high = 100

Output: Smallest twins in given range: [59, 61]

A Simple Solution is to start to start from low and for every number x check if x and x + 2 are primes are
not. Here x varies from low to high-2.
An Efficient Solution is to use Sieve of Eratosthenes

1) Create a boolean array "mark[0..high]" and initialize all
entries in it as false. A value in mark[i] will finally
be true if i is not a prime number, else false.
2) Initialize previous prime as low. Previous prime is going

to store first number of twins.
3) Run a loop from p = 2 to high.

a) If mark[p] is false, then p is prime. [See this]
b) If p is greater than low and p-prev = 2, we found the
pair.
c) Mark all multiples of p as not prime.
d) Update prev: prev = p


void printTwins(int low, int high)

{

bool mark[high+1];
memset(mark, 0, sizeof(mark));

int prev = low;

for (int p=2; p<=high; p++)
{

if (!mark[p])
{

if (p>=low && p-prev == 2)
{
cout << "Smallest twins in given range: "
<< prev << ", " << p;
return;
}

for (int i=p; i<=high; i += p)
mark[i] = true;

prev = p;
}
}
}
int main()
{
printTwins(10, 100);
return 0;
}

Output:

11, 13

Thanks to Utkarsh Trivedi for suggesting this solution.
discussed above.
Primality Test | Set 2 (Fermat Method)
Given a number n, check if it is prime or not. We have introduced and discussed School method for primality
testing in Set 1.
Primality Test | Set 1 (Introduction and School Method)
In this post, Fermet’s method is discussed. This method is a probabilistic method and is based on below
Fermet’s Little Theorem.

Fermet's Little Theorem:
If n is a prime number, then for every a, 1 an-1 ≡ 1 (mod n)
Example: Since 5 is prime, 24 ≡ 1 (mod 5),

34 ≡ 1 (mod 5) and 44 ≡ 1 (mod n)
Since 7 is prime, 26 ≡ 1 (mod 7),

36 ≡ 1 (mod 7), 46 ≡ 1 (mod 7)
56 ≡ 1 (mod 7) and 66 ≡ 1 (mod 7)
Refer this for different proofs.

If a given number is prime, then this method always returns true. If given number is composite (or non-
prime), then it may return true or false, but the probability of producing incorrect result for composite is low
and can be reduced by doing more iterations.
Below is algorithm:

// Higher value of k indicates probability of correct
// results for composite inputs become higher. For prime
// inputs, result is always correct
1) Repeat following k times:
a) Pick a randomly in the range [2, n ? 2]
b) If an-1 ≢ 1 (mod n), then return false
2) Return true [probably prime].


int power(int a, unsigned int n, int p)

{
int res = 1;
a = a % p;
while (n > 0)
{

if (n & 1)
res = (res*a) % p;

n = n>>1;
a = (a*a) % p;
}
return res;
}
bool isPrime(unsigned int n, int k)

{

if (n <= 1) return false;

while (k>0)
{

int a = 2 + rand() % (n-3);

if (power(a, n-1, n) != 1)
return false;
k--;
}
return true;
}
int main()
{
int k = 3;
isPrime(11, k)? cout << " true\n": cout << " false\n";
isPrime(15, k)? cout << " true\n": cout << " false\n";
return 0;
}

Output:

true
false

Time complexity of this solution is O(k Log n). Note that power function takes O(Log n) time.
Note that the above method may fail even for higher values of n. There exist sum composite numbers with
the property that for every a an-1 ≡ 1 (mod n). Such numbers are called Carmichael numbers. Fermet’s
primality test is often used if a rapid method is needed for filtering, for example in key generation phase of
the RSA public key cryptographic algorithm.
We will soon be discussing more methods for Primality Testing.
References:
https://en.wikipedia.org/wiki/Fermat_primality_test
https://en.wikipedia.org/wiki/Prime_number
http://www.cse.iitk.ac.in/users/manindra/presentations/FLTBasedTests.pdf
https://en.wikipedia.org/wiki/Primality_test
This article is contributed by Ajay. Please write comments if you find anything incorrect, or you want to
Given a positive integer, check if the number is prime or not. A prime is a natural number greater than 1 that
has no positive divisors other than 1 and itself. Examples of first few prime numbers are {2, 3, 5,
Examples:

Input: n = 11
Output: true
Input: n = 15
Output: false
Input: n = 1
Output: false

School Method
A simple solution is to iterate through all numbers from 2 to n-1 and for every number check if it divides n. If
we find any number that divides, we return false.

// A school method based C++ program to check if a
// number is prime
bool isPrime(int n)
{
// Corner case
// Check from 2 to n-1

if (n%i == 0)
return false;
return true;
}

int main()
{
isPrime(11)? cout << " true\n": cout << " false\n";
return 0;
}

Output:

true
false

Time complexity of this solution is O(n)
Optimized School Method

We can do following optimizations:
1. Instead of checking till n, we can check till √n because a larger factor of n must be a multiple of smaller
factor that has been already checked.
2. The algorithm can be improved further by observing that all primes are of the form 6k ± 1, with the
exception of 2 and 3. This is because all integers can be expressed as (6k + i) for some integer k and
for i = ?1, 0, 1, 2, 3, or 4; 2 divides (6k + 0), (6k + 2), (6k + 4); and 3 divides (6k + 3). So a more
efficient method is to test if n is divisible by 2 or 3, then to check through all the numbers of form 6k ±
1. (Source: wikipedia)

// A optimized school method based C++ program to check
// if a number is prime
bool isPrime(int n)
{
// Corner cases
// This is checked so that we can skip

// middle five numbers in below loop
if (n%2 == 0 || n%3 == 0) return false;
for (int i=5; i*i<=n; i=i+6)

if (n%i == 0 || n%(i+2) == 0)
return false;
return true;
}

int main()
{
return 0;
}

Output:

true
false

Time complexity of this solution is O(√n)

We will soon be discussing more methods for Primality Testing.
https://en.wikipedia.org/wiki/Prime_number
http://www.cse.iitk.ac.in/users/manindra/presentations/FLTBasedTests.pdf
https://en.wikipedia.org/wiki/Primality_test
This article is contributed by Ajay. Please write comments if you find anything incorrect, or you want
Segmented Sieve
Given a number n, print all primes smaller than n. For example, if the given number is 10, output 2, 3, 5, 7.
A Naive approach is to run a loop from 0 to n-1 and check each number for primeness. A Better Approach is
use Simple Sieve of Eratosthenes.
void simpleSieve(int limit)

{

bool mark[limit];
memset(mark, true, sizeof(mark));

for (int p=2; p*p<limit; p++)
{

if (mark[p] == true)
{

for (int i=p*2; i<limit; i+=p)
mark[i] = false;
}
}

for (int p=2; p<limit; p++)
cout << p << " ";
}

Problems with Simple Sieve:

The Sieve of Eratosthenes looks good, but consider the situation when n is large, the Simple Sieve faces
following issues.
An array of size Θ(n) may not fit in memory

The simple Sieve is not cache friendly even for slightly bigger n. The algorithm traverses the array
without locality of reference
Segmented Sieve
Below are steps used in Segmented Sieve.
1. Use Simple Sieve to find all primes upto square root of ‘n’ and store these primes in an array
“prime[]”. We not only find prime numbers, but also puts them in a separate array prime[].
2. We need all primes in range [2..n-1]. We divide this range in different segments such that size of every
segment is at-most √n
3. Do following for every segment [low..high]
Create an array mark[high-low+1]. Here we need only O(x) space where x is number of
elements in given range.
Iterate through all primes found in step 1. For every prime, mark its multiples in given range
[low..high].
In Simple Sieve, we needed O(n) space which may not be feasible for large n. Here we need O(√n) space and
we process smaller ranges at a time (locality of reference)
void simpleSieve(int limit, vector<int> &prime)

{

bool mark[limit+1];
for (int p=2; p*p<limit; p++)

{

{

for (int i=p*2; i<limit; i+=p)
mark[i] = false;
}
}

for (int p=2; p<limit; p++)
{
{
prime.push_back(p);
cout << p << " ";
}
}
}
void segmentedSieve(int n)
{

int limit = floor(sqrt(n));
vector<int> prime;
simpleSieve(limit, prime);

int low = limit;
int high = 2*limit;

while (low < n)
{

bool mark[limit+1];

for (int i = 0; i < prime.size(); i++)
{

int loLim = floor(low/prime[i]) * prime[i];
if (loLim < low)
loLim += prime[i];

for (int j=loLim; j<high; j+=prime[i])
mark[j-low] = false;
}

for (int i = low; i<high; i++)
if (mark[i - low] == true)
cout << i << " ";

low = low + limit;
high = high + limit;
if (high >= n) high = n;
}
}
int main()
{
int n = 100;
cout << "Primes smaller than " << n << ":\n";
segmentedSieve(n);
return 0;
}

Output:

Primes smaller than 100:
13 17 19 23 29 31 37 41 43 47 53 59
61 67 71 73 79 83 89 97

Note that time complexity (or number of operations) by Segmented Sieve is same as Simple Sieve. It has
advantages for large ‘n’ as it has better locality of reference and requires
Sum of Bitwise And of all pairs in a given array
Given an array “arr[0..n-1]” of integers, calculate sum of “arr[i] & arr[j]” for all the pairs in the given where i
Example:

Input: arr[] = {5, 10, 15}
Output: 15
Required Value = (5 & 10) + (5 & 15) + (10 & 15)
= 0 + 5 + 10
= 15

A Brute Force approach is to run two loops and time complexity is O(n2).
int pairAndSum(int arr[], int n)

{
int ans = 0;

for (int i = 0; i < n; i++)
for (int j = i+1; j < n; j++)
ans += arr[i] & arr[j];
return ans;
}
int main()
{
int arr[] = {5, 10, 15};
int n = sizeof(arr) / sizeof (arr[0]);
cout << pairAndSum(arr, n) << endl;
return 0;
}

Output:

15

An Efficient Solution can solve this problem in O(n) time. The assumption here is that integers are
represented using 32 bits.
The idea is to count number of set bits at every i’th position (i>=0 && ikC2 = k*(k-1)/2 (Count k means there
i
are k numbers which have i’th set bit). Every such pair adds 2i to total sum. Similarly, we work for all other
places and add the sum to our final answer.
This idea is similar to this. Below is C++ implementation.
int pairAndSum(int arr[], int n)

{
int ans = 0;

for (int i = 0; i < 32; i++)
{

int k = 0;
for (int j = 0; j < n; j++)
if ( (arr[j] & (1 << i)) )
k++;

ans += (1<<i) * (k*(k-1)/2);
}
return ans;
}
int main()
{
int arr[] = {5, 10, 15};
int n = sizeof(arr) / sizeof (arr[0]);
cout << pairAndSum(arr, n) << endl;
return 0;
}

Output:

15

Count number of ways to divide a number in 4 parts
Given a positive integer n, find number of ways to divide n in four parts or represent n as sum of four
positive integers. Here n varies from 0 to 5000.
Examples:

Input: n = 5
Output: 1
There is only one way (1, 1, 1, 2)
Input: n = 6
Output: 2
There are two ways (1, 1, 1, 3) and
(1, 1, 2, 2)
Input: n = 8
Output: 5
There are five ways (2, 2, 2, 2), (1, 1, 1, 5),
(1, 1, 3, 3), (1, 1, 2, 4) and (1, 2, 2, 3)

Method 1 (Simple Solution) Run four nested loops to generate all possible different quadruplet. Below is
C++ implementation of the simple algorithm.

int countWays(int n)
{
int counter = 0;

for (int i = 1; i < n; i++)
for (int j = i; j < n; j++)
for (int k = j; k < n; k++)
for (int l = k; l < n; l++)
if (i + j + k + l == n)
counter++;
return counter;
}
int main()
{
int n = 8;
cout << countWays(n);
return 0;
}

Output:
Time complexity of above solution is O(n4)
Method 2 (Uses Dynamic Programming)

The idea is based on below recursive solution.

countWays(n, parts, nextPart) = ∑countWays(n, parts, i)
nextPart <= i <= n
n --> Input number

parts --> Count of parts of n. Initially parts = 4
nextPart --> Starting point for next part to be tried
We try for all values from nextPart to n.
We initially call the function as countWays(n, 4, 1)

Below is Dynamic Programming based on solution of above idea.
int dp[5001][5001][5];
int countWaysUtil(int n, int parts, int nextPart)

{

if (parts == 0 && n == 0) return 1;
if (n <= 0 || parts <= 0) return 0;

if (dp[n][nextPart][parts] != -1)
return dp[n][nextPart][parts];
int ans = 0;

for (int i = nextPart; i <= n; i++)
ans += countWaysUtil(n-i, parts-1, i);

return (dp[n][nextPart][parts] = ans);
}
int countWays(int n)
{
memset(dp, -1, sizeof(dp));
return countWaysUtil(n, 4, 1);
}
int main()
{
int n = 8;
cout << countWays(n) << endl;
return 0;
}

Output:
Time complexity of this solution is O(n3). There are Θ(n2) entries, every entry is filled only once and filling
an entry takes O(n) time.
Method 3 (A O(n 2 Log n) Solution)

We can use the solution discussed in this post to find all quadruplets.
Thanks to Gaurav Ahirwar for suggesting above solutions.Please write comments if you find anything
Orientation of 3 ordered points
Orientation of an ordered triplet of points in the plane can be
counterclockwise
clockwise
colinear
The following diagram shows different possible orientations of (a, b, c)
If orientation of (p1, p2, p3) is collinear, then orientation of (p3, p2, p1) is also collinear.
If orientation of (p1, p2, p3) is clockwise, then orientation of (p3, p2, p1) is counterclockwise and vice versa
is also true.
Given three points p1, p2 and p3, find orientation of (p1, p2, p3).
Example:

Input: p1 = {0, 0}, p2 = {4, 4}, p3 = {1, 2}
Output: CounterClockWise
Input: p1 = {0, 0}, p2 = {4, 4}, p3 = {1, 1}

Output: Colinear

How to compute Orientation?

The idea is to use slope.
Slope of line segment (p1, p2): σ = (y2 - y1)/(x2 - x1)

Slope of line segment (p2, p3): τ = (y3 - y2)/(x3 - x2)
If σ τ, the orientation is clockwise (right turn)
Using above values of σ and τ, we can conclude that,

the orientation depends on sign of below expression:
(y2 - y1)*(x3 - x2) - (y3 - y2)*(x1 - x1)
Above expression is negative when σ τ, i.e., clockwise


// A C++ program to find orientation of three points
#include <iostream>
struct Point
{
int x, y;
};
// To find orientation of ordered triplet (p1, p2, p3).

// 1 --> Clockwise
int orientation(Point p1, Point p2, Point p3)
{
// See 10th slides from following link for derivation
// of the formula
int val = (p2.y - p1.y) * (p3.x - p2.x) -
(p2.x - p1.x) * (p3.y - p2.y);

}

int main()
{
Point p1 = {0, 0}, p2 = {4, 4}, p3 = {1, 2};
int o = orientation(p1, p2, p3);
if (o==0) cout << "Linear";
else if (o == 1) cout << "Clockwise";
else cout << "CounterClockwise";
return 0;
}

Output:

CounterClockwise

The concept of orientation is used in below articles:

Find Simple Closed Path for a given set of points
Convex Hull | Set 1 (Jarvis’s Algorithm or Wrapping)
Convex Hull | Set 2 (Graham Scan)
Source:
Zeckendorf’s Theorem (Non-Neighbouring Fibonacci Representation)
Zeckendorf’s theorem states that every positive Every positive integer can be written uniquely as a sum of
distinct non-neighbouring Fibonacci numbers. Two Fibonacci numbers are neighbours if they one come
after other in Fibonacci Sequence (0, 1, 1, 2, 3, 5, ..). For example, 3 and 5 are neighbours, but 2 and 5 are
not.
Given a number, find a representation of number as sum of non-consecutive Fibonacci numbers.
Examples:

Input: n = 10
Output: 8 2
8 and 2 are two non-consecutive Fibonacci Numbers
and sum of them is 10.
Input: n = 30
Output: 21 8 1
21, 2 and 1 are non-consecutive Fibonacci Numbers
and sum of them is 10.

The idea is to use Greedy Algorithm.

1) Let n be input number
2) While n >= 0
a) Find the greatest Fibonacci Number smaller than n.
Let this number be 'f'. Print 'f'
b) n = n - f


// C++ program for Zeckendorf's theorem. It finds representation
// of n as sum of non-neighbouring Fibonacci Numbers.
// Returns the greatest Fibonacci Numberr smaller than

// or equal to n.
int nearestSmallerEqFib(int n)
{
// Corner cases
if (n == 0 || n==1)
return n;
// Find the greatest Fibonacci Number smaller

// than n.
int f1 = 0, f2 = 1, f3 = 1;
while (f3 <= n)
{
f1 = f2;
f2 = f3;
f3 = f1+f2;
}
return f2;
}
// Prints Fibonacci Representation of n using

// greedy algorithm
void printFibRepresntation(int n)
{
while (n>0)
{
// Find the greates Fibonacci Number smaller
// than or equal to n
int f = nearestSmallerEqFib(n);
// Print the found fibonacci number

cout << f << " ";
// Reduce n
n = n-f;
}
}
// Driver method to test

int main()
{
int n = 30;
cout << "Non-neighbouring Fibonacci Representation of "
<< n << " is \n";
printFibRepresntation(n);
return 0;
}

Output:

Non-neighbouring Fibonacci Representation of 30 is
21 8 1

How does above Greedy Algorithm work?

Let the greatest Fibonacci number smaller than or equal to ‘n’ be fib(i) [i’th Fibonacci Number].
Then n – fib(i) will have its own representation as sum of non-neighbouring Fibonacci numbers.
All we want to make sure is that there is no neighbouring problem. By induction, n-fib(i) does not have
neighbouring problem, then the only way n could have a neighbouring problem is if n-fib(i) uses fib(i-1) in its
representation.
So all we have to further prove is that n-fib(i) does not use fib(i-1) in its representation
Let us prove it using contradiction. If n-fib(i) = fib(i-1) + fib(i-x) +…, then fib(i) cannot be the closest smallest
Fibonacci number to n, since fib(i) + fib(i-1) itself is fib(i+1).
So if n-fib(i) contains fib(i-1) in its representation then fib(i+1) would be closer smaller fib number to n,
contradicting our assumption that fib(i) is the closest smaller fib number to n.
This article is contributed by Gaurav Saxena. Please write comments if you find anything incorrect, or you
Find Simple Closed Path for a given set of points
Given a set of points, connect the dots without crossing.
Example:

Input: points[] = {(0, 3), (1, 1), (2, 2), (4, 4),
(0, 0), (1, 2), (3, 1}, {3, 3}};
Output: Connecting points in following order would

not cause any crossing
{(0, 0), (3, 1), (1, 1), (2, 2), (3, 3),
(4, 4), (1, 2), (0, 3)}

The idea is to use sorting.
1. Find the bottom-most point by comparing y coordinate of all points. If there are two points with same
y value, then the point with smaller x coordinate value is considered. Put the bottom-most point at
first position.
2. Consider the remaining n-1 points and sort them by polor angle in counterclockwise order around
points[0]. If polor angle of two points is same, then put the nearest point first.
3. Traversing the sorted array (sorted in increasing order of angle) yields simple closed path.
How to compute angles?

One solution is to use trigonometric functions.
Observation: We don’t care about the actual values of the angles. We just want to sort by angle.
Idea: Use the orientation to compare angles without actually computing them!

// A C++ program to find simple closed path for n points
struct Point
{
int x, y;
};
// A global point needed for sorting points with reference

// to the first point. Used in compare function of qsort()
Point p0;
// A utility function to swap two points

int swap(Point &p1, Point &p2)
{
Point temp = p1;
p1 = p2;
p2 = temp;
}
// A utility function to return square of distance between

// p1 and p2
// p1 and p2
int dist(Point p1, Point p2)
{
return (p1.x - p2.x)*(p1.x - p2.x) +
(p1.y - p2.y)*(p1.y - p2.y);
}

// 1 --> Clockwise
{
int val = (q.y - p.y) * (r.x - q.x) -
(q.x - p.x) * (r.y - q.y);

return (val > 0)? 1: 2; // clockwise or counterclock wise
}
// A function used by library function qsort() to sort

// an array of points with respect to the first point
int compare(const void *vp1, const void *vp2)
{
// Find orientation
int o = orientation(p0, *p1, *p2);
if (o == 0)
return (dist(p0, *p2) >= dist(p0, *p1))? -1 : 1;
return (o == 2)? -1: 1;

}
// Prints simple closed path for a set of n points.

void printClosedPath(Point points[], int n)
{
// Find the bottommost point
int ymin = points[0].y, min = 0;
for (int i = 1; i < n; i++)
{
int y = points[i].y;
// Pick the bottom-most. In case of tie, chose the

// left most point
if ((y < ymin) || (ymin == y &&
points[i].x < points[min].x))
ymin = points[i].y, min = i;
}
// Place the bottom-most point at first position

swap(points[0], points[min]);
// Sort n-1 points with respect to the first point.

// A point p1 comes before p2 in sorted ouput if p2
// has larger polar angle (in counterclockwise
// direction) than p1
p0 = points[0];
qsort(&points[1], n-1, sizeof(Point), compare);
// Now stack has the output points, print contents

// of stack
cout << "(" << points[i].x << ", "
<< points[i].y <<"), ";
}

int main()
{
Point points[] = {{0, 3}, {1, 1}, {2, 2}, {4, 4},
{0, 0}, {1, 2}, {3, 1}, {3, 3}};
printClosedPath(points, n);
return 0;
}

Output:

(0, 0), (3, 1), (1, 1), (2, 2), (3, 3),
(4, 4), (1, 2), (0, 3),

Time complexity of above solution is O(n Log n) if we use a O(nLogn) sorting algorithm for sorting points.
Source:
Merge two sorted linked lists such that merged list is in reverse order
Given two linked lists sorted in increasing order. Merge them such a way that the result list is in decreasing
order (reverse order).
Examples:

Input: a: 5->10->15->40
b: 2->3->20
Output: res: 2->3->5->10->15->20->40
Input: a: NULL
b: 2->3->20
Output: res: 20->3->2

A Simple Solution is to do following.

1) Reverse first list ‘a’.
2) Reverse second list ‘b’.
3) Merge two reversed lists.
Another Simple Solution is first Merge both lists, then reverse the merged list.
Both of the above solutions require two traversals of linked list.
How to solve without reverse, O(1) auxiliary space and only one traversal of both lists?
The idea is to follow merge style process. Initialize result list as empty. Traverse both lists from beginning to
end. Compare current nodes of both lists and insert smaller of two at the beginning of the result list.

1) Initialize result list as empty: res = NULL.
2) Let 'a' and 'b' be heads first and second lists respectively.
3) While (a != NULL and b != NULL)
a) Find the smaller of two (Current 'a' and 'b')
b) Insert the smaller value node at the front of result.
c) Move ahead in the list of smaller node.
4) If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
5) If 'a' becomes NULL before 'b', insert all nodes of 'a'
into result list at the beginning.

Below is C++ implementation of above solution.

#include<iostream>
struct Node
{
int key;
int key;
struct Node* next;
};
Node* SortedMerge(Node *a, Node *b)

{

if (a==NULL && b==NULL) return NULL;

Node *res = NULL;

while (a != NULL && b != NULL)
{

if (a->key <= b->key)
{

if (res == NULL)
{

res = a;

a = a->next;
res->next = NULL;
}
else
{

Node *temp = a->next;

a->next = res;
res = a;

a = temp;
}
}

else
{
if (res == NULL)
{
res = b;
b = b->next;
res->next = NULL;
}
else
{
Node *temp = b->next;
b->next = res;
res = b;
b = temp;
}
}
}
}

while (a != NULL)
{
Node *temp = a->next;
a->next = res;
res = a;
a = temp;
}

while (b != NULL)
{
Node *temp = b->next;
b->next = res;
res = b;
b = temp;
}
return res;
}
void printList(struct Node *Node)

{
while (Node!=NULL)
{
cout << Node->key << " ";
Node = Node->next;
}
}

{
temp->key = key;
temp->next = NULL;
return temp;
}
int main()
{

struct Node* res = NULL;

Node *a = newNode(5);
a->next = newNode(10);
a->next->next = newNode(15);
Node *b = newNode(2);
b->next = newNode(3);
b->next->next = newNode(20);
cout << "List A before merge: \n";
printList(a);
cout << "\nList B before merge: \n";

printList(b);

res = SortedMerge(a, b);
cout << "\nMerged Linked List is: \n";

printList(res);
return 0;
}

Output:

List A before merge:
5 10 15
List B before merge:
2 3 20
Merged Linked List is:
20 15 10 5 3 2

This solution traverses both lists only once, doesn’t require reverse and works in-place.
This article is contributed by Mohammed Raqeeb. Please write comments if you find anything incorrect,
Count number of squares in a rectangle
Given a m x n rectangle, how many squares are there in it?
Examples:

Input: m = 2, n = 2
Output: 5
There are 4 squares of size 1x1 +
1 square of size 2x2.
Input: m = 4, n = 3
Output: 24
There are 16 squares of size 1x1 +
6 squares of size 2x2 +
2 squares of size 3x3.

Let us first solve this problem for m = n, i.e., for a square:
For m = n = 1, output: 1
For m = n = 2, output: 4 + 1 [4 of size 1×1 + 1 of size 2×2]
For m = n = 3, output: 9 + 4 + 1 [4 of size 1×1 + 4 of size 2×2 + 1 of size 3×3]
For m = n = 4, output 16 + 9 + 4 + 1 [16 of size 1×1 + 9 of size 2×2 + 4 of size 3×3 + 1 of size 4×4]
In general, it seems to be n^2 + (n-1)^2 + … 1 = n(n+1)(2n+1)/6
Let us solve this problem when m may not be equal to n:
Let us assume that m <= n
From above explanation, we know that number of squares in a m x m matrix is m(m+1)(2m+1)/6
What happens when we add a column, i.e., what is the number of squares in m x (m+1) matrix?
When we add a column, number of squares increased is m + (m-1) + … + 3 + 2 + 1

[m squares of size 1×1 + (m-1) squares of size 2×2 + … + 1 square of size m x m]
Which is equal to m(m+1)/2

So when we add (n-m) columns, total number of squares increased is (n-m)*m(m+1)/2.
So total number of squares is m(m+1)(2m+1)/6 + (n-m)*m(m+1)/2.
Using same logic we can prove when n

Total number of squares = m x (m+1) x (2m+1)/6 +
(n-m) x m x (m+1)/2
when n is larger dimension

Using above logic for rectangle, we can also prove that number of squares in a square is n(n+1)(2n+1)/6
Below is C++ implementation of above formula.

// C++ program to count squares in a rectangle of
// size m x n
#include<iostream>
// Returns count of all squares in a rectangle

// of size m x n
int countSquares(int m, int n)
{
// If m is smaller, swap m and n
if (m < n)
swap(m, n);
// Now m is greater dimension, apply formula

return m*(m+1)*(2*m+1)/6 + (n-m)*m*(m+1)/2;
}
// Driver method
int main()
{
int m = 4, n = 3;
cout << "Count of squares is " << countSquares(m, n);
}

Count of Squares is 20
Source:
http://qa.geeksforgeeks.org/5669/find-how-many-square-matrix-in-given-matrix
discussed above
MO’s Algorithm (Query Square Root Decomposition) | Set 1 (Introduction)
Let us consider the following problem to understand MO’s Algorithm.
We are given an array and a set of query ranges, we are required to find sum of every query range.
Example:

Input: arr[] = {1, 1, 2, 1, 3, 4, 5, 2, 8};
query[] = [0, 4], [1, 3] [2, 4]
Output: Sum of arr[] elements in range [0, 4] is 8
Sum of arr[] elements in range [1, 3] is 4
Sum of arr[] elements in range [2, 4] is 6

A Naive Solution is to run a loop from L to R and calculate sum of elements in given range for every query
[L, R]

// Program to compute sum of ranges for different range
// queries.
// Structure to represent a query range

struct Query
{
int L, R;
};
// Prints sum of all query ranges. m is number of queries

// n is size of array.
void printQuerySums(int a[], int n, Query q[], int m)
{
// One by one compute sum of all queries
{
// Left and right boundaries of current range
int L = q[i].L, R = q[i].R;
// Compute sum of current query range

int sum = 0;
for (int j=L; j<=R; j++)
sum += a[j];
// Print sum of current query range

cout << "Sum of [" << L << ", "
<< R << "] is " << sum << endl;
}
}
// Driver program
int main()
{
int a[] = {1, 1, 2, 1, 3, 4, 5, 2, 8};
Query q[] = {{0, 4}, {1, 3}, {2, 4}};
int m = sizeof(q)/sizeof(q[0]);
printQuerySums(a, n, q, m);
return 0;
}

Output:

Sum of [0, 4] is 8
Sum of [1, 3] is 4
Sum of [2, 4] is 6

Time complexity of above solution is O(mn).
The idea of MO’s algorithm is to pre-process all queries so that result of one query can be used in next
query. Below are steps.
Let a[0…n-1] be input array and q[0..m-1] be array of queries.
1. Sort all queries in a way that queries with L values from 0 to √n-1 are put together, then all queries
from √n to 2*√n-1, and so on.
2. Process all queries one by one in a way that every query uses sum computed in previous query.
Let ‘sum’ be sum of previous query.
Remove extra elements of previous query. For example if previous query is [0, 8] and current
query is [3, 9], then we subtract a[0] and a[1] from sum
Add new elements of current query. In the same example as above, we add a[9] to sum.
The great thing about this algorithm is, in step 2, index variable for R change at most O(n * √n) times
throughout the run and same for L changes its value at most O(m * √n) times (See below, after the code, for
details). All these bounds are possible only because sorted queries first in blocks of √n size.
The preprocessing part takes O(m Log m) time.
Processing all queries takes O(n * √n) + O(m * √n) = O((m+n) * √n) time.

// Program to compute sum of ranges for different range
// queries
// Variable to represent block size. This is made global

// so compare() of sort can use it.
int block;

struct Query
{
int L, R;
};
// Function to sort all queries

bool compare(Query x, Query y)
{
// Different blocks, sort by block.
if (x.L/block != y.L/block)
return x.L/block < y.L/block;
// Same block, sort by R value

return x.R < y.R;
}
// Prints sum of all query ranges. m is number of queries

// n is size of array a[].
void queryResults(int a[], int n, Query q[], int m)
{
// Find block size
block = (int)sqrt(n);
// Sort all queries so that queries of same blocks

// are arranged together.
sort(q, q + m, compare);
// Initialize current L, current R and current sum

int currL = 0, currR = 0;
int currSum = 0;
// Traverse through all queries

{
{
// L and R values of current range
// Remove extra elements of previous range. For

// example if previous range is [0, 3] and current
// range is [2, 5], then a[0] and a[1] are subtracted
while (currL < L)
{
currSum -= a[currL];
currL++;
}
// Add Elements of current Range

while (currL > L)
{
currSum += a[currL-1];
currL--;
}
while (currR <= R)
{
currSum += a[currR];
currR++;
}
// Remove elements of previous range. For example

// when previous range is [0, 10] and current range
// is [3, 8], then a[9] and a[10] are subtracted
while (currR > R+1)
{
currSum -= a[currR-1];
currR--;
}
// Print sum of current range

cout << "Sum of [" << L << ", " << R
<< "] is " << currSum << endl;
}
}
// Driver program
int main()
{
int a[] = {1, 1, 2, 1, 3, 4, 5, 2, 8};
Query q[] = {{0, 4}, {1, 3}, {2, 4}};
queryResults(a, n, q, m);
return 0;
}

Output:

Sum of [1, 3] is 4
Sum of [0, 4] is 8
Sum of [2, 4] is 6

The output of above program doesn’t print results of queries in same order as input, because queries are
sorted. The program can be easily extended to keep the same order.
Important Observations:
1. All queries are known beforehead so that they can be preprocessed

2. It cannot work for problems where we have update operations also mixed with sum queries.
3. MO’s algorithm can only be useful for query problems where a query can be computed from results of
previous query. One more such example is maximum or minimum.
Time Complexity Analysis:

The function mainly runs a for loop for all sorted queries. Inside the for loop, there are four while queries
that move ‘currL’ and ‘currR’.
How much currR is moved? For each block, queries are sorted in increasing order of R. So, for a block,
currR moves in increasing order. In worst case, before beginning of every block, currR at extreme right and
current block moves it back the extreme left. This means that for every block, currR moves at most O(n).
Since there are O(√n) blocks, total movement of currR is O(n * √n).
How much currL is moved? Since all queries are sorted in a way that L values are grouped by blocks,
movement is O(√n) when we move from one query to another quert. For m queries, total movement of
currL is O(m * √n)
Please note that a Simple and more Efficient solution to solve this problem is to compute prefix sum for all
elements from 0 to n-1. Let the prefix sum be stored in an array preSum[] (The value of preSum[i] stores
sum of arr[0..i]). Once we have built preSum[], we can traverse through all queries one by one. For every
query [L, R], we return value of preSum[R] – preSum[L]. Here processing every query takes O(1) time.
The idea of this article is to introduce MO’s algorithm with a very simple example. We will soon be
discussing more interesting problems using MO’s algorithm.
References:
http://blog.anudeep2011.com/mos-algorithm/
This article is contributed by Ruchir Garg. Please write comments if you find anything incorrect, or you
Range Minimum Query for Static Array
We have an array arr[0 . . . n-1]. We should be able to efficiently find the minimum value from index L
(query start) to R (query end) where 0 L R n-1. Consider a situation when there are many range queries.
Example:

Input: arr[] = {7, 2, 3, 0, 5, 10, 3, 12, 18};
query[] = [0, 4], [4, 7], [7, 8]
Output: Minimum of [0, 4] is 0

Minimum of [4, 7] is 3

A simple solution is to run a loop from L to R and find minimum element in given range. This solution
takes O(n) time to query in worst case.
Another approach is to use Segment tree. With segment tree, preprocessing time is O(n) and time to for
range minimum query is O(Logn). The extra space required is O(n) to store the segment tree. Segment tree
allows updates also in O(Log n) time.
How to optimize query time when there are no update operations and there are many range minimum
queries?
Below are different methods.
Method 1 (Simple Solution)

A Simple Solution is to create a 2D array lookup[][] where an entry lookup[i][j] stores the minimum value in
range arr[i..j]. Minimum of a given range can now be calculated in O(1) time.

// C++ program to do range minimum query in O(1) time with O(n*n)
// extra space and O(n*n) preprocessing time.
#define MAX 500
// lookup[i][j] is going to store index of minimum value in

// arr[i..j]

struct Query
{
int L, R;
};
// Fills lookup array lookup[n][n] for all possible values of

// query ranges
void preprocess(int arr[], int n)
{
// Initialize lookup[][] for the intervals with length 1
for (int i = 0; i < n; i++)
lookup[i][i] = i;
// Fill rest of the entries in bottom up manner

{
for (int j = i+1; j<n; j++)
// To find minimum of [0,4], we compare minimum of

// arr[lookup[0][3]] with arr[4].
if (arr[lookup[i][j - 1]] < arr[j])
lookup[i][j] = lookup[i][j - 1];
else
lookup[i][j] = j;
}
}
// Prints minimum of given m query ranges in arr[0..n-1]

void RMQ(int arr[], int n, Query q[], int m)
{
// Fill lookup table for all possible input queries
preprocess(arr, n);

{

cout << "Minimum of [" << L << ", "
<< R << "] is " << arr[lookup[L][R]] << endl;
}
}
// Driver program
int main()
{
int a[] = {7, 2, 3, 0, 5, 10, 3, 12, 18};
Query q[] = {{0, 4}, {4, 7}, {7, 8}};
RMQ(a, n, q, m);
return 0;
}

Output:


This approach supports query in O(1), but preprocessing takes O(n2) time. Also, this approach needs
O(n2) extra space which may become huge for large input arrays.
Method 2 (Square Root Decomposition)

We can use Square Root Decompositions to reduce space required in above method.
Preprocessing:
1) Divide the range [0, n-1] into different blocks of √n each.
2) Compute minimum of every block of size √n and store the results.
Preprocessing takes O(√n * √n) = O(n) time and O(√n) space.
Query:
1) To query a range [L, R], we take minimum of all blocks that lie in this range. For left and right corner
blocks which may partially overlap with given range, we linearly scan them to find minimum.
Time complexity of query is O(√n). Note that we have minimum of middle block directly accessible and
there can be at most O(√n) middle blocks. There can be atmost two corner blocks that we may have to scan,
so we may have to scan 2*O(√n) elements of corner blocks. Therefore, overall time complexity is O(√n).
Method 3 (Sparse Table Algorithm)

The above solution requires only O(√n) space, but takes O(√n) time to query. Sparse table method supports
query time O(1) with extra space less than O(n2).
The idea is to precompute minimum of all subarrays of size 2j where j varies from 0 to Log n. Like method
1, we make a lookup table. Here lookup[i][j] contains minimum of range starting from i and of size 2j. For
example lookup[0][3] contains minimum of range [0, 7] (starting with 0 and of size 23)
Preprocessing:
How to fill this lookup table? The idea is simple, fill in bottom up manner using previously computed values.
For example, to find minimum of range [0, 7], we can use minimum of following two.
a) Minimum of range [0, 3]
b) Minimum of range [4, 7]
Based on above example, below is formula,

// If arr[lookup[0][3]] <= arr[lookup[4][7]],
// then lookup[0][7] = lookup[0][3]
If arr[lookup[i][j-1]] <= arr[lookup[i+2j-1-1][j-1]]
lookup[i][j] = lookup[i][j-1]
// If arr[lookup[0][3]] > arr[lookup[4][7]],

// then lookup[0][7] = lookup[4][7]
Else
lookup[i][j] = lookup[i+2 j-1-1][j-1]

Query:
For any arbitrary range [l, R], we need to use ranges which are in powers of 2. The idea is to use closest
power of 2. We always need to do at most comparison (compare minimum of two ranges which are powers of
2). One range starts with L and and ends with “L + closest-power-of-2″. The other range ends at R and starts
with “R – same-closest-power-of-2 + 1″. For example, if given range is (2, 10), we compare minimum of two
ranges (0, 7) and (3, 10).
Based on above example, below is formula,

// For (2,10), j = floor(Log2(10-2+1)) = 3
j = floor(Log(R-L+1))
// If arr[lookup[0][7]]
If arr[lookup[L][j]] // If arr[lookup[0][7]] > arr[lookup[3][10]],
// then RMQ(2,10) = lookup[3][10]
Else
RMQ(L, R) = lookup[i+2 j-1-1][j-1]

Since we do only one comparison, time complexity of query is O(1).

// C++ program to do range minimum query in O(1) time with
// O(n Log n) extra space and O(n Log n) preprocessing time
#define MAX 500
// lookup[i][j] is going to store index of minimum value in

// arr[i..j]. Ideally lookup table size should not be fixed and
// should be determined using n Log n. It is kept constant to
// keep code simple.

struct Query
{
int L, R;
};
// Fills lookup array lookup[][] in bottom up manner.

void preprocess(int arr[], int n)
{
// Initialize M for the intervals with length 1
for (int i = 0; i < n; i++)
lookup[i][0] = i;
// Compute values from smaller to bigger intervals

for (int j=1; (1<<j)<=n; j++)
{
// Compute minimum value for all intervals with size 2^j
for (int i=0; (i+(1<<j)-1) < n; i++)
{
// For arr[2][10], we compare arr[lookup[0][7]] and
// arr[lookup[3][10]]
if (arr[lookup[i][j-1]] < arr[lookup[i + (1<<(j-1))][j-1]])
lookup[i][j] = lookup[i][j-1];
else
lookup[i][j] = lookup[i + (1 << (j-1))][j-1];
}
}
}
// Returns minimum of arr[L..R]

int query(int arr[], int L, int R)
{
// For [2,10], j = 3
int j = (int)log2(R-L+1);
int j = (int)log2(R-L+1);
// For [2,10], we compare arr[lookup[0][7]] and

// arr[lookup[3][10]],
if (arr[lookup[L][j]] <= arr[lookup[R-(int)pow(2,j)+1][j]])
return arr[lookup[L][j]];
else return arr[lookup[R-(int)pow(2,j)+1][j]];

}
// Prints minimum of given m query ranges in arr[0..n-1]

void RMQ(int arr[], int n, Query q[], int m)
{
// Fills table lookup[n][Log n]
preprocess(arr, n);

{

cout << "Minimum of [" << L << ", "
<< R << "] is " << query(arr, L, R) << endl;
}
}
// Driver program
int main()
{
int a[] = {7, 2, 3, 0, 5, 10, 3, 12, 18};
Query q[] = {{0, 4}, {4, 7}, {7, 8}};
RMQ(a, n, q, m);
return 0;
}

Output:


So sparse table method supports query operation in O(1) time with O(n Log n) preprocessing time and O(n
Log n) space.
Print all Good numbers in given range
Given a digit ‘d’ and a range [L, R] where L 0, 6 > 2+0 and 9 > 6+2+0.
Example:

Input: L = 410, R = 520, d = 3
Output: 410 420 421 510 520
All the numbers in output are good (every digit is more
than sum of digits on right of it) and don't have digit 3.
Input: L = 410, R = 520, d = 1

Output: 420 430 520
All the numbers in output are good (every digit is more
than sum of digits on right of it) and don't have digit 3.

The idea is to traverse all numbers in given range. For every number, traverse all digits. While traversing
keep track of digit sum so far. At any point, if previous sum becomes more than or equal to sum, return
false. Also, if current digit becomes ‘d’, return false.

// C++ program to print good numbers in a given range [L, R]
// To check whether n is a good number and doesn't contain

// digit 'd'.
bool isValid(int n, int d)
{
// Get last digit and initialize sum from right side
int digit = n%10;
int sum = digit;
// If last digit is d, return

if (digit == d)
return false;
// Traverse remaining digits

n /= 10;
while (n)
{
// Current digit
digit = n%10;
// If digit is d or digit is less than or

// equal to sum of digits on right side
if (digit == d || digit <= sum)
return false;
// Update sum and n

else
{
sum += digit;
n /= 10;
}
}
return 1;
}
// Print Good numbers in range [L, R]

void printGoodNumbers(int L, int R, int d)
{
// Traverse all numbers in given range
for (int i=L; i<=R; i++)
{
// If current numbers is good, print it.
if (isValid(i, d))
cout << i << " ";
}
}
// Driver program
int main()
{
int L = 410, R = 520, d = 3;
// Print good numbers in [L, R]

printGoodNumbers(L, R, d);
return 0;
}

Output:

410 420 421 510 520

Source: http://qa.geeksforgeeks.org/5702/c-good-numbers?show=5702#q5702
discussed above
Fibonacci Coding
Fibonacci coding encodes an integer into binary number using Fibonacci Representation of the number. The
idea is based on Zeckendorf’s Theorem which states that states that every positive Every positive integer can
be written uniquely as a sum of distinct non-neighbouring Fibonacci numbers (0, 1, 1, 2, 3, 5, 8, 13, 21, 34,
55, 89, 141, ……..).
The Fibonacci code word for a particular integer is exactly the integer’s Zeckendorf representation with the
order of its digits reversed and an additional “1” appended to the end, this representation uniquely
represents every integer. The extra 1 is appended to indicate end of code (Note that the code never contain
two consecutive 1s as per Zeckendorf’s Theorem.
The representation uses Fibonacci numbers starting from 1 (2’nd Fibonacci Number). So the Fibonacci
Numbers used in this representation are 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 141, …….
Given a number n, print its Fibonacci code.
Examples:

Input: n = 1
Output: 11
1 is 2'nd Fibonacci number and an extra 1 is
appended at the end.
Input: n = 11
Output: 001011
11 is sum of 8 and 3. The last 1 represents extra 1
that is always added. A 1 before it represents 8. The
third 1 (from beginning) represents 3.

The following algorithm takes an integer as input and generates a string that stores Fibonacci Encoding.
Find the largest Fibonacci number f less than or equal to n. Say it is the i’th number in the Fibonacci series.
The length of codeword for n will be i+3 characters (One for extra 1 appended at the end, One because i is an
index, and one for ‘\0′). Assuming that the Fibonacci series is stored:
Let f be the largest Fibonacci less than or equal to n, prepend ‘1’ in the binary string. This indicates
usage of f in representation for n. Subtract f from n: n = n – f
Else if f is greater than n, prepend ‘0’ to the binary string.
Move to the Fibonacci number just smaller than f .
Repeat until zero remainder (n = 0)
Append an additional ‘1’ to the binary string. We obtain an encoding such that two consecutive 1s
indicate the end of a number (and the start of the next).

/* C program for Fibonacci Encoding of a positive integer n */
#include<stdio.h>
#include<stdlib.h>
#define N 30
/* Array to store fibonacci numbers. fib[i] is going

to store (i+2)'th Fibonacci number*/
int fib[N];
// Stores values in fib and returns index of the laargest
// fibonacci number smaller than n.
int largestFiboLessOrEqual(int n)
{
fib[0] = 1; // Fib[0] stores 2nd Fibonacci No.
fib[1] = 2; // Fib[1] stores 3rd Fibonacci No.
// Keep Generating remaining numbers while previously

// generated number is smaller
int i;
for (i=2; fib[i-1]<=n; i++)
fib[i] = fib[i-1] + fib[i-2];
// Return index of the largest fibonacci number

// smaller than or equal to n. Note that the above
// loop stopped when fib[i-1] became larger.
return (i-2);
}
/* Returns pointer to the char string which corresponds to code for n */

char* fibonacciEncoding(int n)
{
int index = largestFiboLessOrEqual(n);
//allocate memory for codeword

char *codeword = (char*)malloc(sizeof(char)*(index+3));
// index of the largest Fibonacci f <= n

int i = index;
while (n)
{
// Mark usage of Fibonacci f (1 bit)
codeword[i] = '1';
// Subtract f from n
n = n - fib[i];
// Move to Fibonacci just smaller than f

i = i - 1;
// Mark all Fibonacci > n as not used (0 bit), progress backwards

while (i>=0 && fib[i]>n)
{
codeword[i] = '0';
i = i - 1;
}
}
//additional '1' bit

codeword[index+1] = '1';
codeword[index+2] = '\0';
//return pointer to codeword

return codeword;
}
/* driver function */
int main()
{
int n = 20;
printf("Fibonacci code word for %d is %s\n", n, fibonacciEncoding(n));
return 0;
}

Output:

Fibonacci code word for 143 is 01010101011

Illustration
This article is contributed by Yash Varyani. Please write comments if you find anything incorrect, or you
Partition a set into two subsets such that the difference of subset sums is
minimum
Given a set of integers, the task is to divide it into two sets S1 and S2 such that the absolute difference
between their sums is minimum.
If there is a set S with n elements, then if we assume Subset1 has m elements, Subset2 must have n-m
elements and the value of abs(sum(Subset1) – sum(Subset2)) should be minimum.
Example:

Input: arr[] = {1, 6, 11, 5}
Output: 1
Explanation:
Subset1 = {1, 5, 6}, sum of Subset1 = 12
Subset2 = {11}, sum of Subset2 = 11

This problem is mainly an extension to the Dynamic Programming| Set 18 (Partition Problem).
Recursive Solution
The recursive approach is to generate all possible sums from all the values of array and to check which
solution is the most optimal one.
To generate sums we either include the i’th item in set 1 or don’t include, i.e., include in set 2.

// A Recursive C program to solve minimum sum partition
// problem.
// Function to find the minimum sum

int findMinRec(int arr[], int i, int sumCalculated, int sumTotal)
{
// If we have reached last element. Sum of one
// subset is sumCalculated, sum of other subset is
// sumTotal-sumCalculated. Return absolute difference
// of two sums.
if (i==0)
return abs((sumTotal-sumCalculated) - sumCalculated);
// For every item arr[i], we have two choices

// (1) We do not include it first set
// (2) We include it in first set
// We return minimum of two choices
return min(findMinRec(arr, i-1, sumCalculated+arr[i-1], sumTotal),
findMinRec(arr, i-1, sumCalculated, sumTotal));
}
// Returns minimum possible difference between sums

// of two subsets
int findMin(int arr[], int n)
{
// Compute total sum of elements
int sumTotal = 0;
sumTotal += arr[i];
// Compute result using recursive function

return findMinRec(arr, n, 0, sumTotal);
}

int main()
{
int arr[] = {3, 1, 4, 2, 2, 1};
cout << "The minimum difference between two sets is "
<< findMin(arr, n);
return 0;
}

Output:

The minimum difference between two sets is 1

Time Complexity:

All the sums can be generated by either
(1) including that element in set 1.
(2) without including that element in set 1.
So possible combinations are :-
arr[0] (1 or 2) -> 2 values
arr[1] (1 or 2) -> 2 values
.
.
.
arr[n] (2 or 2) -> 2 values
So time complexity will be 2*2*..... *2 (For n times),
that is O(2^n).

Dynamic Programming
The problem can be solved using dynamic programming when the sum of the elements is not too big. We
can create a 2D array dp[n+1][sum+1] where n is number of elements in given set and sum is sum of all
elements. We can construct the solution in bottom up manner.

The task is to divide the set into two parts.
We will consider the following factors for dividing it.
Let
dp[n+1][sum+1] = {1 if some subset from 1st to i'th has a sum
equal to j
0 otherwise}

i ranges from {1..n}
j ranges from {0..(sum of all elements)}
So
dp[n+1][sum+1] will be 1 if
1) The sum j is achieved including i'th item
2) The sum j is achieved excluding i'th item.
Let sum of all the elements be S.
To find Minimum sum difference, w have to find j such

that Min{sum - j*2 : dp[n][j] == 1 }
where j varies from 0 to sum/2
The idea is, sum of S1 is j and it should be closest

to sum/2, i.e., 2*j should be closest to sum.

Below is C++ implementation of above code.

// A Recursive C program to solve minimum sum partition
// problem.
// Returns the minimum value of the difference of the two sets.

int findMin(int arr[], int n)
{
// Calculate sum of all elements
int sum = 0;
for (int i = 0; i < n; i++)
for (int i = 0; i < n; i++)
sum += arr[i];
// Create an array to store results of subproblems

bool dp[n+1][sum+1];
// Initialize first column as true. 0 sum is possible

// with all elements.
for (int i = 0; i <= n; i++)
dp[i][0] = true;
// Initialize top row, except dp[0][0], as false. With

// 0 elements, no other sum except 0 is possible
dp[0][i] = false;
// Fill the partition table in bottom up manner

{
for (int j=1; j<=sum; j++)
{
// If i'th element is excluded
dp[i][j] = dp[i-1][j];
// If i'th element is included

if (arr[i-1] <= j)
dp[i][j] |= dp[i-1][j-arr[i-1]];
}
}

// Initialize difference of two sums.
int diff = INT_MAX;

// Find the largest j such that dp[n][j]
// is true where j loops from sum/2 t0 0
for (int j=sum/2; j>=0; j--)
{
// Find the
if (dp[n][j] == true)
{
diff = sum-2*j;
break;
}
}
return diff;
}

int main()
{
int arr[] = {3, 1, 4, 2, 2, 1};
cout << "The minimum difference between 2 sets is "
<< findMin(arr, n);
return 0;
}

Output:

The minimum difference between 2 sets is 1

Time Complexity = O(n*sum) where n is number of elements and sum is sum of all elements.
Note that the above solution is in Pseudo Polynomial Time (time complexity is dependent on numeric value
of input).
This article is contributed by Abhiraj Smit. Please write comments if you find anything incorrect, or you
Fibonacci Search
Given a sorted array arr[] of size n and an element x to be searched in it. Return index of x if it is present in
array else return -1.
Examples:

Input: arr[] = {2, 3, 4, 10, 40}, x = 10
Output: 3
Element x is present at index 3.
Input: arr[] = {2, 3, 4, 10, 40}, x = 11

Output: -1
Element x is not present.

Fibonacci Search is a comparison-based technique that uses Fibonacci numbers to search an element in a
sorted array.
Similarities with Binary Search:
1. Works for sorted arrays

2. A Divide and Conquer Algorithm.
3. Has Log n time complexity.
Differences with Binary Search >
1. Fibonacci Search divides given array in unequal parts

2. Binary Search uses division operator to divide range. Fibonacci Search doesn’t use /, but uses + and -.
The division operator may be costly on some CPUs.
3. Fibonacci Search examines relatively closer elements in subsequent steps. So when input array is big
that cannot fit in CPU cache or even in RAM, Fibonacci Search can be useful.
Background:
Fibonacci Numbers are recursively defined as F(n) = F(n-1) + F(n-2), F(0) = 0, F(1) = 1. First few Fibinacci
Numbers are 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, …
Observations:
Below observation is used for range elimination, and hence for the O(log(n)) complexity.

F(n - 2) ≈ (1/3)*F(n) and
F(n - 1) ≈ (2/3)*F(n).

Algorithm:
Let the searched element be x.
The idea it to first find the smallest Fibonacci number that is greater than or equal to length of given array.
Let the found fibonacci number be fib (m’th fibonacci number). We use (m-2)’th Fibonacci number as index
(If it is a valid index). Let (m-2)’th Fibonacci Number be i, we compare arr[i] with x, if x is same, we return i.
Else if x is greater, we recur for subarray after i, else we recur for subarray before i.
Below is complete algorithm

Let arr[0..n-1] be th input array and element to be searched be x.
1. Find the smallest Fibonacci Number greater than or equal n. Let this number be fibM [m’th Fibonacci
Number]. Let the two Fibonacci numbers preceding it be fibMm1 [(m-1)’th Fibonacci Number and
fibMm2 [(m-2)’th Fibonacci Number.
2. While the array has elements to be inspected:
a. Compare x with the last element of the range covered by fibMm2
b. If x matches, return index
c. Else If x is less than the element, move the three Fibonacci variables two Fibonacci down,
indicating elimination of approximately rear two-third of the remaining array.
d. Else x is greater than the element, move the three Fibonacci variables one Fibonacci down.
Reset offset to index. Together these indicate elimination of approximately front one-third of
the remaining array.

// C program for Fibonacci Search
#include <stdio.h>
// Utility function to find minimum of two elements

int min(int x, int y) { return (x<=y)? x : y; }
/* Returns index of x if present, else returns -1 */

int fibMonaccianSearch(int arr[], int x, int n)
{
/* Initialize fibonacci numbers */
int fibMMm2 = 0; // (m-2)'th Fibonacci No.
int fibMMm1 = 1; // (m-1)'th Fibonacci No.
int fibM = fibMMm2 + fibMMm1; // m'th Fibonacci
/* fibM is going to store the smallest Fibonacci

Number greater than or equal to n */
while (fibM < n)
{
fibMMm2 = fibMMm1;
fibMMm1 = fibM;
fibM = fibMMm2 + fibMMm1;
}
// Marks the eliminated range from front

int offset = -1;
/* while there are elements to be inspected. Note that

we compare arr[fibMm2] with x. When fibM becomes 2,
fibMm2 becomes 0 */
while (fibM > 1)
{
// Check if fibMm2 is a valid location
int i = min(offset+fibMMm2, n-1);
/* If x is greater than the value at index fibMm2,

cut the subarray array from offset to i */
if (arr[i] < x)
{
fibM = fibMMm1;
fibMMm1 = fibMMm2;
fibMMm2 = fibM - fibMMm1;
offset = i;
}
/* If x is greater than the value at index fibMm2,

cut the subarray after i+1 */
else if (arr[i] > x)
{
fibM = fibMMm2;
fibMMm1 = fibMMm1 - fibMMm2;
fibMMm2 = fibM - fibMMm1;
}
/* element found. return index */

else return i;
}
/*element not found. return -1 */

return -1;
}
/* driver function */
int main(void)
{
int arr[] = {10, 22, 35, 40, 45, 50, 80, 82,
85, 90, 100};
int x = 85;
printf("Found at index: %d",
fibMonaccianSearch(arr, x, n));
return 0;
}

Output:

Found at index 8

Illustration:
Let us understand the algorithm with below example:
Illustration assumption: 1-based indexing. Target element x is 85. Length of array n = 11.
Smallest Fibonacci number greate than or equal to 11 is 13. As per our illustration, fibMm2 = 5, fibMm2 = 8,
and fibM = 13.
Another implementation detail is the offset variable (zero initialized). It marks the range that has been
eliminated, starting from the front. We will update it time to time.
Now since the offset value is an index and all indices inclusive it and below it have been eliminated, it only
makes sense to add something to it. Since fibMm2 marks approximately one-third of our array, as well as the
indices it marks are sure to be valid ones, we can add fibMm2 to offset and check the element at index i =
min(offset + fibL, n ).
Visualization:
Time Complexity analysis:

The worst case will occur when we have our target in the larger (?) fraction of the array, as we proceed
finding it. In other words, we are eliminating the smaller (?) fraction of the array every time. We call once for
n, then for ? n, then for 4/9 n and henceforth.
Consider that:
References:
https://en.wikipedia.org/wiki/Fibonacci_search_technique
Compute nCr % p | Set 2 (Lucas Theorem)
Given three numbers n, r and p, compute value of nCr mod p.
Examples:

Input: n = 10, r = 2, p = 13
Output: 6
Explanation: 10C2 is 45 and 45 % 13 is 6.
Input: n = 1000, r = 900, p = 13

Output: 8

Compute nCr % p | Set 1 (Introduction and Dynamic Programming Solution)
We have introduced overflow problem and discussed Dynamic Programming based solution in above set 1.
The time complexity of the DP based solution is O(n*r) and it required O(n) space. The time taken and extra
space become very high for large values of n, especially values close to 109.
In this post, Lucas Theorem based solution is discussed. Time complexity of this solution is O(p2 * Logp n)
and it requires only O(p) space.
Lucas Theorem:
Using Lucas Theorem for n Cr % p:

Lucas theorem basically suggests that the value of nCr can be computed by multiplying results of niCri
where ni and ri are individual same-positioned digits in base p representations of n and r respectively.
.
The idea is to one by one compute niCr i for individual digits ni and ri in base p. We can compute these values
DP based solution discussed in previous post. Since these digits are in base p, we would never need more
than O(p) space and time complexity of these individual computations would be bounded by O(p2).

// A Lucas Theorem based solution to compute nCr % p
// Returns nCr % p. In this Lucas Theorem based program,

// this function is only called for n < p and r < p.
int nCrModpDP(int n, int r, int p)
{
// The array C is going to store last row of
// pascal triangle at the end. And last entry
// of last row is nCr
int C[r+1];
memset(C, 0, sizeof(C));
C[0] = 1; // Top row of Pascal Triangle
// One by constructs remaining rows of Pascal

// Triangle from top to bottom
for (int i = 1; i <= n; i++)
{
// Fill entries of current row using previous
// row values
for (int j = min(i, r); j > 0; j--)
// nCj = (n-1)Cj + (n-1)C(j-1);

C[j] = (C[j] + C[j-1])%p;
}
return C[r];
}
// Lucas Theorem based function that returns nCr % p

// This function works like decimal to binary conversion
// recursive function. First we compute last digits of
// n and r in base p, then recur for remaining digits
int nCrModpLucas(int n, int r, int p)
{
// Base case
if (r==0)
return 1;
// Compute last digits of n and r in base p

int ni = n%p, ri = r%p;
// Compute result for last digits computed above, and

// for remaining digits. Multiply the two results and
// compute the result of multiplication in modulo p.
return (nCrModpLucas(n/p, r/p, p) * // Last digits of n and r
nCrModpDP(ni, ri, p)) % p; // Remaining digits
}
// Driver program
int main()
{
int n = 1000, r = 900, p = 13;
cout << "Value of nCr % p is " << nCrModpLucas(n, r, p);
return 0;
}

Output:

Value of nCr % p is 8

Time Complexity: Time complexity of this solution is O(p2 * Logp n). There are O(Logp n) digits in base p
representation of n. Each of these digits is smaller than p, therefore, computations for individual digits take
O(p2). Note that these computations are done using DP method which takes O(n*r) time.
Chinese Remainder Theorem | Set 1 (Introduction)
We are given two arrays num[0..k-1] and rem[0..k-1]. In num[0..k-1], every pair is coprime (gcd for every
pair is 1). We need to find minimum positive number x such that:

x % num[0] = rem[0],
x % num[1] = rem[1],
.......................
x % num[k-2] = rem[k-1]

Basically, we are given k numbers which are pairwise coprime, and given remainders of these numbers when
an unknown number x is divided by them. We need to find the minimum possible value of x that produces
given remainders.
Examples:

Input: num[] = {5, 7}, rem[] = {1, 3}
Output: 31
Explanation:
31 is the smallest number such that:
(1) When we divide it by 5, we get remainder 1.
Input: num[] = {3, 4, 5}, rem[] = {2, 3, 1}

Output: 11
Explanation:

Chinise Remainder Theorem states that there always exists an x that satisfies given
congruences. Below is theorem statement adapted from wikipedia.
Let num[0], num[1], …num[k-1] be positive integers that are pairwise coprime. Then, for any given sequence
of integers rem[0], rem[1], … rem[k-1], there exists an integer x solving the following system of simultaneous
congruences.
The first part is clear that there exist an x. The second part basically states that all solutions (including the
minimum one) produce the same remainder when divided by product of n[0], num[1], .. num[k-1]. In above
example, product is 3*4*5 = 60. And 11 is one solution, other solutions are 71, 131, .. etc. All these solutions
produce same remainder when divide by 60, i.e., they are of the form 11 + m*60 where m >= 0.
A Naive Approach to find x is to start with 1 and one by one increment it and check if dividing it with
given elements in num[] produces corresponding remainders in rem[]. Once we find such a x, we return it.
Below is C++ implementation of Naive Approach.
int findMinX(int num[], int rem[], int k)

{
int x = 1;

while (true)
{

int j;
for (j=0; j<k; j++ )
if (x%num[j] != rem[j])
break;

if (j == k)
return x;

x++;
}
return x;
}
int main(void)
{
int num[] = {3, 4, 5};
int rem[] = {2, 3, 1};
int k = sizeof(num)/sizeof(num[0]);
cout << "x is " << findMinX(num, rem, k);
return 0;
}

Output:

x is 11

We will soon be discussing efficient methods to find x.
Find multiplication of sums of data of leaves at sane levels
Given a Binary Tree, return following value for it.
1) For every level, compute sum of all leaves if there are leaves at this level. Otherwise ignore it.
2) Return multiplication of all sums.
Examples:

2
/ \
7 5
\
9
Output: 63
First levels doesn't have leaves. Second level
has one leaf 7 and third level also has one
leaf 9. Therefore result is 7*9 = 63

2
/ \
7 5
/ \ \
8 6 9
/ \ / \
1 11 4 10
Output: 208
First two levels don't have leaves. Third
level has single leaf 8. Last level has four
leaves 1, 11, 4 and 10. Therefore result is
8 * (1 + 11 + 4 + 10)

One Simple Solution is to recursively compute leaf sum for all level starting from top to bottom. Then
multiply sums of levels which have leaves. Time complexity of this solution would be O(n2).
An Efficient Solution is to use Queue based level order traversal. While doing the traversal, process all
different levels separately. For every processed level, check if it has a leaves. If it has then compute sum of
leaf nodes. Finally return product of all sums.

struct Node
{
int data;
};
bool isLeaf(Node *root)
{
return (!root->left && !root->right);
}

int sumAndMultiplyLevelData(Node *root)
{

if (!root)
return 0;
int mul = 1;

queue<Node *> q;

q.push(root);

while (1)
{

int NodeCount = q.size();

if (NodeCount == 0)
break;

int levelSum = 0;

bool leafFound = false;

while (NodeCount > 0)
{

Node *Node = q.front();

if (isLeaf(Node))
{
leafFound = true;
levelSum += Node->data;
}
q.pop();

if (Node->left != NULL)
q.push(Node->left);
if (Node->right != NULL)
q.push(Node->right);
NodeCount--;
}

if (leafFound)
mul *= levelSum;
}
return mul;
}

{
temp->data = data;
return temp;
}
int main()
{
cout << "Final product value = "

<< sumAndMultiplyLevelData(root) << endl;
return 0;
}

Output:

Final product value = 208

This article is contributed by Mohammed Raqeeb. Please write comments if you find anything incorrect, or
Compute nCr % p | Set 1 (Introduction and Dynamic Programming
Solution)
Given three numbers n, r and p, compute value of nCr mod p.
Example:

Input: n = 10, r = 2, p = 13
Output: 6
Explanation: 10C2 is 45 and 45 % 13 is 6.

A Simple Solution is to first compute nCr , then compute nCr % p. This solution works fine when the value
of nCr is small.
What if the value of n Cr is large?

The value of nCr %p is generally needed for large values of n when nCr cannot fit in a variable, and causes
overflow. So computing nCr and then using modular operator is not a good idea as there will be overflow
even for slightly larger values of n and r. For example the methods discussed here and here cause overflow
for n = 50 and r = 40.
The idea is to compute nCr using below formula

C(n, r) = C(n-1, r-1) + C(n-1, r)
C(n, 0) = C(n, n) = 1

Working of Above formula and Pascal Triangle:

Let us see how above formula works for C(4,3)
1==========>> n = 0, C(0,0) = 1
1–1========>> n = 1, C(1,0) = 1, C(1,1) = 1
1–2–1======>> n = 2, C(2,0) = 1, C(2,1) = 2, C(2,2) = 1
1–3–3–1====>> n = 3, C(3,0) = 1, C(3,1) = 3, C(3,2) = 3, C(3,3)=1
1–4–6–4–1==>> n = 4, C(4,0) = 1, C(4,1) = 4, C(4,2) = 6, C(4,3)=4, C(4,4)=1
So here every loop on i, builds i’th row of pascal triangle, using (i-1)th row
Extension of above formula for modular arithmetic:

We can use distributive property of modulor operator to find nCr % p using above formula.

C(n, r)%p = [ C(n-1, r-1)%p + C(n-1, r)%p ] % p
C(n, 0) = C(n, n) = 1

The above formula can implemented using Dynamic Programming using a 2D array.
The 2D array based dynamic programming solution can be further optimized by constructing one row at a
time. See Space optimized version in below post for details.
Binomial Coefficient using Dynamic Programming
Below is C++ implementation based on the space optimized version discussed in above post.

// A Dynamic Programming based solution to compute nCr % p
// Returns nCr % p
int nCrModp(int n, int r, int p)
{
// The array C is going to store last row of
// pascal triangle at the end. And last entry
// of last row is nCr
int C[r+1];
memset(C, 0, sizeof(C));
C[0] = 1; // Top row of Pascal Triangle
// One by constructs remaining rows of Pascal

// Triangle from top to bottom
for (int i = 1; i <= n; i++)
{
// Fill entries of current row using previous
// row values
for (int j = min(i, r); j > 0; j--)
// nCj = (n-1)Cj + (n-1)C(j-1);

C[j] = (C[j] + C[j-1])%p;
}
return C[r];
}
// Driver program
int main()
{
int n = 10, r = 2, p = 13;
cout << "Value of nCr % p is " << nCrModp(n, r, p);
return 0;
}

Output:

Value of nCr % p is 6

Time complexity of above solution is O(n*r) and it requires O(n) space. There are more and better solutions
to above problem. We will soon be discussing them in separate posts.
discussed above.
Euclid’s lemma
We are given two numbers x and y. We know that a number p divides their product. Can we say for sure that
p also divides one of them?
The answer is no. For example, consider x = 15, y = 6 and p = 9. p divides the product 15*6, but doesn’t
divide any of them.
What if p is prime?
Euclid’s lemma states that if a prime p divides the product of two numbers (x*y), it must divide at least one
of those numbers.
For example x = 15, y = 6 and p = 5. p divides the product 15*6, it also divides 15.
Generalization of Euclid’s lemma:

If p divides x*y and p is relatively prime to x, then p must divide y. In the above example, 5 is relatively prime
to 6, therefore it must divide 15.
Reference:
https://en.wikipedia.org/wiki/Euclid’s_lemma
discussed above
Chinese Remainder Theorem | Set 2 (Inverse Modulo based
Implementation)
We are given two arrays num[0..k-1] and rem[0..k-1]. In num[0..k-1], every pair is coprime (gcd for every
pair is 1). We need to find minimum positive number x such that:
x % num[0] = rem[0],
x % num[1] = rem[1],
.......................
x % num[k-2] = rem[k-1]

Example:

Input: num[] = {3, 4, 5}, rem[] = {2, 3, 1}
Output: 11
Explanation:

We strongly recommend to refer below post as a prerequisite for this.
Chinese Remainder Theorem | Set 1 (Introduction)
We have discussed a Naive solution to find minimum x. In this article, an efficient solution to find x is
discussed.
The solution is based on below formula.
x = ( ∑ (rem[i]*pp[i]*inv[i]) ) % prod
Where 0 <= i <= n-1
rem[i] is given array of remainders
prod is product of all given numbers

prod = num[0] * num[1] * ... * num[k-1]
pp[i] is product of all but num[i]

pp[i] = prod / num[i]
inv[i] = Modular Multiplicative Inverse of

pp[i] with respect to num[i]

Example:

Let us take below example to understand the solution
num[] = {3, 4, 5}, rem[] = {2, 3, 1}
prod = 60
pp[] = {20, 15, 12}
inv[] = {2, 3, 3} // (20*2)%3 = 1, (15*3)%4 = 1
// (12*3)%5 = 1
x = (rem[0]*pp[0]*inv[0] + rem[1]*pp[1]*inv[1] +
rem[2]*pp[2]*inv[2]) % prod
= (2*20*2 + 3*15*3 + 1*12*3) % 60
= (40 + 135 + 36) % 60
= 11

Refer this for nice visual explanation of above formula.
Below is C++ implementation of above formula. We can use Extended Euclid based method discussed here
to find inverse modulo.

// A C++ program to demonstrate working of Chinise remainder
// Theorem
// Returns modulo inverse of a with respect to m using extended

// Euclid Algorithm. Refer below post for details:
// http://www.geeksforgeeks.org/multiplicative-inverse-under-modulo-m/
int inv(int a, int m)
{
int m0 = m, t, q;
int x0 = 0, x1 = 1;
if (m == 1)
return 0;
// Apply extended Euclid Algorithm

while (a > 1)
{
// q is quotient
q = a / m;
t = m;
// m is remainder now, process same as

// euclid's algo
m = a % m, a = t;
t = x0;
x0 = x1 - q * x0;
x1 = t;
}
// Make x1 positive
if (x1 < 0)
x1 += m0;
return x1;
}
}
// k is size of num[] and rem[]. Returns the smallest

// number x such that:
// x % num[0] = rem[0],
// x % num[1] = rem[1],
// ..................
// x % num[k-2] = rem[k-1]
// Assumption: Numbers in num[] are pairwise coprime
// (gcd for every pair is 1)
int findMinX(int num[], int rem[], int k)
{
// Compute product of all numbers
int prod = 1;
for (int i = 0; i < k; i++)
prod *= num[i];
int result = 0;
// Apply above formula

for (int i = 0; i < k; i++)
{
int pp = prod / num[i];
result += rem[i] * inv(pp, num[i]) * pp;
}
return result % prod;

}
// Driver method
int main(void)
{
int num[] = {3, 4, 5};
int rem[] = {2, 3, 1};
int k = sizeof(num)/sizeof(num[0]);
cout << "x is " << findMinX(num, rem, k);
return 0;
}

Output:

x is 11

Primality Test | Set 3 (Miller–Rabin)
Given a number n, check if it is prime or not. We have introduced and discussed School and Fermat methods
for primality testing.

Primality Test | Set 2 (Fermat Method)
In this post, Miller-Rabin method is discussed. This method is a probabilistic method (Like Fermat), but it
generally preferred over Fermat’s method.
Algorithm:

// It returns false if n is composite and returns true if n
// is probably prime. k is an input parameter that determines
// accuracy level. Higher value of k indicates more accuracy.
bool isPrime(int n, int k)
1) Handle base cases for n r.
Note that since, n is even (n-1) must be even and r must be
greater than 0.
4) Do following k times
if (millerTest(n, d) == false)
return false
5) Return true.
// This function is called for all k trials. It returns

// false if n is composite and returns false if n is probably
// prime.
// d is an odd number such that d*2r = n-1 for some r >= 1
bool millerTest(int n, int d)
1) Pick a random number 'a' in range [2, n-2]
2) Compute: x = pow(a, d) % n
3) If x == 1 or x == n-1, return true.
// Below loop mainly runs 'r-1' times.

4) Do following while d doesn't become n-1.
a) x = (x*x) % n.
b) If (x == 1) return false.
c) If (x == n-1) return true.

Example:

Input: n = 13, k = 2.
1) Compute d and r such that d*2r = n-1,

d = 3, r = 2.
2) Call millerTest k times.
1st Iteration:
Suppose a = 4
x = 43 % 13 = 12
3) Since x = (n-1), return true.
IInd Iteration:
Suppose a = 5
x = 53 % 13 = 8
3) x neither 1 nor 12.
4) Do following (r-1) = 1 times

a) x = (x * x) % 13 = (8 * 8) % 13 = 12
b) Since x = (n-1), return true.
Since both iterations return true, we return true.

Implementation:

// C++ program Miller-Rabin primality test
// Utility function to do modular exponentiation.

// It returns (x^y) % p
{
// equal to p
while (y > 0)
{
if (y & 1)
res = (res*x) % p;

y = y>>1; // y = y/2
x = (x*x) % p;
}
return res;
}
// This function is called for all k trials. It returns

// false if n is composite and returns false if n is
// false if n is composite and returns false if n is
// probably prime.
// d is an odd number such that d*2<sup>r</sup> = n-1
// for some r >= 1
bool miillerTest(int d, int n)
{
// Pick a random number in [2..n-2]
// Corner cases make sure that n > 4
int a = 2 + rand() % (n - 4);
// Compute a^d % n
int x = power(a, d, n);
if (x == 1 || x == n-1)
return true;
// Keep squaring x while one of the following doesn't

// happen
// (i) d does not reach n-1
// (ii) (x^2) % n is not 1
// (iii) (x^2) % n is not n-1
while (d != n-1)
{
x = (x * x) % n;
d *= 2;
if (x == 1) return false;
if (x == n-1) return true;
}
// Return composite
return false;
}
// It returns false if n is composite and returns true if n

// is probably prime. k is an input parameter that determines
// accuracy level. Higher value of k indicates more accuracy.
bool isPrime(int n, int k)
{
// Corner cases
if (n <= 1 || n == 4) return false;
// Find r such that n = 2^d * r + 1 for some r >= 1

int d = n - 1;
while (d % 2 == 0)
d /= 2;
// Iterate given nber of 'k' times

for (int i = 0; i < k; i++)
if (miillerTest(d, n) == false)
return false;
return true;
}
// Driver program
int main()
{
int k = 4; // Number of iterations
cout << "All primes smaller than 100: \n";

for (int n = 1; n < 100; n++)
if (isPrime(n, k))
cout << n << " ";
cout << n << " ";
return 0;
}

Output:

All primes smaller than 100:
2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59
61 67 71 73 79 83 89 97

How does this work?

Below are some important facts behind the algorithm:
1. Fermat’s theorem states that, If n is a prime number, then for every a, 1 <= a < n, an-1 % n = 1
2. Base cases make sure that n must be odd. Since n is odd, n-1 must be even. And an even number can
be written as d * 2s.
3. From above two points, for every randomly picked number in range [2, n-2], following must be true.
r
ad*2 % n = 1.
r
4. Point 3 means ad*2 % n is a multiple of all 1’s or multiple of even number of -1’s under modulo n.
Which means,

ad % n = 1
OR
i
ad*2 % n = -1
for some i, where 0

References:
https://en.wikipedia.org/wiki/Miller%E2%80%93Rabin_primality_test
This article is contributed Ruchir Garg. Please write comments if you find anything incorrect, or you want
Find the subarray with least average
Given an array arr[] of size n and integer k such that k

Input: arr[] = {3, 7, 90, 20, 10, 50, 40}, k = 3
Output: Subarray between indexes 3 and 5
The subarray {20, 10, 50} has the least average among
all subarrays of size 3.

A Simple Solution is to consider every element as beginning of subarray of size k and compute sum of
subarray starting with this element. Time complexity of this solution is O(nk).
An Efficient Solution is to solve the above problem in O(n) time and O(1) extra space. The idea is to use
sliding window of size k. Keep track of sum of current k elements. To compute sum of current window,
remove first element of previous window and add current element (last element of current window).

1) Initialize res_index = 0 // Beginning of result index
2) Find sum of first k elements. Let this sum be 'curr_sum'
3) Initialize min_sum = sum
4) Iterate from (k+1)'th to n'th element, do following
for every element arr[i]
a) curr_sum = curr_sum + arr[i] - arr[i-k]
b) If curr_sum < min_sum
res_index = (i-k+1)
5) Print res_index and res_index+k-1 as beginning and ending
indexes of resultant subarray.


// A Simple C++ program to find minimum average subarray
// Prints beginning and ending indexes of subarray

// of size k with minimum average
void findMinAvgSubarray(int arr[], int n, int k)
{
if (n < k)
return;
// Initialize beginning index of result

int res_index = 0;
// Compute sum of first subarray of size k

int curr_sum = 0;
curr_sum += arr[i];
// Initialize minimum sum as current sum

int min_sum = curr_sum;
// Traverse from (k+1)'th element to n'th element

for (int i = k; i < n; i++)
{
// Add current item and remove first item of
// previous subarray
curr_sum += arr[i] - arr[i-k];

if (curr_sum < min_sum)
{
min_sum = curr_sum;
res_index = (i-k+1);
}
}
cout << "Subarray between [" << res_index << ", "
<< res_index + k - 1<< "] has minimum average";
}
// Driver program
int main()
{
int arr[] = {3, 7, 90, 20, 10, 50, 40};
int k = 3; // Subarray size
findMinAvgSubarray(arr, n, k);
return 0;
}

Output:

Subarray between [3, 5] has minimum average

Source: http://qa.geeksforgeeks.org/2221/given-an-array-integers-find-subarray-having-least-average
discussed above
Program for Rank of Matrix
What is rank of a matrix?
Rank of a matrix A of size M x N is defined as
(a) Maximum number of linearly independent column vectors in the matrix or
(b) Maximum number of linearly independent row vectors in the matrix.
Example:

Input: mat[][] = {{10, 20, 10},
{20, 40, 20},
{30, 50, 0}}
Output: Rank is 2
Explanation: Ist and IInd rows are linearly dependent.
But Ist and 3rd or IInd and IIIrd are
independent.
Input: mat[][] = {{10, 20, 10},

{-20, -30, 10},
{30, 50, 0}}
Output: Rank is 2
Explanation: Ist and IInd rows are linearly independent.
So rank must be atleast 2. But all three rows
are linearly dependent (the first is equal to
the sum of the second and third) so the rank
must be less than 3.

In other words rank of A is the largest order of any non-zero minor in A where order of a minor is the side-
length of the square sub-matrix of which it is determinant.
So if M How to find Rank?

The idea is based on conversion to Row echelon form.

1) Let the input matrix be mat[][]. Initialize rank equals
to number of columns
// Before we visit row 'row', traversal of previous

// rows make sure that mat[row][0],....mat[row][row-1]
// are 0.
2) Do following for row = 0 to rank-1.
a) If mat[row][row] is not zero, make all elements of

current column as 0 except the element mat[row][row]
by finding appropriate multiplier and adding a the
multiple of row 'row'

b) Else (mat[row][row] is zero). Two cases arise:
(i) If there is a row below it with non-zero entry in
same column, then swap current 'row' and that row.
(ii) If all elements in current column below mat[r][row]
are 0, then remove this column by swapping it with
last column and reducing number of rank by 1.
Reduce row by 1 so that this row is processed again.
3) Number of remaining columns is rank of matrix.

Example:

Input: mat[][] = {{10, 20, 10},
{-20, -30, 10},
{30, 50, 0}}
row = 0:
Since mat[0][0] is not 0, we are in case 2.a of above algorithm.
We set all entries of 0'th column as 0 (except entry mat[0][0]).
To do this, we subtract R1*(-2) from R2, i.e., R2 --> R2 - R1*(-2)
mat[][] = {{10, 20, 10},
{ 0, 10, 30},
{30, 50, 0}}
And subtract R1*3 from R3, i.e., R3 --> R3 - R1*3
mat[][] = {{10, 20, 10},
{ 0, 10, 30},
{ 0, -10, -30}}
row = 1:
Since mat[1][1] is not 0, we are in case 2.a of above algorithm.
We set all entries of 1st column as 0 (except entry mat[1][1]).
To do this, we subtract R2*2 from R1, i.e., R1 --> R1 - R2*2
mat[][] = {{10, 0, -50},
{ 0, 10, 30},
{ 0, -10, -30}}
And subtract R2*(-1) from R3, i.e., R3 --> R3 - R2*(-1)
mat[][] = {{10, 0, -50},
{ 0, 10, 30},
{ 0, 0, 0}}
row = 2:
Since Since mat[2][2] is 0, we are in case 2.b of above algorithm.
Since there is no row below it swap. We reduce the rank by 1 and
keep row as 2.
The loop doesn't iterate next time because loop termination condition
The loop doesn't iterate next time because loop termination condition
row
// C++ program to find rank of a matrix

#define R 3
#define C 3
/* function for exchanging two rows of

a matrix */
void swap(int mat[R][C], int row1, int row2,
int col)
{
for (int i = 0; i < col; i++)
{
int temp = mat[row1][i];
mat[row1][i] = mat[row2][i];
mat[row2][i] = temp;
}
}
// Function to display a matrix

void display(int mat[R][C], int row, int col);
/* function for finding rank of matrix */

int rankOfMatrix(int mat[R][C])
{
int rank = C;
for (int row = 0; row < rank; row++)

{
// Before we visit current row 'row', we make
// sure that mat[row][0],....mat[row][row-1]
// are 0.
// Diagonal element is not zero

if (mat[row][row])
{
for (int col = 0; col < R; col++)
{
if (col != row)
{
// This makes all entries of current
// column as 0 except entry 'mat[row][row]'
double mult = (double)mat[col][row] /
mat[row][row];
for (int i = 0; i < rank; i++)
mat[col][i] -= mult * mat[row][i];
}
}
}
// Diagonal element is already zero. Two cases

// arise:
// 1) If there is a row below it with non-zero
// entry, then swap this row with that row
// and process that row
// 2) If all elements in current column below
// mat[r][row] are 0, then remvoe this column
// by swapping it with last column and
// reducing number of columns by 1.
else
else
{
bool reduce = true;
/* Find the non-zero element in current

column */
for (int i = row + 1; i < R; i++)
{
// Swap the row with non-zero element
// with this row.
if (mat[i][row])
{
swap(mat, row, i, rank);
reduce = false;
break ;
}
}
// If we did not find any row with non-zero

// element in current columnm, then all
// values in this column are 0.
if (reduce)
{
// Reduce number of columns
rank--;
// Copy the last column here

for (int i = 0; i < R; i ++)
mat[i][row] = mat[i][rank];
}
// Process this row again

row--;
}
// Uncomment these lines to see intermediate results

// display(mat, R, C);
// printf("\n");
}
return rank;
}
/* function for displaying the matrix */

void display(int mat[R][C], int row, int col)
{
for (int i = 0; i < row; i++)
{
for (int j = 0; j < col; j++)
printf(" %d", mat[i][j]);
printf("\n");
}
}

int main()
{
int mat[][3] = {{10, 20, 10},
{-20, -30, 10},
{30, 50, 0}};
printf("Rank of the matrix is : %d",
rankOfMatrix(mat));
return 0;
}

Output:
Rank of the matrix is : 2
Since above rank calculation method involves floating point arithmetic, it may produce i
ncorrect results if the division goes beyond precision. There are other methods to hand
le
Reference:
https://en.wikipedia.org/wiki/Rank_%28linear_algebra%29
This article is contributed by Utkarsh Trivedi. Please write comments if you find anythi
ng incorrect, or you want to share more information about the topic discussed above.

Find LCA in Binary Tree using RMQ
The article describes an approach to solving the problem of finding the LCA of two nodes in a tree by
reducing it to a RMQ problem.
Lowest Common Ancestor (LCA) of two nodes u and v in a rooted tree T is defined as the node located
farthest from the root that has both u and v as descendants.
For example, in below diagram, LCA of node 4 and node 9 is node 2.
There can be many approaches to solve the LCA problem. The approaches differ in their time and space
complexities. Here is a link to a couple of them (these do not involve reduction to RMQ).
Range Minimum Query (RMQ) is used on arrays to find the position of an element with the minimum
value between two specified indices. Different approaches for solving RMQ have been discussed here and
here. In this article, Segment Tree based approach is discussed. With segment tree, preprocessing time is
O(n) and time to for range minimum query is O(Logn). The extra space required is O(n) to store the
segment tree.
Reduction of LCA to RMQ:

The idea is to traverse the tree starting from root by an Euler tour (traversal without lifting pencil), which is
a DFS-type traversal with preorder traversal characteristics.
Observation: The LCA of nodes 4 and 9 is node 2, which happens to be the node closest to the root
amongst all those encountered between the visits of 4 and 9 during a DFS of T. This observation is the key to
the reduction. Let’s rephrase: Our node is the node at the smallest level and the only node at that level
amongst all the nodes that occur between consecutive occurrences (any) of u and v in the Euler tour of T.
We require three arrays for implementation:
1. Nodes visited in order of Euler tour of T

2. Level of each node visited in Euler tour of T
3. Index of the first occurrence of a node in Euler tour of T (since any occurrence would be good, let’s
track the first one)
Algorithm:
1. Do a Euler tour on the tree, and fill the euler, level and first occurrence arrays.
2. Using the first occurrence array, get the indices corresponding to the two nodes which will be the
corners of the range in the level array that is fed to the RMQ algorithm for the minimum value.
3. Once the algorithm return the index of the minimum level in the range, we use it to determine the
LCA using Euler tour array.

/* C++ Program to find LCA of u and v by reducing the problem to RMQ */
#define V 9 // number of nodes in input tree
int euler[2*V - 1]; // For Euler tour sequence

int level[2*V - 1]; // Level of nodes in tour sequence
int firstOccurrence[V+1]; // First occurences of nodes in tour
int firstOccurrence[V+1]; // First occurences of nodes in tour
int ind; // Variable to fill-in euler and level arrays

struct Node
{
int key;
};
// Utility function creates a new binary tree node with given key
Node * newNode(int k)
{
temp->key = k;
return temp;
}
// log base 2 of x
int Log2(int x)
{
int ans = 0 ;
while (x>>=1) ans++;
return ans ;
}
/* A recursive function to get the minimum value in a given range

of array indexes. The following are parameters for this function.

index --> Index of current node in the segment tree. Initially
0 is passed as root is always at index 0
ss & se --> Starting and ending indexes of the segment represented
by current node, i.e., st[index]
int RMQUtil(int index, int ss, int se, int qs, int qe, int *st)
{
// If segment of this node is a part of given range, then return
// the min of the segment
return st[index];

else if (se < qs || ss > qe)
return -1;

int q1 = RMQUtil(2*index+1, ss, mid, qs, qe, st);

int q2 = RMQUtil(2*index+2, mid+1, se, qs, qe, st);
if (q1==-1) return q2;
else if (q2==-1) return q1;
return (level[q1] < level[q2]) ? q1 : q2;

}
// Return minimum of elements in range from index qs (quey start) to

int RMQ(int *st, int n, int qs, int qe)
{
if (qs < 0 || qe > n-1 || qs > qe)
{
return -1;
}
return RMQUtil(0, 0, n-1, qs, qe, st);

}

void constructSTUtil(int si, int ss, int se, int arr[], int *st)
{
if (ss == se)st[si] = ss;
else
{
constructSTUtil(si*2+1, ss, mid, arr, st);
constructSTUtil(si*2+2, mid+1, se, arr, st);
if (arr[st[2*si+1]] < arr[st[2*si+2]])

st[si] = st[2*si+1];
else
st[si] = st[2*si+2];
}
}

{
// Height of segment tree

int x = Log2(n)+1;
// Maximum size of segment tree

int max_size = 2*(1<<x) - 1; // 2*pow(2,x) -1

constructSTUtil(0, 0, n-1, arr, st);

return st;
}
// Recursive version of the Euler tour of T

void eulerTour(Node *root, int l)
{
/* if the passed node exists */
if (root)
{
euler[ind] = root->key; // insert in euler array
level[ind] = l; // insert l in level array
ind++; // increment index
/* if unvisited, mark first occurrence */
if (firstOccurrence[root->key] == -1)
firstOccurrence[root->key] = ind-1;
/* tour left subtree if exists, and remark euler

and level arrays for parent on return */
if (root->left)
{
eulerTour(root->left, l+1);
euler[ind]=root->key;
level[ind] = l;
ind++;
}
/* tour right subtree if exists, and remark euler

and level arrays for parent on return */
if (root->right)
{
eulerTour(root->right, l+1);
euler[ind]=root->key;
level[ind] = l;
ind++;
}
}
}
// Returns LCA of nodes n1, n2 (assuming they are

// present in the tree)
int findLCA(Node *root, int u, int v)
{
/* Mark all nodes unvisited. Note that the size of
firstOccurrence is 1 as node values which vary from
1 to 9 are used as indexes */
memset(firstOccurrence, -1, sizeof(int)*(V+1));
/* To start filling euler and level arrays from index 0 */

ind = 0;
/* Start Euler tour with root node on level 0 */

eulerTour(root, 0);
/* construct segment tree on level array */

int *st = constructST(level, 2*V-1);
/* If v before u in Euler tour. For RMQ to work, first

parameter 'u' must be smaller than second 'v' */
if (firstOccurrence[u]>firstOccurrence[v])
std::swap(u, v);
// Starting and ending indexes of query range

int qs = firstOccurrence[u];
int qe = firstOccurrence[v];
// query for index of LCA in tour

int index = RMQ(st, 2*V-1, qs, qe);
/* return LCA node */

return euler[index];
}

int main()
{
// Let us create the Binary Tree as shown in the diagram.
// Let us create the Binary Tree as shown in the diagram.
int u = 4, v = 9;
printf("The LCA of node %d and node %d is node %d.\n",
u, v, findLCA(root, u, v));
return 0;
}

Output:

The LCA of node 4 and node 9 is node 2.

Note:
1. We assume that the nodes queried are present in the tree.

2. We also assumed that if there are V nodes in tree, then keys (or data) of these nodes are in range from
1 to V.
Time complexity:
1. Euler tour: Number of nodes is V. For a tree, E = V-1. Euler tour (DFS) will take O(V+E) which is
O(2*V) which can be written as O(V).
2. Segment Tree construction : O(n) where n = V + E = 2*V – 1.
3. Range Minimum query: O(log(n))
Overall this method takes O(n) time for preprocssing, but takes O(Log n) time for query. Therefore, it can be
useful when we have a single tree on which we want to perform large number of LCA queries (Note that LCA
is useful for finding shortest path between two nodes of Binary Tree)
Auxiliary Space:
1. Euler tour array: O(n) where n = 2*V – 1

2. Node Levels array: O(n)
3. First Occurrences array: O(V)
4. Segment Tree: O(n)
Overall: O(n)
Another observation is that the adjacent elements in level array differ by 1. This can be used to convert a
RMQ problem to a LCA problem.
Wilson’s Theorem
Wilson’s theorem states that a natural number p > 1 is a prime number if and only if
(p - 1) ! ≡ -1 mod p
OR (p - 1) ! ≡ (p-1) mod p

Examples:

p = 5
(p-1)! = 24
24 % 5 = 4
p = 7
(p-1)! = 6! = 720
720 % 7 = 6

How does it work?

1) We can quickly check result for p = 2 or p = 3.
2) For p > 3, and if it is composite, then all factors of it must be range from 2 to p-1. Therefore (p-1)! mod p
must be 0, not -1.
3) Now let us see how it is exactly -1 when p is a prime. If p is a prime, then all numbers in [1, p-1] are
relatively prime to p. And for every number x in range [2, p-2], there must exist a number y such that
(x*y)%p = 1. So

[1 * 2 * 3 * ... (p-1)]%p
= [1 * 1 * 1 ... (p-1)] // Group all x and y in [2..p-2]
// such that (x*y)%p = 1
= (p-1)

How can it be useful?

Consider the problem of computing factorial under modulo of a prime number which is close to input
number, i.e., we want to find value of “n! % p” such that n this for details).
See this for more applications of Wilson’s Theorem.
References:
https://en.wikipedia.org/wiki/Wilson’s_theorem
https://primes.utm.edu/notes/proofs/Wilsons.html
discussed above
Compute n! under modulo p
Given a large number n and a prime p, how to efficiently compute n! % p?
Examples:

Input: n = 5, p = 13
Output: 3
5! = 120 and 120 % 13 = 3
Input: n = 6, p = 11
Output: 5
6! = 720 and 720 % 11 = 5

A Naive Solution is to first compute n!, then compute n! % p. This solution works fine when the value of n!
is small. The value of n! % p is generally needed for large values of n when n! cannot fit in a variable, and
causes overflow. So computing n! and then using modular operator is not a good idea as there will be
overflow even for slightly larger values of n and r.
Following are different methods.
Method 1 (Simple)
A Simple Solution is to one by one multiply result with i under modulo p. So the value of result doesn’t go
beyond p before next iteration.

// Simple method to compute n! % p
// Returns value of n! % p
int modFact(int n, int p)
{
if (n >= p)
return 0;
int result = 1;
result = (result * i) % p;
return result;
}
// Driver program
int main()
{
int n = 25, p = 29;
cout << modFact(n, p);
return 0;
}

Output:

5

Time Complexity of this solution is O(n).
Method 2 (Using Sieve)

The idea is based on below formula discussed here.

The largest possible power of a prime pi that divides n is,
?n/pi? + ?n/(pi2)? + ?n/(pi3)? + .....+ 0
Every integer can be written as multiplication of powers of primes. So,

n! = p1k1 * p2k2 * p3k3 * ....
Where p1, p 2, p 3,.. are primes and
k1, k 2, k 3, .. are integers greater than or equal to 1.

The idea is to find all primes smaller than n using Sieve of Eratosthenes. For every prime ‘pi‘, find the largest
power of it that divides n!. Let the largest power be k i. Compute piki % p using modular exponentiation.
Multiply this with final result under modulo p.

// Returns n % p using Sieve of Eratosthenes
// Returns largest power of p that divides n!

int largestPower(int n, int p)
{
int x = 0;
// Calculate x = n/p + n/(p^2) + n/(p^3) + ....

while (n)
{
n /= p;
x += n;
}
return x;
}

int power(int x, int y, int p)
{
// equal to p
while (y > 0)
{
if (y & 1)
res = (res*x) % p;

y = y>>1; // y = y/2
y = y>>1; // y = y/2
x = (x*x) % p;
}
return res;
}
// Returns n! % p
{
if (n >= p)
return 0;
int res = 1;
// Use Sieve of Eratosthenes to find all primes

// smaller than n
bool isPrime[n+1];
memset(isPrime, 1, sizeof(isPrime));
for (int i=2; i*i<=n; i++)
{
if (isPrime[i])
{
for (int j=2*i; j<=n; j+=i)
isPrime[j] = 0;
}
}
// Consider all primes found by Sieve

{
if (isPrime[i])
{
// Find the largest power of prime 'i' that divides n
int k = largestPower(n, i);
// Multiply result with (i^k) % p

res = (res * power(i, k, p)) % p;
}
}
return res;
}
// Driver method
int main()
{
int n = 25, p = 29;
return 0;
}

Output:
This is an interesting method, but time complexity of this is more than Simple Method as time complexity of
Sieve itself is O(n log log n). This method can be useful if we have list of prime numbers smaller than or
equal to n available to us.
Method 3 (Using Wilson’s Theorem)

Wilson’s theorem states that a natural number p > 1 is a prime number if and only if

(p - 1) ! ? -1 mod p
OR (p - 1) ! ? (p-1) mod p

Note that n! % p is 0 if n >= p. This method is mainly useful when p is close to input number n. For example
(25! % 29). From Wilson’s theorem, we know that 28! is -1. So we basically need to find [ (-1) * inverse(28,
29) * inverse(27, 29) * inverse(26) ] % 29. The inverse function inverse(x, p) returns inverse of x under
modulo p (See this for details).

// C++ program to comput n! % p using Wilson's Theorem

{
// equal to p
while (y > 0)
{
if (y & 1)
res = (res*x) % p;

y = y>>1; // y = y/2
x = (x*x) % p;
}
return res;
}
// Function to find modular inverse of a under modulo p

// using Fermat's method. Assumption: p is prime
int modInverse(int a, int p)
{
return power(a, p-2, p);
}
// Returns n! % p using Wilson's Theorem

{
// n! % p is 0 if n >= p
if (p <= n)
return 0;
// Initialize result as (p-1)! which is -1 or (p-1)

int res = (p-1);
// Multiply modulo inverse of all numbers from (n+1)

// to p
for (int i=n+1; i<p; i++)
res = (res * modInverse(i, p)) % p;
return res;
}
// Driver method
int main()
{
int n = 25, p = 29;
return 0;
}

Output:

5

Time complexity of this method is O((p-n)*Logn)
Method 4 (Using Primality Test Algorithm)

1) Initialize: result = 1
2) While n is not prime
result = (result * n) % p
3) result = (result * (n-1)) % p // Using Wilson's Theorem
4) Return result.

Note that time complexity step 2 of above algorithm depends on the primality test algorithm being used and
value of the largest prime smaller than n. The AKS algorithm for example takes O(Log 10.5 n) time.
Count inversions in an array | Set 2 (Using Self-Balancing BST)

Two elements a[i] and a[j] form an inversion if
a[i] > a[j] and i < j. For simplicity, we may
assume that all elements are unique.
Example:
Input: arr[] = {8, 4, 2, 1}
Output: 6
Given array has six inversions (8,4), (4,2),
(8,2), (8,1), (4,1), (2,1).

We have already discussed Naive approach and Merge Sort based approaches for counting inversions.
Time Complexity of the Naive approach is O(n2) and that of merge sort based approach is O(n Log n). In this
post one more O(n Log n) approach is discussed. The idea is to use Self-Balancing Binary Search Tree like
Red-Black Tree, AVL Tree, etc and augment it so that every node also keeps track of number of nodes in right
subtree.

1) Create an empty AVL Tree. The tree is augmented here
such that every node also maintains size of subtree
rooted with this node.
2) Initialize inversion count or result as 0.
3) Iterate from 0 to n-1 and do following for every

element in arr[i]
a) Insert arr[i] into the AVL Tree. The insertion
operation also updates result. The idea is to
keep counting greater nodes when tree is traversed
from root to a leaf for insertion.
4) Return result.

More explanation for step 3.a:

1) When we insert arr[i], elements from arr[0] to arr[i-1] are already inserted into AVL Tree. All we need to
do is count these nodes.
2) For insertion into AVL Tree, we traverse tree from root to a leaf by comparing every node with arr[i[].
When arr[i[ is smaller than current node, we increase inversion count by 1 plus the number of nodes in right
subtree of current node. Which is basically count of greater elements on left of arr[i], i.e., inversions.

// An AVL Tree based C++ program to count inversion in an array
// An AVL tree node

struct node
{
int key, height;
int key, height;
int size; // size of the tree rooted with this node
};
// A utility function to get height of the tree rooted with N

{
if (N == NULL)
return 0;
return N->height;
}
// A utility function to size of the tree of rooted with N

int size(struct node *N)
{
if (N == NULL)
return 0;
return N->size;
}
{
struct node* node = new Node;
node->key = key;
node->height = node->size = 1;
return(node);
}

{
// Perform rotation
x->right = y;
y->left = T2;
// Update heights
// Update sizes
// Return new root

return x;
}

{
// Perform rotation
y->left = x;
x->right = T2;
// Update heights
// Update heights
// Update sizes
// Return new root

return y;
}

{
if (N == NULL)
return 0;
}
// Inserts a new key to the tree rotted with node. Also, updates
// *result (inversion count)
struct node* insert(struct node* node, int key, int *result)
{
if (node == NULL)

{
node->left = insert(node->left, key, result);
// UPDATE COUNT OF GREATE ELEMENTS FOR KEY

*result = *result + size(node->right) + 1;
}
else
node->right = insert(node->right, key, result);
/* 2. Update height and size of this ancestor node */

node->height = max(height(node->left),
height(node->right)) + 1;
node->size = size(node->left) + size(node->right) + 1;
/* 3. Get the balance factor of this ancestor node to

check whether this node became unbalanced */
// If this node becomes unbalanced, then there are

// 4 cases
// Left Left Case

// Right Right Case

// Left Right Case

{
}
// Right Left Case
{
}

return node;
}
// The following function returns inversion count in arr[]

{
struct node *root = NULL; // Create empty AVL Tree
int result = 0; // Initialize result
// Starting from first element, insert all elements one by

// one in an AVL tree.
// Note that address of result is passed as insert

// operation updates result by adding count of elements
// greater than arr[i] on left of arr[i]
root = insert(root, arr[i], &result);
return result;
}

int main()
{
int arr[] = {8, 4, 2, 1};
int n = sizeof(arr)/sizeof(int);
cout << "Number of inversions count are : "
<< getInvCount(arr,n);
return 0;
}

Output:

Number of inversions count are : 6

Time complexity of above solution is O(n Log n) as AVL insert takes O(Log n) time.
We will soon be discussing Binary Indexed Tree based approach for the same.
discussed above
Count inversions in an array | Set 3 (Using BIT)

Two elements a[i] and a[j] form an inversion if
a[i] > a[j] and i < j. For simplicity, we may
assume that all elements are unique.
Example:
Input: arr[] = {8, 4, 2, 1}
Output: 6
Given array has six inversions (8,4), (4,2),
(8,2), (8,1), (4,1), (2,1).

We have already discussed below methods to solve inversion count

1) Naive and Modified Merge Sort
2) Using AVL Tree
Background:
BIT basically supports two operations for an array arr[] of size n
(1) Sum of elements till arr[i] in O(Log n) time.
(2) Update an array element in O(Log n) time.
BIT is implemented using an array and works in form of trees. Note that there are two ways of looking at
BIT as a tree.
1) The sum operation where parent of index x is "x - x(x & -x)".
2) The update operation where parent of index x is "x + x(x & -x)".
We recommend you refer Binary Indexed Tree (BIT) before further reading this post.
Basic Approach using BIT :

The idea is to iterate the array from n-1 to 0. When we are at i'th index, we check how many numbers less
than arr[i] are present in BIT and add it to the result. To get the count of smaller elements, getSum() of BIT
is used. In his basic idea, BIT is represented as an array of size equal to maximum element plus one. So that
elements can be used as an index.
After that we add current element to to the BIT[] by doing an update operation that updates count of current
element from 0 to 1, and therefore updates ancestors of current element in BIT (See update() in BIT for
details).
Below is C++ implementation of basic idea that uses BIT.

// C++ program to count inversions using Binary Indexed Tree

int getSum(int BITree[], int index)
{
int sum = 0; // Initialize result

while (index > 0)
{
// Move index to parent node in getSum View

}
return sum;
}

void updateBIT(int BITree[], int n, int index, int val)
{
while (index <= n)
{
// Update index to that of parent in update View

}
}
// Returns inversion count arr[0..n-1]

{
int invcount = 0; // Initialize result
// Find maximum element in arr[]

int maxelement = 0;
if (maxelement < arr[i])
maxelement = arr[i];
// Create a BIT with size equal to maxelement+1 (Extra

// one is used so that elements can be directly be
// used as index)
int BIT[maxelement+1];
for (int i=1; i<=maxelement; i++)
BIT[i] = 0;
// Traverse all elements from right.

for (int i=n-1; i>=0; i--)
{
// Get count of elements smaller than arr[i]
invcount += getSum(BIT, arr[i]-1);
// Add current element to BIT

updateBIT(BIT, maxelement, arr[i], 1);
}
return invcount;
}
// Driver program
int main()
{
int arr[] = {8, 4, 2, 1};
cout << "Number of inversions are : " << getInvCount(arr,n);
return 0;
}

Output:

Number of inversions are : 6

Time Complexity :- The update function and getSum function runs for O(log(maximumelement)) and we
are iterating over n elements. So overall time complexity is : O(nlog(maximumelement)).
Auxiliary space : O(maxelement)
Better Approach :
The problem with the previous approach is that it doesn't work for negative numbers as index cannot be
negative. Also by updating the value till maximum element we waste time and space as it is quite possible
that we may never use intermediate value. For example, lots of space an time is wasted for an array like {1,
100000}.
The idea is to convert given array to an array with values from 1 to n and relative order of smaller and
greater elements remains

Example :-
arr[] = {7, -90, 100, 1}
It gets converted to,

arr[] = {3, 1, 4 ,2 }
as -90 < 1 < 7 < 100.

We only have to make BIT[] of number of elements instead of maximum element.

Changing element will not have any change in the answer as the greater elements remain greater and at
same position.

// C++ program to count inversions using Binary Indexed Tree

{
int sum = 0; // Initialize result

while (index > 0)
{
// Move index to parent node in getSum View

}
return sum;
}

{
while (index <= n)
{
// Update index to that of parent in update View

}
}
// Converts an array to an array with values from 1 to n

// and relative order of smaller and greater elements remains
// same. For example, {7, -90, 100, 1} is converted to
// {3, 1, 4 ,2 }
void convert(int arr[], int n)
{
// Create a copy of arrp[] in temp and sort the temp array
// in increasing order
int temp[n];
temp[i] = arr[i];
sort(temp, temp+n);

{
// lower_bound() Returns pointer to the first element
// greater than or equal to arr[i]
arr[i] = lower_bound(temp, temp+n, arr[i]) - temp + 1;
}
}
// Returns inversion count arr[0..n-1]

{
int invcount = 0; // Initialize result
// Convert arr[] to an array with values from 1 to n and

// relative order of smaller and greater elements remains
// same. For example, {7, -90, 100, 1} is converted to
// {3, 1, 4 ,2 }
convert(arr, n);
// Create a BIT with size equal to maxelement+1 (Extra

// one is used so that elements can be directly be
// used as index)
int BIT[n+1];
BIT[i] = 0;
// Traverse all elements from right.

for (int i=n-1; i>=0; i--)
{
// Get count of elements smaller than arr[i]
invcount += getSum(BIT, arr[i]-1);
// Add current element to BIT

updateBIT(BIT, n, arr[i], 1);
}
return invcount;
}
// Driver program
int main()
{
int arr[] = {8, 4, 2, 1};
cout << "Number of inversions are : " << getInvCount(arr,n);
return 0;
}

Output:

Number of inversions are : 6

Time Complexity :- The update function and getSum function runs for O(log(n)) and we are iterating over
n elements. So overall time complexity is : O(nlogn).
Auxiliary space : O(n)
This article is contributed by Abhiraj Smit. Please write comments if you find anything incorrect, or you
Euler’s criterion (Check if square root under modulo p exists)
Given a number ‘n’ and a prime p, find if square root of n under modulo p exists or not. A number x is square
root of n under modulo p if (x*x)%p = n%p.
Examples:

Input: n = 2, p = 5
Output: false
There doesn't exist a number x such that
(x*x)%5 is 1
Input: n = 2, p = 7
Output: true
There exists a number x such that (x*x)%5 is
1. The number is 3.

Euler’s criterion states that

If n (p-1)/2 % p = 1
then square root of under modulo n exists, i.e.,
there exists an integer x such that (x * x) % p = 1
OR
Square root of n under modulo p exists if and only if

n (p-1)/2 % p = 1

Below is C++ implementation based on above criterion.

// C++ program to check if square root of a number
// under modulo p exists or not
#include<iostream>

{
// equal to p
while (y > 0)
{
if (y & 1)
res = (res*x) % p;

y = y>>1; // y = y/2
x = (x*x) % p;
}
return res;
}
// Returns true if there exists an integer x such

// that (x*x)%p = n%p
bool squareRootExists(int n, int p)
{
// Check for Euler's criterion that is
// [n ^ ((p-1)/2)] % p is 1 or not.
if (power(n, (p-1)/2, p) == 1)
return true;
return false;
}

int main()
{
int p = 7;
int n = 2;
squareRootExists(n, p)? cout << "Yes": cout << "No";
return 0;
}

Output:

Yes

How does this work?

If p is a prime, then it must be an odd number and (p-1)
must be an even, i.e., (p-1)/2 must be an integer.
Suppose a square root of n under modulo p exists, then

there must exist an integer x such that,
x 2 % p = n % p
or,
x2 ≡ n mod p
Raising both sides to power (p-1)/2,

(x2)(p-1)/2 ≡ n(p-1)/2 mod p
x p-1 ≡ n(p-1)/2 mod p
Since p is a prime, from Fermet's theorem, we can say that

xp-1 ≡ 1 mod p
Therefore,
n (p-1)/2 ≡ 1 mod p

Find Square Root under Modulo p | Set 1 (When p is in form of 3*i + 4)
Given a number ‘n’ and a prime ‘p’, find square root of n under modulo p if it exists. It may be given that p is
in the form for 3*i + 4 where i is an integer (OR p % 3 = 4). Examples of such primes are 7, 13, 17, 23, 29, 41,
47, 53, 59, .. etc,
Examples:

Input: n = 2, p = 7
Output: 3 or 4
3 and 4 both are square roots of 2 under modulo
7 because (3*3) % 7 = 2 and (4*4) % 7 = 2
Input: n = 2, p = 5
Output: Square root doesn't exist

Naive Solution : Try all numbers from 2 to p-1. And for every number x, check if x is square root of n
under modulo p.
#include<iostream>
void squareRoot(int n, int p)

{
n = n%p;

for (int x=2; x<p; x++)
{
if ((x*x)%p == n)
{
cout << "Square root is " << x;
return;
}
}
cout << "Square root doesn't exist";
}
int main()
{
int p = 7;
int n = 2;
squareRoot(n, p);
return 0;
}

Output:

Square root is 3

Time Complexity of this solution is O(p)
Direct Method : If p is in the form of 3*i + 4 (or p%3 = 4), then there exist a Quick way of finding square
root.

If n is in the form 3*i + 4 with i >= 1 (or p % 3 = 4)
And
If Square root of n exists, then it must be
±n(p + 1)/4

#include<iostream>

{
int res = 1;
x = x % p;

while (y > 0)
{

if (y & 1)
res = (res*x) % p;

y = y>>1;
x = (x*x) % p;
}
return res;
}

{
if (p % 3 != 4)
{
return;
}

n = n % p;
int x = power(n, (p+1)/4, p);
if ((x*x)%p == n)
{
return;
}

x = p - x;
if ((x*x)%p == n)
{
return;
}

cout << "Square root doesn't exist ";
}
int main()
{
int p = 7;
int n = 2;
squareRoot(n, p);
return 0;
}

Output:
Time Complexity of this solution is O(Log p)
How does this work?

We have discussed Euler’s Criterion in the previous post.

As per Euler's criterion, if square root exists, then
following condition is true
n(p-1)/2 % p = 1
Multiplying both sides with n, we get

n(p+1)/2 % p = n % p ------ (1)
Let x be the modulo square root. We can write,

(x * x) ≡ n mod p
(x * x) ≡ n(p+1)/2 [Using (1) given above]
(x * x) ≡ n(2i + 2) [Replacing n = 3*i + 4]
x ≡ ±n(i + 1)
x ≡ ±n(p + 1)/4

We will soon be discussing methods when p is not in above form.
Gaussian Elimination to Solve Linear Equations
The article focuses on using an algorithm for solving a system of linear equations. We will deal with the
matrix of coefficients. Gaussian Elimination does not work on singular matrices (they lead to division by
zero).

Input: For N unknowns, input is an augmented
matrix of size N x (N+1). One extra
column is for Right Hand Side (RHS)
mat[N][N+1] = {{3.0, 2.0,-4.0, 3.0},
{2.0, 3.0, 3.0, 15.0},
{5.0, -3, 1.0, 14.0}
};
Output: Solution to equations is:
3.000000
1.000000
2.000000
Explanation:
Given matrix represents following equations
3.0X1 + 2.0X 2 - 4.0X 3 = 3.0
2.0X1 + 3.0X 2 + 3.0X 3 = 15.0
5.0X1 - 3.0X 2 + X 3 = 14.0
There is a unique solution for given equations,

solutions is, X1 = 3.0, X2 = 1.0, X3 = 2.0,

Row echelon form: Matrix is said to be in r.e.f. if the following conditions hold:
1. The first non-zero element in each row, called the leading coefficient, is 1.
2. Each leading coefficient is in a column to the right of the previous row leading coefficient.
3. Rows with all zeros are below rows with at least one non-zero element.
Reduced row echelon form: Matrix is said to be in r.r.e.f. if the following conditions hold –
1. All the conditions for r.e.f.

2. The leading coefficient in each row is the only non-zero entry in its column.
The algorithm is majorily about performing a sequence of operations on the rows of the matrix. What we
would like to keep in mind while performing these operations is that we want to convert the matrix into an
upper triangular matrix in row echelon form. The operations can be:
1. Swapping two rows
2. Multiplying a row by a non-zero scalar
3. Adding to one row a multiple of another
The process:
1. Forward elimination: reduction to row echelon form. Using it one can tell whether there are no
solutions, or unique solution, or infinitely many solutions.
2. Back substitution: further reduction to reduced row echelon form.
Algorithm:
1. Partial pivoting: Find the kth pivot by swapping rows, to move the entry with the largest absolute
value to the pivot position. This imparts computational stability to the algorithm.
2. For each row below the pivot, calculate the factor f which makes the kth entry zero, and for every
element in the row subtract the fth multiple of corresponding element in kth row.
3. Repeat above steps for each unknown. We will be left with a partial r.e.f. matrix.
#define N 3 // Number of unknowns
int forwardElim(double mat[N][N+1]);
void backSub(double mat[N][N+1]);
void gaussianElimination(double mat[N][N+1])

{

int singular_flag = forwardElim(mat);

if (singular_flag != -1)
{
printf("Singular Matrix.\n");

if (mat[singular_flag][N])
printf("Inconsistent System.");
else
printf("May have infinitely many "
"solutions.");
return;
}

backSub(mat);
}
void swap_row(double mat[N][N+1], int i, int j)
{

for (int k=0; k<=N; k++)

{
double temp = mat[i][k];
mat[i][k] = mat[j][k];
mat[j][k] = temp;
}
}
void print(double mat[N][N+1])

{
for (int i=0; i<N; i++, printf("\n"))
for (int j=0; j<=N; j++)
printf("%lf ", mat[i][j]);
printf("\n");
}
int forwardElim(double mat[N][N+1])

{
for (int k=0; k<N; k++)
{

int i_max = k;
int v_max = mat[i_max][k];

for (int i = k+1; i < N; i++)
if (abs(mat[i][k]) > v_max)
v_max = mat[i][k], i_max = i;

if (!mat[k][i_max])
return k;

if (i_max != k)
swap_row(mat, k, i_max);

for (int i=k+1; i<N; i++)

{

double f = mat[i][k]/mat[k][k];

for (int j=k+1; j<=N; j++)
mat[i][j] -= mat[k][j]*f;

mat[i][k] = 0;
}

}

return -1;
}
void backSub(double mat[N][N+1])

{
double x[N];

for (int i = N-1; i >= 0; i--)
{

x[i] = mat[i][N];

for (int j=i+1; j<N; j++)
{

x[i] -= mat[i][j]*x[j];
}

x[i] = x[i]/mat[i][i];
}
printf("\nSolution for the system:\n");

printf("%lf\n", x[i]);
}
int main()
{

double mat[N][N+1] = {{3.0, 2.0,-4.0, 3.0},
{2.0, 3.0, 3.0, 15.0},
{5.0, -3, 1.0, 14.0}
};
gaussianElimination(mat);
return 0;
}

Output:

Solution for the system:
3.000000
1.000000
2.000000

Illustration:
Time Complexity: Since for each pivot we traverse the part to its right for each row below it, O(n)*
(O(n)*O(n)) = O(n3).
We can also apply Gaussian Elimination for calculating:

1. Rank of a matrix
2. Determinant of a matrix
3. Inverse of an invertible square matrix
Count Inversions of size three in a give array
Given an array arr[] of size n. Three elements arr[i], arr[j] and arr[k] form an inversion of size 3 if a[i] > a[j]
>a[k] and i < j < k. Find total number of inversions of size 3.
Example:

Input: {8, 4, 2, 1}
Output: 3
The four inversions are (8,4,2), (8,4,1), (4,2,1) and (8,2,1).

We have already discussed inversion count of size two by merge sort, Self Balancing BST and BIT.
Simple approach :- Loop for all possible value of i, j and k and check for the condition a[i] > a[j] > a[k]
and i
int getInvCount(int arr[],int n)

{
int invcount = 0;

{
for (int j=i+1; j<n-1; j++)
{
if (arr[i]>arr[j])
{
for (int k=j+1; k<n; k++)
{
if (arr[j]>arr[k])
invcount++;
}
}
}
}
return invcount;
}
int main()
{
int arr[] = {8, 4, 2, 1};
cout << "Inversion Count : " << getInvCount(arr, n);
return 0;
}

Output:

Inversion Count : 4

Time complexity of this approach is : O(n^3)
Better Approach :
We can reduce the complexity if we consider every element arr[i] as middle element of inversion, find all the
numbers greater than a[i] whose index is less than i, find all the numbers which are smaller than a[i] and
index is more than i. We multiply the number of elements greater than a[i] to the number of elements
smaller than a[i] and add it to the result. Below is C++ implementation of the idea.

{
int invcount = 0;

{

int small = 0;
if (arr[i] > arr[j])
small++;

int great = 0;
for(int j=i-1; j>=0; j--)
if(arr[i] < arr[j])
great++;

invcount += great*small;
}
return invcount;
}
int main()
{
int arr[] = {8, 4, 2, 1};
return 0;
}

Output:

Inversion Count : 4

Time Complexity of this approach : O(n^2)
Binary Indexed Tree Approach :

Like inversions of size 2, we can use Binary indexed tree to find inversions of size 3. It is strongly
recommended to refer below article first.
Count inversions of size two Using BIT
The idea is similar to above method. We count the number of greater elements and smaller elements for all
the elements and then multiply greater[] to smaller[] and add it to the result.
Solution :
1. To find out the number of smaller elements for an index we iterate from n-1 to 0. For every element
a[i] we calculate the getSum() function for (a[i]-1) which gives the number of elements till a[i]-1.
2. To find out the number of greater elements for an index we iterate from 0 to n-1. For every element
a[i] we calculate the sum of numbers till a[i] (sum smaller or equal to a[i]) by getSum() and subtract it
from i (as i is the total number of element till that point) so that we can get number of elements greater
than a[i].
Like we did for inversions of size 2, here also we convert the input array to an array with values from 1
to n so that the size of BIT remains O(n), and getSum() and update() functions take O(Log n) time.
For example, we convert arr[] = {7, -90, 100, 1} to arr[] = {3, 1, 4 ,2 }.

{
int sum = 0;

while (index > 0)
{


}
return sum;
}
{

while (index <= n)
{


}
}
void convert(int arr[], int n)

{

int temp[n];
temp[i] = arr[i];
sort(temp, temp+n);

{

arr[i] = lower_bound(temp, temp+n, arr[i]) - temp + 1;
}
}

{

convert(arr, n);

int greater1[n], smaller1[n];
greater1[i] = smaller1[i] = 0;

int BIT[n+1];
BIT[i]=0;
for(int i=n-1; i>=0; i--)

{
smaller1[i] = getSum(BIT, arr[i]-1);
}

BIT[i] = 0;

{
greater1[i] = i - getSum(BIT,arr[i]);
}

int invcount = 0;
invcount += smaller1[i]*greater1[i];
return invcount;
}
int main()
{
int arr[] = {8, 4, 2, 1};
return 0;
}

Output:

Inversion Count : 4

Time Complexity : O(n log n)

Auxiliary Space : O(n)
We can also use Self-Balancing Binary Search Tree to count greater elements on left and smaller on
right. Time complexity of this method would also be O(n Log n), But BIT based method is easy to
implement.
This article is contributed by Abhiraj Smit. Please write comments if you find anything incorrect, or
Find Square Root under Modulo p | Set 1 (When p is in form of 4*i + 3)
Given a number ‘n’ and a prime ‘p’, find square root of n under modulo p if it exists. It may be given that p is
in the form for 4*i + 3 (OR p % 4 = 3) where i is an integer. Examples of such primes are 7, 11, 19, 23, 31, …
etc,
Examples:

Input: n = 2, p = 7
Output: 3 or 4
3 and 4 both are square roots of 2 under modulo
7 because (3*3) % 7 = 2 and (4*4) % 7 = 2
Input: n = 2, p = 5
Output: Square root doesn't exist

Naive Solution : Try all numbers from 2 to p-1. And for every number x, check if x is square root of n
under modulo p.

// A Simple C++ program to find square root under modulo p
// when p is 7, 11, 19, 23, 31, ... etc,
#include<iostream>
// Returns true if square root of n under modulo p exists

{
n = n%p;
// One by one check all numbers from 2 to p-1

for (int x=2; x<p; x++)
{
if ((x*x)%p == n)
{
return;
}
}
cout << "Square root doesn't exist";
}

int main()
{
int p = 7;
int n = 2;
squareRoot(n, p);
return 0;
}

Output:

Square root is 3

Time Complexity of this solution is O(p)
Direct Method : If p is in the form of 3*i + 4, then there exist a Quick way of finding square root.

If n is in the form 4*i + 3 with i >= 1 (OR p % 4 = 3)
And
If Square root of n exists, then it must be
±n(p + 1)/4


// An efficient C++ program to find square root under
// modulo p when p is 7, 11, 19, 23, 31, ... etc.
#include<iostream>

// It returns (x^y) % p.
{
// equal to p
while (y > 0)
{
if (y & 1)
res = (res*x) % p;

y = y>>1; // y = y/2
x = (x*x) % p;
}
return res;
}
// Returns true if square root of n under modulo p exists

// Assumption: p is of the form 3*i + 4 where i >= 1
{
if (p % 4 != 3)
{
return;
}
// Try "+(n^((p + 1)/4))"

n = n % p;
int x = power(n, (p+1)/4, p);
if ((x*x)%p == n)
{
return;
return;
}
// Try "-(n ^ ((p + 1)/4))"

x = p - x;
if ((x*x)%p == n)
{
return;
}
// If none of the above two work, then

// square root doesn't exist
cout << "Square root doesn't exist ";
}

int main()
{
int p = 7;
int n = 2;
squareRoot(n, p);
return 0;
}

Output:
Time Complexity of this solution is O(Log p)
How does this work?

We have discussed Euler’s Criterion in the previous post.

As per Euler's criterion, if square root exists, then
following condition is true
n(p-1)/2 % p = 1
Multiplying both sides with n, we get

n(p+1)/2 % p = n % p ------ (1)
Let x be the modulo square root. We can write,

(x * x) ≡ n mod p
(x * x) ≡ n(p+1)/2 [Using (1) given above]
(x * x) ≡ n(2i + 2) [Replacing n = 4*i + 3]
x ≡ ±n(i + 1) [Taking Square root of both sides]
x ≡ ±n(p + 1)/4 [Putting 4*i + 3 = p or i = (p-3)/4]

We will soon be discussing methods when p is not in above form.
Find all possible binary trees with given Inorder Traversal
Given an array that represents Inorder Traversal, find all possible Binary Trees with the given Inorder
traversal and print their preorder traversals.
Examples:

Input: in[] = {3, 2};
Output: Preorder traversals of different possible Binary Trees are:
3 2
2 3
Below are different possible binary trees
3 2
\ /
2 3
Input: in[] = {4, 5, 7};

Output: Preorder traversals of different possible Binary Trees are:
4 5 7
4 7 5
5 4 7
7 4 5
7 5 4
Below are different possible binary trees
4 4 5 7 7
\ \ / \ / /
5 7 4 7 4 5
\ / \ /
7 5 5 4

Let given inorder traversal be in[]. In the given traversal, all nodes in left subtree of in[i] must appear
before it and in right subtree must appear after it. So when we consider in[i] as root, all elements from in[0]
to in[i-1] will be in left subtree and in[i+1] to n-1 will be in right subtree. If in[0] to in[i-1] can form x
different trees and in[i+1] to in[n-1] can from y different trees then we will have x*y total trees when in[i] as
root. So we simply iterate from 0 to n-1 for root. For every node in[i], recursively find different left and right
subtrees. If we take a closer look, we can notice that the count is basically n’th Catalan number. We have
discussed different approaches to find n’th Catalan number here.
The idea is to maintain a list of roots of all Binary Trees. Recursively construct all possible left and right
subtrees. Create a tree for every pair of left and right subtree and add the tree to list. Below is detailed
algorithm.

1) Initialize list of Binary Trees as empty.
2) For every element in[i] where i varies from 0 to n-1,
do following
......a) Create a new node with key as 'arr[i]',
let this node be 'node'
......b) Recursively construct list of all left subtrees.
......c) Recursively construct list of all right subtrees.
3) Iterate for all left subtrees
a) For current leftsubtree, iterate for all right subtrees
Add current left and right subtrees to 'node' and add
'node' to list.

struct Node
{
int key;
};

{
temp->key = item;
return temp;
}
void preorder(Node *root)

{
if (root != NULL)
{
}
}
vector<Node *> getTrees(int arr[], int start, int end)

{

vector<Node *> trees;

if (start > end)
if (start > end)
{
trees.push_back(NULL);
return trees;
}

for (int i = start; i <= end; i++)
{

vector<Node *> ltrees = getTrees(arr, start, i-1);

vector<Node *> rtrees = getTrees(arr, i+1, end);

for (int j = 0; j < ltrees.size(); j++)
{
for (int k = 0; k < rtrees.size(); k++)
{

Node * node = newNode(arr[i]);

node->left = ltrees[j];

node->right = rtrees[k];

trees.push_back(node);
}
}
}
return trees;
}
int main()
{
int in[] = {4, 5, 7};
int n = sizeof(in) / sizeof(in[0]);
vector<Node *> trees = getTrees(in, 0, n-1);
cout << "Preorder traversals of different "

<< "possible Binary Trees are \n";
for (int i = 0; i < trees.size(); i++)
{
preorder(trees[i]);
printf("\n");
}
return 0;
}

Output:

Preorder traversals of different possible Binary Trees are
4 5 7
4 7 5
5 4 7
7 4 5
7 5 4

Thanks to Utkarsh for suggesting above solution.
This problem is similar to the problem discussed here.
discussed above

Algorithm Book

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Algorithm Book

Uploaded by

Copyright:

Available Formats

GeeksforGeeks

Created By Jing Connect on LinkedIn

Input string = “test”

2: Return the index of maximum value in count array (returns ‘t’).

int *getCharCountArray(char *);

/* Returns the maximum occurring character in

/* Returns an array of size 256 containg count

for (i = 0; *(str+i); i++)

char getIndexOfMax(int ar[], int ar_size)

for(i = 1; i < ar_size; i++)

/* free memory allocated to count */

Time Complexity: O(n)

Algorithm: Let input string be “geeksforgeeks”

/* Fills count array with frequency of characters */

/* Print duplicates present in the passed string */

// Print characters having count more than 0

/* Driver program to test to pront printDups*/

Time Complexity: O(n)

METHOD 1 (Use Sorting)

1) Sort the elements.

/* Function to remove duplicates in a sorted array */

/* Utitlity function to sort array A[] */

/* Function removes duplicate characters from the string

/* Function to remove duplicates in a sorted array */

/* In place removal of duplicate characters*/

/* After above step string is stringiittg.

/* Driver program to test removeDups */

/* FOLLOWING FUNCTIONS ARE ONLY FOR SORTING

int partition(char A[], int si, int ei)

for (j = si; j <= ei - 1; j++)

/* Implementation of Quick Sort

METHOD 2 (Use Hashing )

/* Function removes duplicate characters from the string

/* In place removal of duplicate characters*/

/* After above step string is stringiittg.

/* Driver program to test removeDups */

Time Complexity: O(n)

/* Link list node */

/* Given a reference (pointer to pointer) to the head

/* put in the data */

/* Takes head pointer of the linked list and index

/* Drier program to test above function*/

Time Complexity: O(n)

struct node *temp = node_ptr->next;

/* Link list node */

/* Given a reference (pointer to pointer) to the head

/* put in the data */

/* link the old list off the new node */

/* move the head to point to the new node */

void printList(struct node *head)

/* Drier program to test above function*/

/* Use push() to construct below list

printf("\n Before deleting \n");

/* I m deleting the head itself.

printf("\n After deleting \n");

You can try this problem for doubly linked list.

2: Construct count array from mask_str. Count array would be:

4: Put a ‘\0′ at the end of the string?

/* Returns an array of size 256 containg count

/* removeDirtyChars takes two string as arguments: First

/* After above step string is ngring.

/* Driver program to test getCharCountArray*/

Algorithm: areRotations(str1, str2)

1. Create a temp string and store concatenation of str1 to

int getCharCountArray(char );

#define square(x) ((x)(x)) / Note that the expression

/Driver program to test above function/

/Driver program to test above function/