Day 72 : One DP and one tree problem

Author: mandliya

README.md

@@ -6,9 +6,9 @@
 
 | Current Status|     Stats     |
 | :------------: | :----------: |
-| Total Problems | 103 |
-| Current Streak | 71 days |
-| Longest Streak | 71 ( August 17, 2015 - October 26, 2015 ) |
+| Total Problems | 105 |
+| Current Streak | 72 days |
+| Longest Streak | 72 ( August 17, 2015 - October 27, 2015 ) |
 
 </center>
 
@@ -180,3 +180,5 @@ Include contains single header implementation of data structures and some algori
 |Given an array nums, write a function to move all 0's to the end of it while maintaining the relative order of the non-zero elements. For example, given nums = [0, 1, 0, 3, 12], after calling your function, nums should be [1, 3, 12, 0, 0].| [moveZeroes.cpp](leet_code_problems/moveZeroes.cpp)|
 |Given an array of integers, find if the array contains any duplicates. Function should return true if any value appears at least twice in the array, and it should return false if every element is distinct.| [containsDuplicate.cpp](leet_code_problems/containsDuplicate.cpp)|
 | Given a list, rotate the list to the right by k places, where k is non-negative. For example: <ul><li>Given 1->2->3->4->5->NULL and k = 2, return 4->5->1->2->3->NULL</li></ul>| [rotateList.cpp](leet_code_problems/rotateList.cpp)|
+| Given two words word1 and word2, find the minimum number of steps required to convert word1 to word2. (each operation is counted as 1 step.). You have the following 3 operations permitted on a word:<ul><li>Insert a character</li></ul><ul><li>Delete a character.</li></ul><ul><li>Replace a character</li></ul>.|[editDistance.cpp](leet_code_problems/editDistance.cpp)|
+|Given a binary tree, Populate each next pointer to point to its next right node. If there is no next right node, the next pointer should be set to NULL. Initially, all next pointers are set to NULL.You may only use constant extra space.You may assume that it is a perfect binary tree (ie, all leaves are at the same level, and every parent has two children).| [connectNextPointers.cpp](leet_code_problems/connectNextPointers.cpp)|

leet_code_problems/connectNextPointers.cpp

@@ -0,0 +1,84 @@
+/**
+ * Populate each next pointer to point to its next right node. If there is no next right node, the next pointer should be set to NULL.
+ *
+ * Initially, all next pointers are set to NULL.
+ *
+ * Note:
+ *
+ * You may only use constant extra space.
+ * You may assume that it is a perfect binary tree (ie, all leaves are at the same level, and every parent has two children).
+ *
+ */
+
+
+#include<iostream>
+#include<queue>
+
+struct TreeLinkNode {
+	int data;
+	TreeLinkNode * left;
+	TreeLinkNode * right;
+	TreeLinkNode * next;
+	TreeLinkNode( int d ) : data{ d }, left{ nullptr }, right{ nullptr }, next{ nullptr } {}
+};
+
+void connect(TreeLinkNode *root) {
+	if( root == nullptr) {
+		return;
+	}
+	std::queue<TreeLinkNode*> qu;
+	qu.push(root);
+	qu.push(nullptr);
+	TreeLinkNode * curr = nullptr;
+	while(!qu.empty()) {
+		curr = qu.front();
+		qu.pop();
+		if ( curr == nullptr ) {
+			if (!qu.empty()) {
+				qu.push(nullptr);
+			}
+			continue;
+		}
+		if (!qu.empty()) {
+			curr->next = qu.front();
+		} else {
+			curr->next = nullptr;
+		}
+		if ( curr->left ) {
+			qu.push(curr->left);
+		}
+		if ( curr->right ) {
+			qu.push(curr->right);
+		}
+	}
+}
+
+void printTree( TreeLinkNode * root ) {
+	if (root) {
+		std::cout << "Node value " << root->data << "-->";
+		if ( root->next != nullptr ) {
+			std::cout << root->next->data << std::endl;
+		} else {
+			std::cout << "nullptr" << std::endl;
+		}
+		printTree(root->left);
+		printTree(root->right);
+	}
+}
+
+
+int main() {
+	TreeLinkNode * root = new TreeLinkNode(1);
+	root->left = new TreeLinkNode(2);
+	root->right = new TreeLinkNode(3);
+	root->left->left = new TreeLinkNode(4);
+	root->left->right = new TreeLinkNode(5);
+	root->right->left = new TreeLinkNode(6);
+	root->right->right = new TreeLinkNode(7);
+	std::cout << "Before Connect:\n";
+	printTree(root);
+	connect(root);
+	std::cout << "After Connect:\n";
+	printTree(root);
+	return 0;
+}

leet_code_problems/editDistance.cpp

@@ -0,0 +1,62 @@
+/**
+ * Given two words word1 and word2, find the minimum number of steps required to convert word1 to word2. (each operation is counted as 1 step.)
+ *
+ * You have the following 3 operations permitted on a word:
+ *
+ * a) Insert a character
+ * b) Delete a character
+ * c) Replace a character
+ *
+ */
+
+#include <iostream>
+#include <string>
+
+using std::string;
+
+int min( int a, int b, int c ) {
+	int minab = ( a  < b ) ? a : b;
+	return ( minab < c ) ? minab:c;
+}
+
+int minEditDistance(string word1, string word2) {
+	int len1 = word1.size();
+	int len2 = word2.size();
+	int minCost;
+	int ** table = new int*[len1+1];
+	for ( int i = 0;i <= len1; ++i ) {
+		table[i] = new int[len2+1];
+	}
+
+	for (int i = 0; i <= len1; ++i) {
+		for (int j = 0; j <= len2; ++j ) {
+			if ( i == 0 ) {
+				table[i][j] = j;
+			}
+			else if ( j == 0 ) {
+				table[i][j] = i;
+			} else if ( word1[i-1] == word2[j-1]) {
+				table[i][j] = table[i-1][j-1];
+			} else {
+				table[i][j] = 1+ min(table[i-1][j-1], table[i][j-1], table[i-1][j]);
+			}
+		}
+	}
+	minCost = table[len1][len2];
+	for ( int i = 0; i <= len1; ++i ) {
+		delete table[i];
+	}
+	delete[] table;
+	return minCost;
+}
+
+
+int main() {
+	std::string word1, word2;
+	std::cout << "Enter word 1 : " ;
+	std::cin >> word1;
+	std::cout << "Enter word 2 : " ;
+	std::cin >> word2;
+	std::cout << "Min edit distance : " << minEditDistance(word1, word2) << std::endl;
+	return 0;
+}