Merge branch 'master' of https://github.com/i-priyanshu/CompetitiveProgrammingQuestionBank

Author: i-priyanshu

DSA 450 GFG/max_sum_bottom_up.py

@@ -0,0 +1,29 @@
+#https://practice.geeksforgeeks.org/problems/maximum-sum-problem2211/1/
+
+
+#Approach 2 - Bottom Up approach 
+
+
+    def maxSum(self, n): 
+        # code here
+        dp = [0]*(n+1)
+        dp[0] = 0
+        if(n >= 1):
+            dp[1] = 1
+            for i in range(2 , n+1):
+                dp[i] = max((dp[int(i/2)] + dp[int(i/3)] + dp[int(i/4)]) , i)
+                
+        return dp[n]
+
+
+#{ 
+#  Driver Code Starts
+#Initial Template for Python 3
+
+if __name__ == '__main__': 
+    t = int(input())
+    for _ in range(t):
+        n = int(input())
+        ob = Solution()
+        print(ob.maxSum(n))
+# } Driver Code Ends

DSA 450 GFG/max_sum_memoization.py

@@ -0,0 +1,31 @@
+
+#https://practice.geeksforgeeks.org/problems/maximum-sum-problem2211/1/
+
+# Approach 1 - Memoization 
+
+from functools import lru_cache
+
+class Solution:
+    @lru_cache(maxsize = 1000)
+    def maxSum(self, n): 
+        # code here 
+        if(n == 0 or n == 1):
+            return n
+        else:
+            return max( (self.maxSum(n//2) + self.maxSum(n//3) + self.maxSum(n//4))  , n )
+
+
+
+#{ 
+#  Driver Code Starts
+#Initial Template for Python 3
+
+if __name__ == '__main__': 
+    t = int(input())
+    for _ in range(t):
+        n = int(input())
+        ob = Solution()
+        print(ob.maxSum(n))
+# } Driver Code Ends
+
+

Data Structures/Graphs/Center_Of_Star_Graph.cpp

@@ -0,0 +1,90 @@
+/* There is an undirected star graph consisting of n nodes labeled from 1 to n.
+ A star graph is an undirected graph that has n nodes in which one is center node and  has exactly n - 1 edges.
+
+ Given a 2D integer array edges where each edges[i] = [ui, vi] indicates that there is an edge between the nodes ui and vi.
+ Return the center of the given star graph.
+    4
+    |
+    2
+   / \
+  1   3 
+  
+ Here 2 is the answer.
+ 
+ Approach: Store the nodes in vector that are connected to partciular node, if size of that vector equals to nodes-1 then 
+ print it is the centre. */
+
+#include <bits/stdc++.h>
+using namespace std;
+
+int findCenter(vector<vector<int>>& edges)
+{
+        int n=edges.size()+1;
+        
+        vector<int>l[n+1];
+        
+        // Store the destintaion edges into source node vector
+        for(int i=0;i<edges.size();i++)
+        {
+                l[edges[i][0]].push_back(edges[i][1]);
+                l[edges[i][1]].push_back(edges[i][0]);
+        }
+         
+        // Check if vector size is equal to nodes-1, to find the center
+        int center;
+        for(int i=0;i<=n;i++)
+        {
+            if(l[i].size()==n-1)
+                center=i;
+        }
+        return center;
+}
+
+int main()
+{
+    int src,dest,no_of_edges;
+    cout<<"Enter number of edges"<<endl;
+    cin>>no_of_edges;
+    vector<vector<int>>edges;
+    
+    for(int i=0;i<no_of_edges;i++)
+    {
+        vector<int>temp;
+        
+        cout<<"Enter source of edge"<<endl;
+        cin>>src;
+        temp.push_back(src);
+        cout<<"Enter destination of edge"<<endl;
+        cin>>dest;
+        temp.push_back(dest);
+        
+        edges.push_back(temp);
+    }
+    cout<<"Center Of Star Graph : ";
+    cout<<(findCenter(edges));
+    return 0;
+}
+
+
+/* 
+INPUT:
+Enter number of edges
+3
+Enter source of edge
+1
+Enter destination of edge
+2
+Enter source of edge
+2
+Enter destination of edge
+3
+Enter source of edge
+4
+Enter destination of edge
+2
+OUTPUT:
+Center Of Star Graph : 2
+
+Time Complexity: O(no_of_edges)
+Space Complexity: O(no_of_edges)
+*/

Data Structures/Graphs/Khan_algo.py

@@ -0,0 +1,77 @@
+'''
+author :saurabh jain
+to find whether a graph has a cycle or not not
+if not than print the topological sorting for them
+'''
+from collections import defaultdict
+
+
+class solution:
+
+    def __init__(self, vrt):
+        self.vrt = vrt
+        self.graph = defaultdict(list)
+
+    def edges(self, u, v):
+        global vertex,indegree
+        self.graph[u].append(v)
+        if u not in indegree.keys():
+            indegree[u]=0
+        if v not in indegree.keys():
+            indegree[v]=1
+
+        else:
+            indegree[v]+=1
+        vertex.add(u)
+        vertex.add(v)
+
+    def topological(self):
+        global vertex,indegree
+        q=[]
+        count=0
+        for i in vertex:
+            if indegree[i]==0:
+                q.append(i)
+
+        result=[]
+
+        while q:
+
+            current=q.pop(0)
+            count+=1
+            result.append(current)
+
+
+
+            for i in self.graph[current]:
+                indegree[i]-=1
+                if indegree[i]==0:
+                    q.append(i)
+
+        if count!=len(vertex):
+            print("there is no topolical string ")
+        else:
+            print(result)
+
+
+
+        return
+
+
+
+
+
+indegree=defaultdict()
+vertex=set()
+
+g =solution(6)
+g.edges(5, 2);
+g.edges(5, 0);
+g.edges(4, 0);
+g.edges(4, 1);
+g.edges(2, 3);
+g.edges(3, 1)
+print(indegree)
+print(vertex)
+
+g.topological()

Data Structures/Graphs/RottenOranges.cpp

@@ -0,0 +1,73 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+#define f(i,a,b) for(int i = a;i<b;i++)
+class Solution
+{
+    public:
+    //Function to find minimum time required to rot all oranges.
+    void solve(int r, int c, queue<pair<int,int>>&q, vector<vector<int>>&grid){
+        int rr[4] = {-1,1,0,0};
+        int cc[4] = {0,0,-1,1};
+        for(int i = 0;i<4;i++){
+            int nr = r + rr[i];
+            int nc = c + cc[i];
+
+            if(nr<0 || nc<0 || nr>=grid.size()|| nc>=grid[0].size())continue;
+            if(grid[nr][nc] == 1){
+                grid[nr][nc] = 2;
+                q.push({nr,nc});
+            }
+
+        }
+    }
+    int orangesRotting(vector<vector<int>>& grid) {
+        queue<pair<int,int>>q;
+        f(i,0,grid.size()){
+            f(j,0,grid[0].size()){
+                if(grid[i][j] == 2){
+                    q.push({i,j});
+                }
+            }
+        }
+        int timer = -1;
+        while(!q.empty()){
+            int k = q.size();
+            while(k--){
+                int r = q.front().first;
+                int c = q.front().second;
+                q.pop();
+                solve(r,c,q,grid);
+            }
+            timer++;
+        }
+        for(auto i: grid){
+            for(auto j :i){
+                if(j == 1)return -1;
+            }
+
+        }
+        return timer;
+
+
+    }
+};
+
+int main(){
+	int tc;
+	cin >> tc;
+	while(tc--){
+		int n, m;
+		cin >> n >> m;
+		vector<vector<int>>grid(n, vector<int>(m, -1));
+		for(int i = 0; i < n; i++){
+			for(int j = 0; j < m; j++){
+				cin >> grid[i][j];
+			}
+		}
+		Solution obj;
+		int ans = obj.orangesRotting(grid);
+		cout << ans << "\n";
+	}
+	return 0;
+}  //