Practise 18-Jul-2020

Author: sureshmangs

array/array_product_except_ith_element.cpp

@@ -0,0 +1,71 @@
+/*
+Given an array A of size N, construct a Product Array P (of same size) such that P is equal to the product of all the elements of A except A[i].
+
+Input:
+The first line of input contains an integer T denoting the number of test cases. T testcases follow. Each testcase contains two lines of input. The first line is N. The second line contains N elements separated by spaces.
+
+Output:
+For each testcase, print the Product array P.
+
+Constraints:
+1 <= T <= 10
+1 <= N <= 1000
+1 <= Ai <= 20
+
+Example:
+Input:
+2
+5
+10 3 5 6 2
+2
+12 20
+Output:
+180 600 360 300 900
+20 12
+
+Explanation:
+Testcase1: For the product array P, at i=0 we have 3*5*6*2. At i=1 10*5*6*2. At i=2 we have 10*3*6*2. At i=3 we have 10*3*5*2. At i=4 we have 10*3*5*6
+So P is 180 600 360 300 900
+*/
+
+
+
+
+
+#include<bits/stdc++.h>
+using namespace std;
+
+int main(){
+    ios_base::sync_with_stdio(false);
+    cin.tie(NULL);
+    cout.tie(NULL);
+    int t;
+    cin>>t;
+    while(t--){
+        int n;
+        cin>>n;
+        int a[n];
+        for(int i=0;i<n;i++) cin>>a[i];
+        int left[n], right[n], res[n];
+        int prod=1;
+        left[0]=1;
+        right[n-1]=1;
+
+        for(int i=1;i<n;i++)
+            left[i]=a[i-1]*left[i-1];
+
+        for(int i=n-2;i>=0;i--)
+            right[i]=a[i+1]*right[i+1];
+
+        res[0]=right[0];
+        res[n-1]=left[n-1];
+        for(int i=1;i<n-1;i++)
+            res[i]=left[i]*right[i];
+
+        for(int i=0;i<n;i++)
+         cout<<res[i]<<" ";
+         cout<<endl;
+    }
+
+return 0;
+}

competitive programming/leetcode/130. Surrounded Regions.cpp

@@ -0,0 +1,70 @@
+Given a 2D board containing 'X' and 'O' (the letter O), capture all regions surrounded by 'X'.
+
+A region is captured by flipping all 'O's into 'X's in that surrounded region.
+
+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
+Explanation:
+
+Surrounded regions shouldn’t be on the border, which means that any 'O' on the border of the board are not flipped to 'X'. Any 'O' that is not on the border and it is not connected to an 'O' on the border will be flipped to 'X'. Two cells are connected if they are adjacent cells connected horizontally or vertically.
+
+
+
+
+
+
+
+
+
+class Solution {
+public:
+
+    void dfs(vector<vector<char> >& board, int x, int y){
+        if(x>=0 && x< board.size() && y>=0 && y< board[0].size() && board[x][y]=='O'){
+            board[x][y]='P';
+            dfs(board,x-1,y);
+            dfs(board,x+1,y);
+            dfs(board,x,y-1);
+            dfs(board,x,y+1);
+        } else return;
+    }
+
+    void solve(vector<vector<char>>& board) {
+        int rows=board.size();
+        if(rows==0) return;
+        int cols=board[0].size();
+        if(cols==0) return;
+
+        for(int i=0; i<cols;i++){
+            if(board[0][i]=='O')    // first row
+                dfs(board, 0, i);
+            if(board[rows-1][i]=='O')    // last row
+                dfs(board, rows-1, i);
+        }
+
+        for(int i=0; i<rows;i++){
+            if(board[i][0]=='O')    // first col
+                dfs(board, i, 0);
+            if(board[i][cols-1]=='O')    // last col
+                dfs(board, i, cols-1);
+        }
+
+        for(int i=0;i<rows;i++){
+            for(int j=0;j<cols;j++){
+                if(board[i][j]=='O') board[i][j]='X';
+                if(board[i][j]=='P') board[i][j]='O';
+
+            }
+        }
+    }
+};

competitive programming/leetcode/2020-June-Challenge/Day-17-Surrounded Regions.cpp

