Add files via upload

Author: shashankch292

GraphDataStructure&Algorithms/BlackShapes.cpp

@@ -0,0 +1,65 @@
+/*
+Given N * M field of O's and X's, where O=white, X=black
+Return the number of black shapes. A black shape consists of one or more adjacent X's (diagonals not included)
+
+Example:
+
+OOOXOOO
+OOXXOXO
+OXOOOXO
+
+answer is 3 shapes are :
+(i) X
+ X X
+(ii)
+ X
+ (iii)
+ X
+ X
+Note that we are looking for connected shapes here.
+
+For example,
+
+XXX
+XXX
+XXX
+is just one single connected black shape.
+
+LINK: https://www.interviewbit.com/problems/black-shapes/
+*/
+
+int n,m;
+int X[] = {0, 0, 1, -1};
+int Y[] = {1, -1, 0, 0};
+ 
+void dfs(int x, int y, vector<string> &A)
+{
+ A[x][y] = 'O';
+ 
+ for(int i=0;i<4;i++)
+ {
+ int newx = x+X[i];
+ int newy = y+Y[i];
+ 
+ if(newx>=0 && newx<n && newy>=0 && newy<m && A[newx][newy]=='X')
+ dfs(newx,newy,A);
+ }
+}
+ 
+int Solution::black(vector<string> &A)
+{
+ n = A.size();
+ m = A[0].size();
+ 
+ int ans = 0;
+ 
+ for(int i=0;i<n;i++)
+ for(int j=0;j<m;j++)
+ if(A[i][j] == 'X')
+ {
+ ans++;
+ dfs(i,j,A);
+ }
+ 
+ return ans;
+}

GraphDataStructure&Algorithms/CaptureRegionsOnBoard.cpp

@@ -0,0 +1,75 @@
+/*
+Given a 2D board containing 'X' and 'O', capture all regions surrounded by 'X'.
+
+A region is captured by flipping all 'O's into 'X's in that surrounded region.
+
+For example,
+
+X X X X
+X O O X
+X X O X
+X O X X
+After running your function, the board should be:
+
+X X X X
+X X X X
+X X X X
+X O X X
+
+LINK: https://www.interviewbit.com/problems/capture-regions-on-board/
+*/
+
+int m,n;
+vector<vector<bool> > vis;
+ 
+int X[] = {0, 0, 1, -1};
+int Y[] = {1, -1, 0, 0};
+ 
+void dfs(int x, int y, vector<vector<char> > &A)
+{
+ vis[x][y] = true;
+ 
+ for(int i=0;i<4;i++)
+ {
+ int newx = x + X[i];
+ int newy = y + Y[i];
+ 
+ if(newx>=0 && newx<m && newy>=0 && newy<n && vis[newx][newy]==false && A[newx][newy]=='O')
+ dfs(newx,newy,A);
+ }
+}
+ 
+void Solution::solve(vector<vector<char> > &A)
+{
+ // Do not write main() function.
+ // Do not read input, instead use the arguments to the function.
+ // Do not print the output, instead return values as specified
+ // Still have a doubt. Checkout www.interviewbit.com/pages/sample_codes/ for more details
+ 
+ m = A.size();
+ n = A[0].size();
+ 
+ vis.clear();
+ vis.resize(m, vector<bool>(n, false));
+ 
+ for(int i=0;i<m;i++)
+ {
+ if(A[i][0] == 'O' && vis[i][0] == false)
+ dfs(i,0,A);
+ if(A[i][n-1] == 'O' && vis[i][n-1] == false)
+ dfs(i,n-1,A);
+ }
+ 
+ for(int j=0;j<n;j++)
+ {
+ if(A[0][j] == 'O' && vis[0][j]==false)
+ dfs(0,j,A);
+ if(A[m-1][j] == 'O' && vis[m-1][j]==false)
+ dfs(m-1,j,A);
+ }
+ 
+ for(int i=0;i<m;i++)
+ for(int j=0;j<n;j++)
+ if(A[i][j] == 'O' && !vis[i][j])
+ A[i][j] = 'X';
+}

GraphDataStructure&Algorithms/CloneGraph.cpp

@@ -0,0 +1,50 @@
+/*
+Clone an undirected graph. Each node in the graph contains a label and a list of its neighbors.
+
+LINK: https://www.interviewbit.com/problems/clone-graph/
+*/
+
+/**
+ * Definition for undirected graph.
+ * struct UndirectedGraphNode {
+ * int label;
+ * vector<UndirectedGraphNode *> neighbors;
+ * UndirectedGraphNode(int x) : label(x) {};
+ * };
+ */
+UndirectedGraphNode *Solution::cloneGraph(UndirectedGraphNode *node)
+{
+ if(node == NULL)
+ return node;
+ 
+ unordered_map<UndirectedGraphNode*, UndirectedGraphNode*> mp;
+ queue<UndirectedGraphNode*> q;
+ 
+ UndirectedGraphNode* src = new UndirectedGraphNode(node->label);
+ mp[node] = src;
+ 
+ q.push(node);
+ 
+ while(!q.empty())
+ {
+ UndirectedGraphNode* u = q.front();
+ q.pop();
+ 
+ vector<UndirectedGraphNode*> v = u->neighbors;
+ int n = v.size();
+ 
+ for(int i=0;i<n;i++)
+ {
+ if(mp[v[i]] == NULL)
+ {
+ UndirectedGraphNode* temp = new UndirectedGraphNode(v[i]->label);
+ mp[v[i]] = temp;
+ q.push(v[i]);
+ }
+ 
+ mp[u]->neighbors.push_back(mp[v[i]]);
+ }
+ }
+ 
+ return src;
+}

