Chayandas07 patch 1 20

01 February Distinct Coloring

@@ -0,0 +1,21 @@
+class Solution{   
+public:
+    long long int distinctColoring(int N, int r[], int g[], int b[]){
+        // code here
+         long long int dpr[N];
+        long long int dpg[N];
+        long long int dpb[N];
+        dpr[0]=r[0];
+        dpg[0]=g[0];
+        dpb[0]=b[0];
+
+        for(int i=1;i<N;i++){
+            dpr[i]=min(dpg[i-1],dpb[i-1])+r[i];
+            dpg[i]=min(dpr[i-1],dpb[i-1])+g[i];
+            dpb[i]=min(dpr[i-1],dpg[i-1])+b[i];
+        }
+        long long int mini=min(dpr[N-1],min(dpg[N-1],dpb[N-1]));
+        return mini;
+
+    }
+};

01 January Count even length(T)

@@ -0,0 +1,43 @@
+class Solution{
+
+public:
+
+int inv(int n, int m, int mod=1000000007){
+
+if(m==0) return 1;
+
+if(m&1) return (n*1ll*inv(n, m-1))%mod;
+
+int tmp=inv(n, m/2);
+
+return (tmp*1ll*tmp)%mod;
+
+}
+
+int compute_value(int n)
+
+{
+
+// Code here
+
+int m = 1000000007;
+
+long long fact2N=1, factN;
+
+for(int i=1; i<=2*n; i++){
+
+fact2N *= i;
+
+fact2N %= m;
+
+if(i==n)factN=fact2N;
+
+}
+
+factN = (factN*factN)%m;
+
+return (fact2N * 1ll * inv(factN, m-2))%m;
+
+}
+
+};

02 February Largest Sum Cycle

@@ -0,0 +1,55 @@
+class Solution
+{
+  public:
+  vector<vector<int>> v;
+  vector<int> vis,par,tmp;
+  long long dfs(int node,int p=-1){
+    vis[node]=1;
+    par[node]=p;
+    tmp.push_back(node);
+    for(auto i:v[node]){
+      if(vis[i]==0){
+        long long z=dfs(i,node);
+        if(z!=-1){
+          return z;
+        }
+      }
+      else if(vis[i]==1){
+        long long sum=i;
+        while(node!=i){
+          sum+=node;
+          node=par[node];
+        }
+        if(node==i)
+          return sum;
+        return -1;
+      }
+    }
+    return -1;
+  }
+  long long largestSumCycle(int N, vector<int> Edge)
+  {
+    long long ans=-1;
+    vis=vector<int>(N);
+    v=vector<vector<int>>(N);
+    par=vector<int>(N);
+
+    for(int i=0;i<N;i++){
+      if(Edge[i]!=-1){
+        v[i].push_back(Edge[i]);
+      }
+    }
+
+    for(int i=0;i<N;i++){
+      if(!vis[i]){
+        ans=max(ans,dfs(i));
+        for(auto j:tmp){
+          vis[j]=2;
+        }
+        tmp.clear();
+      }
+    }
+
+    return ans;
+  }
+};

02 January Maximum Value

@@ -0,0 +1,43 @@
+class Solution {
+  public:
+    void traverse(Node* node, vector<int>& ans, int level ){
+        if(node == NULL )
+            return;
+        if(ans.size()>=level){
+            ans[level-1] = max(node->data, ans[level-1]);
+        }
+        else{
+            ans.push_back(node->data);
+        }
+        traverse(node->left, ans, level+1);
+        traverse(node->right, ans, level+1);
+    }
+    // Takes O(n) Time complexity and O(H) space complexity
+    void dfs(Node* node, vector<int>&ans){
+        if (node==NULL)
+            return;
+        stack<pair<Node*, int>> s;
+        s.push({node, 1});
+        while(!s.empty()){
+            auto it = s.top();
+            s.pop();
+            if(ans.size()>=it.second){
+                ans[it.second-1] = max(it.first->data, ans[it.second-1]);
+            }
+            else{
+                ans.push_back(it.first->data);
+            }
+            if(it.first->left != NULL )
+                s.push({it.first->left, it.second+1});
+            if(it.first->right != NULL )
+                s.push({it.first->right, it.second+1});
+        }
+    }
+    vector<int> maximumValue(Node* node) {
+        vector<int> ans;
+        // int level = 1;
+        // traverse(node, ans, level);
+        dfs(node, ans);
+        return ans;
+    }
+};

03 December Aggressive Cows

@@ -0,0 +1,28 @@
+class Solution {
+public:
+
+    int solve(int n, int k, vector<int> &stalls) {
+           sort(stalls.begin(),stalls.end());
+        int l=0,r=stalls[n-1]-stalls[0];
+        int ans=0;
+        while(l<=r){
+            int mid=(l+r)/2;
+            int cow=1;
+            int last=stalls[0];
+            for(int i=1;i<n;i++){
+                if(stalls[i]-last>=mid){
+                    cow++;
+                    last=stalls[i];
+                }
+            }
+            if(cow>=k){
+                ans=mid;
+                l=mid+1;
+            }
+            else{
+                r=mid-1;
+            }
+        }
+        return ans;
+    }
+};

03 February Last cell in a Matrix

