Merge pull request #241 from paurush11/master

WordBoggle.cpp

Author: smv1999

Data Structures/Graphs/WordBoggle.cpp

@@ -0,0 +1,89 @@
+// Given a dictionary of distinct words and an M x N board where every cell has one character. Find all possible words from the dictionary that can be formed by a sequence of adjacent characters on the board. We can move to any of 8 adjacent characters, but a word should not have multiple instances of the same cell.
+// Example 1:
+
+// Input:
+// N = 1
+// dictionary = {"CAT"}
+// R = 3, C = 3
+// board = {{C,A,P},{A,N,D},{T,I,E}}
+// Output:
+// CAT
+// Explanation:
+// C A P
+// A N D
+// T I E
+// Words we got is denoted using same color.
+// Example 2:
+
+// Input:
+// N = 4
+// dictionary = {"GEEKS","FOR","QUIZ","GO"}
+// R = 3, C = 3
+// board = {{G,I,Z},{U,E,K},{Q,S,E}}
+// Output:
+// GEEKS QUIZ
+// Explanation:
+// G I Z
+// U E K
+// Q S E
+// Words we got is denoted using same color.
+
+// Companies
+// Amazon Directi Facebook Google MakeMyTrip Microsoft Nvidia Yahoo
+
+// Expected Time Complexity: O(NW + RC^2)
+// Expected Auxiliary Space: O(NW + RC)
+------------------------------------------------------------
+
+#include<bits/stdc++.h>
+using namespace std;
+
+class Solution {
+public:
+
+    bool isfullyfound(int r, int c, int index, vector<vector<char>>& board, vector<vector<bool>>&visited, string word){
+        if(index == word.size()){
+            return true;
+        }
+        if(r>=0 && r<board.size() && c>=0 && c<board[0].size() && !visited[r][c] && word[index] == board[r][c]){
+            visited[r][c] = true;
+            if( isfullyfound(r-1,c,index+1,board,visited,word) ||
+                isfullyfound(r+1,c,index+1,board,visited,word) ||
+                isfullyfound(r,c-1,index+1,board,visited,word) ||
+                isfullyfound(r,c+1,index+1,board,visited,word) ||
+                isfullyfound(r+1,c+1,index+1,board,visited,word) ||
+                isfullyfound(r+1,c-1,index+1,board,visited,word) ||
+                isfullyfound(r-1,c-1,index+1,board,visited,word) ||
+                isfullyfound(r-1,c+1,index+1,board,visited,word)
+            )return true;
+
+            visited[r][c] = false;
+        }
+        return false;
+    }
+    bool wordfound(string word,vector<vector<char>>& board){
+        int index = 0;
+        vector<vector<bool>>visited(board.size(), vector<bool>(board[0].size(), false));
+        for(int i = 0;i<board.size();i++){
+            for(int j = 0;j<board[0].size();j++){
+                if(word[index] == board[i][j]){
+                    if(isfullyfound(i,j,index,board,visited,word)){
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+
+    }
+	vector<string> wordBoggle(vector<vector<char> >& board, vector<string>& dictionary) {
+	    vector<string>v;
+	    for(auto i: dictionary){
+	        if(wordfound(i,board)){
+	            v.push_back(i);
+	        }
+	    }
+	    return v;
+	}
+};
+

Data Structures/Trees/Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal.cpp

@@ -0,0 +1,48 @@
+// Leetcode problem for Binary Tree
+// 105. Construct Binary Tree from Preorder and Inorder Traversal
+
+// Given two integer arrays preorder and inorder where preorder is the preorder traversal of a binary tree and inorder is the inorder traversal of the same tree, construct and return the binary tree.
+
+// Example 1:
+
+// Input: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]
+// Output: [3,9,20,null,null,15,7]
+// Example 2:
+
+// Input: preorder = [-1], inorder = [-1]
+// Output: [-1]
+----------------------------------------------------------------------------
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution {
+public:
+    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
+        int pre = 0;
+        return maketree(pre,0,preorder.size()-1,inorder,preorder);
+    }
+
+    TreeNode* maketree(int &pre, int start, int end,vector<int>& inorder, vector<int>& postorder){
+        if(start>end || pre>postorder.size())return NULL;
+    TreeNode* root = new TreeNode(postorder[pre]);
+    int index = -1;
+    for(int i = start;i<=end;i++){
+        if(inorder[i] == postorder[pre]){
+            index = i;
+            break;
+        }
+    }
+    pre++;
+    root->left = maketree(pre,start, index-1,inorder,postorder);
+    root->right = maketree(pre,index+1, end,inorder,postorder);
+    return root;
+    }
+};