Day-59 Max Subarray prob and CTCI prob 2

Author: mandliya

README.md

@@ -6,9 +6,9 @@
 
 | Current Status|     Stats     |
 | :------------: | :----------: |
-| Total Problems | 82 |
-| Current Streak | 58 |
-| Longest Streak | 58 ( August 17, 2015 - October 13, 2015 ) |
+| Total Problems | 84 |
+| Current Streak | 59 days |
+| Longest Streak | 59 ( August 17, 2015 - October 14, 2015 ) |
 
 </center>
 
@@ -83,12 +83,14 @@ Include contains single header implementation of data structures and some algori
 | Problem 1-8: Write an algorithm such that if an element of MxN matrix is 0, its entire row and column is set to 0. | [1-8-zero-matrix.cpp](cracking_the_coding_interview_problems/1-8-zero-matrix.cpp)|
 | Problem 1-9: Given two strings s1 and s2, determine s2 is rotation of s1 using only one call to a function which checks whether one string is rotation of another.|[1-9-string-rotation.cpp](cracking_the_coding_interview_problems/1-9-string-rotation.cpp)|
 | Problem 2-1: Remove duplicates from an *unsorted* linked list. What if no temporary buffer is allowed.|[2-1-remove-dups.cpp](cracking_the_coding_interview_problems/2-1-remove-dups.cpp)|
+| Problem 2-2: Determine k<sup>th</sup> node from the last of a singly linked list. (Iterative and Recursive Approaches) | [2-2-kthToLast.cpp](cracking_the_coding_interview_problems/2-2-kthToLast.cpp)|
 
 ###Dynamic Programming Problems
 | Problem | Solution |
 | :------------ | :----------: |
 | N<sup>th</sup> Fibonacci term using different memoization techniques | [fibonacci.cpp](dynamic_programming_problems/fibonacci.cpp)|
 | Longest Common Subsequence Problem | [lcs.cpp](dynamic_programming_problems/lcs.cpp) | 