GraphDataStructure&Algorithms/CommutableIslands.cpp

@@ -0,0 +1,79 @@
+/*
+There are n islands and there are many bridges connecting them. Each bridge has some cost attached to it.
+
+We need to find bridges with minimal cost such that all islands are connected.
+
+It is guaranteed that input data will contain at least one possible scenario in which all islands are connected with each other.
+
+Example :
+Input
+
+ Number of islands ( n ) = 4
+ 1 2 1 
+ 2 3 4
+ 1 4 3
+ 4 3 2
+ 1 3 10
+In this example, we have number of islands(n) = 4 . Each row then represents a bridge configuration. In each row first two numbers represent the islands number which are connected by this bridge and the third integer is the cost associated with this bridge.
+
+In the above example, we can select bridges 1(connecting islands 1 and 2 with cost 1), 3(connecting islands 1 and 4 with cost 3), 4(connecting islands 4 and 3 with cost 2). Thus we will have all islands connected with the minimum possible cost(1+3+2 = 6). 
+In any other case, cost incurred will be more.
+
+LINK: https://www.interviewbit.com/problems/commutable-islands/
+*/
+
+int Rank[1000005];
+int Parent[1000005];
+ 
+int Find(int x)
+{
+ if(x!=Parent[x])
+ Parent[x] = Find(Parent[x]);
+ return Parent[x];
+}
+ 
+int Union(int u, int v, int cost)
+{
+ int x = Find(u);
+ int y = Find(v);
+ 
+ if(x==y)
+ return 0;
+ 
+ if(Rank[x] > Rank[y])
+ {
+ Parent[y] = x;
+ Rank[x] += Rank[y];
+ }
+ else
+ {
+ Parent[x] = y;
+ Rank[y] += Rank[x];
+ }
+ 
+ return cost;
+}
+ 
+bool comp(const vector<int> &a, const vector<int> &b)
+{
+ return a[2] < b[2];
+}
+ 
+int Solution::solve(int A, vector<vector<int> > &B)
+{
+ for(int i=0;i<A;i++)
+ {
+ Parent[i] = i;
+ Rank[i] = 1;
+ }
+ 
+ sort(B.begin(), B.end(), comp);
+ 
+ int n = B.size();
+ int ans = 0;
+ 
+ for(int i=0;i<n;i++)
+ ans += Union(B[i][0]-1, B[i][1]-1, B[i][2]);
+ 
+ return ans;
+}

GraphDataStructure&Algorithms/ConvertSortedListToBinarySearchTree.cpp

@@ -0,0 +1,70 @@
+/*
+Given a singly linked list where elements are sorted in ascending order, convert it to a height balanced BST.
+
+ A height balanced BST : a height-balanced binary tree is defined as a binary tree in which the depth of the two subtrees of every node never differ by more than 1. 
+Example :
+
+
+Given A : 1 -> 2 -> 3
+A height balanced BST :
+
+ 2
+ / \
+ 1 3
+
+LINK: https://www.interviewbit.com/problems/convert-sorted-list-to-binary-search-tree/
+*/
+
+/**
+ * Definition for binary tree
+ * struct TreeNode {
+ * int val;
+ * TreeNode *left;
+ * TreeNode *right;
+ * TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ * int val;
+ * ListNode *next;
+ * ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+ 
+TreeNode* convertToBST(ListNode** head, int n)
+{
+ if(n<=0)
+ return NULL;
+ 
+ TreeNode* left = convertToBST(head, n/2);
+ 
+ TreeNode* root = new TreeNode((*head)->val);
+ root->left = left;
+ 
+ (*head) = (*head)->next;
+ 
+ root->right = convertToBST(head, n-n/2-1);
+ 
+ return root;
+}
+ 
+TreeNode* Solution::sortedListToBST(ListNode* A)
+{
+ // Do not write main() function.
+ // Do not read input, instead use the arguments to the function.
+ // Do not print the output, instead return values as specified
+ // Still have a doubt. Checkout www.interviewbit.com/pages/sample_codes/ for more details
+ 
+ int cnt = 0;
+ ListNode* temp = A;
+ 
+ while(temp)
+ {
+ temp = temp->next;
+ cnt++;
+ }
+ 
+ return convertToBST(&A, cnt);
+}