@@ -0,0 +1,70 @@
+Given a 2D board containing 'X' and 'O' (the letter O), capture all regions surrounded by 'X'.
+
+A region is captured by flipping all 'O's into 'X's in that surrounded region.
+
+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
+Explanation:
+
+Surrounded regions shouldn’t be on the border, which means that any 'O' on the border of the board are not flipped to 'X'. Any 'O' that is not on the border and it is not connected to an 'O' on the border will be flipped to 'X'. Two cells are connected if they are adjacent cells connected horizontally or vertically.
+
+
+
+
+
+
+
+
+
+class Solution {
+public:
+
+    void dfs(vector<vector<char> >& board, int x, int y){
+        if(x>=0 && x< board.size() && y>=0 && y< board[0].size() && board[x][y]=='O'){
+            board[x][y]='P';
+            dfs(board,x-1,y);
+            dfs(board,x+1,y);
+            dfs(board,x,y-1);
+            dfs(board,x,y+1);
+        } else return;
+    }
+
+    void solve(vector<vector<char>>& board) {
+        int rows=board.size();
+        if(rows==0) return;
+        int cols=board[0].size();
+        if(cols==0) return;
+
+        for(int i=0; i<cols;i++){
+            if(board[0][i]=='O')    // first row
+                dfs(board, 0, i);
+            if(board[rows-1][i]=='O')    // last row
+                dfs(board, rows-1, i);
+        }
+
+        for(int i=0; i<rows;i++){
+            if(board[i][0]=='O')    // first col
+                dfs(board, i, 0);
+            if(board[i][cols-1]=='O')    // last col
+                dfs(board, i, cols-1);
+        }
+
+        for(int i=0;i<rows;i++){
+            for(int j=0;j<cols;j++){
+                if(board[i][j]=='O') board[i][j]='X';
+                if(board[i][j]=='P') board[i][j]='O';
+
+            }
+        }
+    }
+};

competitive programming/leetcode/207. Course Schedule.cpp

@@ -0,0 +1,68 @@
+There are a total of numCourses courses you have to take, labeled from 0 to numCourses-1.
+
+Some courses may have prerequisites, for example to take course 0 you have to first take course 1, which is expressed as a pair: [0,1]
+
+Given the total number of courses and a list of prerequisite pairs, is it possible for you to finish all courses?
+
+
+
+Example 1:
+
+Input: numCourses = 2, prerequisites = [[1,0]]
+Output: true
+Explanation: There are a total of 2 courses to take.
+             To take course 1 you should have finished course 0. So it is possible.
+Example 2:
+
+Input: numCourses = 2, prerequisites = [[1,0],[0,1]]
+Output: false
+Explanation: There are a total of 2 courses to take.
+             To take course 1 you should have finished course 0, and to take course 0 you should
+             also have finished course 1. So it is impossible.
+
+
+Constraints:
+
+The input prerequisites is a graph represented by a list of edges, not adjacency matrices. Read more about how a graph is represented.
+You may assume that there are no duplicate edges in the input prerequisites.
+1 <= numCourses <= 10^5
+
+
+
+
+
+class Solution {
+public:
+
+    bool dfs(vector<int> adj[], vector<bool> &vis, vector<bool> &rec, int node){
+    if(vis[node]==false){
+        vis[node]=true;
+        rec[node]=true;
+        for(auto it: adj[node]){
+            if(!vis[it] && dfs(adj, vis, rec, it)) return true;
+            else if(rec[it]==true) return true;
+        }
+    }
+    rec[node]=false;
+    return false;
+}
+
+    bool canFinish(int numCourses, vector<vector<int>>& preReq) {
+        vector<int> adj[numCourses];
+        for(int i=0;i<preReq.size();i++){
+            adj[preReq[i][0]].push_back(preReq[i][1]);
+        }
+        vector<bool> vis(numCourses, false);
+        vector<bool> rec(numCourses, false);
+        for(int i=0;i<numCourses;i++){
+            if(!vis[i])
+                if(dfs(adj, vis, rec, i)){
+                    // cycle exists, coureses cannot be taken
+                    return false;
+                }
+        }
+        // cycle doesn't exist, courses can be taken
+        return true;
+
+    }
+};

competitive programming/leetcode/767. Reorganize String.cpp

@@ -0,0 +1,62 @@
+Given a string S, check if the letters can be rearranged so that two characters that are adjacent to each other are not the same.
+
+If possible, output any possible result.  If not possible, return the empty string.
+
+Example 1:
+
+Input: S = "aab"
+Output: "aba"
+Example 2:
+
+Input: S = "aaab"
+Output: ""
+Note:
+
+S will consist of lowercase letters and have length in range [1, 500].
+
+
+
+
+
+
+
+class Solution {
+public:
+    string reorganizeString(string s) {
+        vector<int> freq(26, 0);
+        int n=s.length();
+        for(int i=0;i<n;i++){
+            freq[s[i]-'a']++;
+        }
+
+        priority_queue<pair<int, char> > pq;   // max heap
+        for(int i=0;i<26;i++){
+            if(freq[i]>0){
+                pq.push({freq[i], char(i+97)});
+            }
+        }
+
+
+        string res;
+        while(pq.size()>1){
+            pair<int, char> cur, next;
+            cur=pq.top();
+            pq.pop();
+            next=pq.top();
+            pq.pop();
+            res+=cur.second;
+            res+=next.second;
+            cur.first-=1;
+            next.first-=1;
+            if(cur.first>0) pq.push(cur);
+            if(next.first>0) pq.push(next);
+        }
+
+        if(!pq.empty()){
+            pair<int , char> last= pq.top();
+            if(last.first>1) return "";
+            else res+=last.second;
+        }
+        return res;
+    }
+};