@@ -0,0 +1,24 @@
+class Solution{
+    public:
+    pair<int,int> endPoints(vector<vector<int>> matrix, int R, int C){
+        //code here
+        int x=0;
+        int y=0;
+        int dir =0;
+        int dirx[] = {0,1,0,-1};
+        int diry[] = {1,0,-1,0};
+        while(x>=0 && y>=0 && x<R && y< C){
+            if(matrix[x][y]){
+                dir = (dir+1)%4;
+                matrix[x][y] =0;
+
+            }
+            x+=dirx[dir];
+            y += diry[dir];
+        }
+        pair<int,int> ans;
+        ans.first = x-dirx[dir];
+        ans.second = y-diry[dir];
+        return ans;
+    }
+};

03 January Minimize number of Students to be removed

@@ -0,0 +1,41 @@
+class Solution {
+  public:
+    // Helper function to find LIS
+    int LongestIncreasingSubsequenceLength(vector<int>& v)  
+    {  
+        if (v.size() == 0)  
+            return 0;  
+
+        vector<int> tail(v.size(), 0);  
+        int length = 1; // always points empty slot in tail  
+
+        tail[0] = v[0];  
+
+        for (int i = 1; i < v.size(); i++) {  
+
+                // Do binary search for the element in  
+                // the range from begin to begin + length 
+            auto b = tail.begin(), e = tail.begin() + length; 
+            auto it = lower_bound(b, e, v[i]);  
+
+            // If not present change the tail element to v[i]  
+            if (it == tail.begin() + length) 
+                tail[length++] = v[i];  
+            else   
+                *it = v[i];  
+        }  
+
+        return length;  
+    }  
+
+    int removeStudents(int H[], int N) {
+
+        vector<int> arr;
+        for(int i=0; i<N; i++)
+            arr.push_back(H[i]);
+
+        int ans = N - LongestIncreasingSubsequenceLength(arr);
+
+        return ans;
+    }
+};

04 February Max Sum without Adjacents

@@ -0,0 +1,19 @@
+class Solution{
+public: 
+ // calculate the maximum sum with out adjacent
+ int findMaxSum(int *arr, int n) {
+     if(n==1) return arr[0];
+     int a=arr[0];
+
+     int b=max(arr[0],arr[1]);
+     int curr=0;
+     for(int i=2;i<n;i++)
+     {
+         curr=max(b,arr[i]+a);
+         a=b;
+         b=curr;
+
+     }
+     return max(a,b);
+ }
+};

04 January Maximum Profit By Choosing A Subset Of Intervals

@@ -0,0 +1,30 @@
+class Solution {
+  public:
+  vector<vector<int>>job;
+    int p=0;
+    int solve(int i,vector<int>&dp,vector<int>&startTime){
+        if(i>=job.size())return 0;
+        if(dp[i]!=-1)return dp[i];
+        int next=lower_bound(startTime.begin(),startTime.end(),job[i][1])-startTime.begin();
+        return dp[i]=max(solve(i+1,dp,startTime),job[i][2]+solve(next,dp,startTime));
+    }
+    int jobSched(vector<int>& startTime, vector<int>& endTime, vector<int>& profit) {
+        for(int i=0;i<startTime.size();i++){
+            job.push_back({startTime[i],endTime[i],profit[i]});
+        }
+         sort(job.begin(),job.end());
+        sort(startTime.begin(),startTime.end());
+        vector<int>dp(job.size(),-1);
+        return solve(0,dp,startTime);
+    }
+    int maximum_profit(int n, vector<vector<int>> &in) {
+        // Write your code here.
+        vector<int>s,e,p;
+        for(int i=0;i<n;i++){
+            s.push_back(in[i][0]);
+           e.push_back(in[i][1]);
+            p.push_back(in[i][2]);
+        }
+        return jobSched(s,e,p);
+    }
+};

05 December Shortest Path by Removing K walls

@@ -0,0 +1,35 @@
+class Solution {
+  public:
+    int shotestPath(vector<vector<int>> mat, int n, int m, int k) {
+        vector<vector<int>> lives(n, vector<int> (m, -1));
+        queue<vector<int>> q;
+        // q-> row, col, k, dist
+        q.push({0, 0, k, 0});
+
+        int dx[] = {-1, 0, 1, 0, -1}; 
+        while(!q.empty()) {
+            vector<int> temp = q.front();
+            q.pop();
+
+            int row = temp[0];
+            int col = temp[1];
+            int clives = temp[2];
+            int dist = temp[3];
+
+            if(row == n-1 && col == m-1) return dist;
+
+            if(mat[row][col] == 1) clives--;
+
+            for(int i=0; i<4; i++) {
+                int nrow = row + dx[i];
+                int ncol = col + dx[i+1];
+
+                if(nrow >= 0 && nrow < n && ncol >= 0 && ncol < m && lives[nrow][ncol] < clives) {
+                    q.push({nrow, ncol, clives, dist+1});
+                    lives[nrow][ncol] = clives;
+                }
+            }
+        }
+        return -1;
+    }
+};

05 January Find the longest string

@@ -0,0 +1,39 @@
+class Solution
+{
+public:
+    string longestString(vector<string> &words)
+    {
+         sort(words.begin(),words.end(),[&](string &a,string &b){
+        return a.size()<b.size();
+    });
+    string ans="";
+        set<string>s(words.begin(),words.end());
+        for(int i=0;i<words.size();i++)
+        {
+            string a=words[i];
+            string word="";
+            int c=0;
+            for(int j=0;j<a.length();j++)
+            {
+                word+=a[j];
+                if(s.find(word)==s.end())
+                break;
+                else
+                c++;
+            }
+            if(c==a.length())
+            {
+                if(ans.length()!=c)
+                {
+                    ans=a;
+                }
+                else if(ans.length()==c)
+                {
+                    if(ans>a)
+                    ans=a;
+                }
+            }
+        }
+        return ans;
+    }
+};