+| Maximum Value Contigous Subsequence Problem [wiki](https://en.wikipedia.org/wiki/Maximum_subarray_problem)| [max_subsequence.cpp](dynamic_programming_problems/max_subsequence.cpp)|
 
 ### Tree Problems
 | Problem | Solution |

cracking_the_coding_interview_problems/2-2-kthToLast.cpp

@@ -0,0 +1,161 @@
+/**
+ *  Cracking the coding interview edition 6
+ *  Problem 2.2
+ *  Return kth to last
+ *  Implement an algorithm to find the kth to last element of a singly linked list.
+ *  We can assume we are not provided the length of the list.
+ *
+ *  Approaches:
+ *  1. Iterative:
+ *  	 Use two pointers
+ *  	 Move first pointer k places.
+ *  	 Now move second pointer(from start) and first pointer (from k+1) simultanously.
+ *  	 When second pointer would have reached end, first pointer would be at kth node.
+ *
+ *  2. Recursive:
+ *  	 Maintain an index to keep track of node.
+ *  	 Solve the problem for n-1 nodes and add 1 to index.
+ *  	 Since each parent call is adding 1, when counter reaches k,
+ *  	 we have reached length-k node from start, which is kth node from last.
+ */
+
+#include <iostream>
+
+struct Node {
+  int data;
+  Node * next;
+  Node(int d) : data{ d }, next{ nullptr } { }
+};
+
+
+/**
+ * Insert to the head of the list
+ * @param head - Current head of list
+ * @param data - new node's data
+ */
+void insert( Node * & head, int data ) {
+  Node * newNode = new Node(data);
+  newNode->next = head;
+  head = newNode;
+}
+
+/**
+ * [deleteList - delete the entire list]
+ * @param head - head of the list
+ */
+void deleteList( Node * & head ) {
+  Node * nextNode;
+  while(head) {
+    nextNode = head->next;
+    delete(head);
+    head = nextNode;
+  }
+}
+
+/**
+ * printList - Print the list
+ * @param head - Current head of the list.
+ */
+void printList( Node * head ) {
+  while(head) {
+    std::cout << head->data << "-->";
+    head = head->next;
+  }
+  std::cout << "null" << std::endl;
+}
+
+/**
+ * [kthToLastHelper - helper routine to find nth node for recursive approach
+ * @param  head  - head of the list
+ * @param  k     - the k value for finding kth element from last of the list.
+ * @param  i     - an index maintained to keep track of current node.
+ * @return       - kth node from last.
+ */
+Node * kthToLastHelper( Node * head, int k , int & i) {
+  if ( head == nullptr ) {
+    return nullptr;
+  }
+
+  Node * node = kthToLastHelper(head->next, k, i);
+  i = i + 1;
+  //if we have solved problem k times from last.
+  if ( i == k ) {
+    return head;
+  }
+  return node;
+}
+
+/**
+ * kthToLastRecursive - Recursive approach for finding kth to last element of list.
+ * @param  head  - head of node
+ * @param  k     - the k value for finding kth element from last of the list.
+ * @return       - kth node from last.
+ */
+Node * kthToLastRecursive( Node * head, int k ) {
+  int i = 0;
+  return kthToLastHelper(head, k, i);
+}
+
+/**
+ * kthToLastIterative -  Iterative approach for finding kth to last element of list.
+ * @param  head  - head of node
+ * @param  k     - the k value for finding kth element from last of the list.
+ * @return       - kth node from last.
+ */
+Node * kthToLastIterative( Node * head, int k ) {
+  if ( head == nullptr ) {
+    return head;
+  }
+
+  Node * ptr1 = head;
+  Node * ptr2 = head;
+
+  int i = 0;
+  while( i < k && ptr1 ) {
+    ptr1 = ptr1->next;
+    ++i;
+  }
+
+  //out of bounds
+  if ( i < k ) {
+    return nullptr;
+  }
+
+  while( ptr1 != nullptr ) {
+    ptr1 = ptr1->next;
+    ptr2 = ptr2->next;
+  }
+
+  return ptr2;
+}
+
+
+
+int main() {
+  Node * head = nullptr;
+  for ( int i = 7; i > 0; i-- ) {
+    insert(head, i);
+  }
+  std::cout << "List: ";
+  printList(head);
+
+  std::cout << "4th node from last (Recursive) : ";
+  Node *node4 = kthToLastRecursive(head, 4);
+  if ( node4 != nullptr ) {
+    std::cout << node4->data << std::endl;
+  } else {
+    std::cout << "NULL NODE\n";
+  }
+
+  std::cout << "4th node from last (Iterative) : ";
+  node4 = kthToLastIterative(head, 4);
+  if ( node4 != nullptr ) {
+    std::cout << node4->data << std::endl;
+  } else {
+    std::cout << "NULL NODE\n";
+  }
+
+  deleteList(head);
+
+  return 0;
+}

dynamic_programming_problems/max_subsequence.cpp

@@ -0,0 +1,137 @@
+/**
+ * Maximum Value Contiguous Subsequence
+ * Given an array of n numbers, give an algorithm for finding a contigous
+ * subsequence A(i)...A(j) for which the sum of elements is maximum.
+ * Example - { -2, 11, -4, 13, -5, 2} --> 20 i.e. { 11, -4, 13}
+ * Example - { 1, -3, 4, -2, -1, 6} --> 7 { 4, -2, -1, 6}
+ *
+ * Approach :
+ * For selecting an ith element, we have to make a decision
+ * 			- Add it to the old sum M(i-1) + A[i]
+ * 			- or start the new window with one element A[i]
+ *
+ * We will use above approach in solving it with O(n) space and with O(1) space (Kadane's approach).
+ * Special Case:
+ * If all the elements are positive then, we the Maximum Value Contigous Subsequence would be the entire set
+ *
+ */
+
+
+#include <iostream>
+#include <vector>
+#include <algorithm>
+#include <limits>
+
+//approach one using O(n) space.
+int max_contigous_subsequence_sum( const std::vector<int> & v ) {
+
+  //special case when all the elements are negative.
+  bool allNegativeOrZero = true;
+  int maxSum = std::numeric_limits<int>::min();
+  for ( size_t i = 0; i < v.size(); ++i ) {
+    if ( v[i] > 0 ) {
+      allNegativeOrZero = false;
+    }
+    if (v[i] > maxSum) {
+      maxSum = v[i];
+    }
+  }
+
+  if (allNegativeOrZero) {
+    return maxSum;
+  }
+
+  maxSum = 0;
+
+  std::vector<int> M(v.size(), 0);
+  if (v[0] > 0) {
+    M[0] = v[0];
+  }
+  for (size_t i = 1; i < v.size(); ++i) {
+    if ( M[i-1] + v[i] > 0 ) {
+      M[i] = M[i-1] + v[i];
+    } else {
+      M[i] = 0;
+    }
+  }
+  for ( size_t i = 0; i < v.size(); ++i ) {
+    if (M[i] > maxSum) {
+      maxSum = M[i];
+    }
+  }
+  return maxSum;
+}
+
+//approach two
+// Kadane's algorithm.
+// Since we care about sum till i-1 for calculating i
+// and we need to pick the maximum of all the sums eventully,
+// We don't really need an array to store sums.
+// We have to take care of special case when array contains only negative nums.
+int max_contigous_subsequence_sum2( std::vector<int> & v ) {
+  int max_so_far = std::numeric_limits<int>::min();
+  int sum_so_far = 0;
+
+  //special case all negative or zero
+  bool allNegativeOrZero = true;
+  for ( size_t i = 0; i < v.size(); ++i ) {
+    if ( v[i] > 0 ) {
+      allNegativeOrZero = false;
+    }
+    if ( v[i] > max_so_far ) {
+      max_so_far = v[i];
+    }
+  }
+  if (allNegativeOrZero) {
+    return max_so_far;
+  }
+
+  //case 2 normal case;
+  max_so_far = 0;
+  for ( size_t i = 0; i < v.size(); ++i ) {
+    sum_so_far += v[i];
+    if ( sum_so_far < 0 ) {
+      sum_so_far = 0;
+    }
+    if ( max_so_far < sum_so_far ) {
+      max_so_far = sum_so_far;
+    }
+  }
+  return max_so_far;
+}
+
+
+void printVec(const std::vector<int> & vec) {
+  for(auto x : vec) {
+    std::cout << x << " ";
+  }
+  std::cout << std::endl;
+}
+
+int main()
+{
+  std::vector<int> vec{ -2, 11, -4, 13, -5, 2};
+  std::cout << "Vector: ";
+  printVec(vec);
+  std::cout << "Sum of Maximum Contiguous Subarray for above vector is : "
+            << max_contigous_subsequence_sum(vec) << std::endl;
+
+  std::vector<int> vec1{ -2, -1, -4, -3, -5, -2};
+  std::cout << " Special Vector: ";
+  printVec(vec1);
+  std::cout << "Sum of Maximum Contiguous Subarray for above vector is : "
+            << max_contigous_subsequence_sum(vec1) << std::endl;
+
+  std::vector<int> vec2{ -200, -100, -50, -70, -500, -51};
+  std::cout << " Special Vector: ";
+  printVec(vec2);
+  std::cout << "Sum of Maximum Contiguous Subarray for above vector is : "
+            << max_contigous_subsequence_sum(vec2) << std::endl;
+
+  std::vector<int> vec3{ 1, -3, 4, -2, -1, 6 };
+  std::cout << "Vector: ";
+  printVec(vec3);
+  std::cout << "Sum of Maximum Contiguous Subarray for above vector is : "
+            << max_contigous_subsequence_sum(vec3) << std::endl;
+  return 0;
+}