Add files via upload

Author: ankurmoh

4_sum_2.cpp

@@ -0,0 +1,30 @@
+class Solution {
+public:
+    int fourSumCount(vector<int>& A, vector<int>& B, vector<int>& C, vector<int>& D) {
+       unordered_map<int,int>mp1;
+
+       int i,j,sz1,sz2,sz3,sz4,ans=0,sum;
+        sz1=A.size();
+        sz2=B.size();
+        sz3=C.size();
+        sz4=D.size();
+        if((sz1==0) || (sz2==0) || (sz3==0) || (sz4==0))
+            return 0;
+        for(i=0;i<sz1;i++)
+        {
+            for(j=0;j<sz2;j++)
+            {
+                mp1[A[i]+B[j]]++;
+            }
+        }
+        for(i=0;i<sz3;i++)
+        {
+            for(j=0;j<sz4;j++)
+            {
+                sum=-(C[i]+D[j]);
+                ans=ans+mp1[sum];
+            }
+        }
+        return ans;
+    }
+};

Add2Nos.cpp

@@ -0,0 +1,49 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
+        stack<int>s1;
+        stack<int>s2;
+        ListNode* x=l1;
+        int sum,carry=0;
+        while(x)
+        {
+            s1.push(x->val);
+            x=x->next;
+        }
+        x=l2;
+        while(x)
+        {
+            s2.push(x->val);
+            x=x->next;
+        }
+        ListNode* val=NULL;
+        while(!s1.empty() || !s2.empty() || carry!=0)
+        {
+            sum=0;
+            if(!s1.empty())
+            {
+                sum=s1.top();
+                s1.pop();
+            }
+            if(!s2.empty())
+            {
+                sum=sum+s2.top();
+                s2.pop();
+            }
+            sum=sum+carry;
+            ListNode* dummy=new ListNode(sum%10);
+            dummy->next=val;
+            val=dummy;
+            carry=sum/10;
+        }
+        return val;
+    }
+};

Add_1_linkedList.cpp

@@ -0,0 +1,42 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode* plusOne(ListNode* head) {
+        if(head==NULL)
+            return head;
+        ListNode* node=head;
+        ListNode* start=NULL;
+        while(node)
+        {
+            if(node->val<9)
+                start=node;
+            node=node->next;
+        }
+        if(start)
+        {
+            start->val=start->val+1;
+            node=start->next;
+        }
+        else if(!start)
+        {
+            ListNode* n = new ListNode(1);
+            n->next=head;
+            head=n;
+            node=head->next;
+            //head=n;
+        }
+        while(node)
+        {
+            node->val=0;
+            node=node->next;
+        }
+        return head;
+    }
+};

Array+ListRotation.cpp

@@ -0,0 +1,43 @@
+class Solution {
+public:
+    void rotate(vector<int>& nums, int k) {
+        vector<int>copy=nums;
+        int i,sz=nums.size();
+        for(i=0;i<sz;i++)
+            copy[(i+k)%sz]=nums[i];
+        nums=copy;
+    }
+};
+
+void rotate(vector<int>& nums, int k) {
+    int sz=nums.size();
+    k=k%sz;
+    reverse(nums.begin(),nums.end()-k);
+    reverse(nums.end()-k,nums.end());
+    reverse(nums.begin(),nums.end());
+}
+
+class Solution {
+public:
+    ListNode* rotateRight(ListNode* head, int k)
+    {
+        if((head==NULL) || (head->next==NULL))
+            return head;
+        if(k==0)
+            return head;
+        int len=1,con,i;
+        ListNode *x=head , *h1;
+        while(x->next!=NULL)
+        {
+            x=x->next;
+            len++;
+        }
+        x->next=head;
+        k=k%len;
+        for(i=0;i<len-k;i++)
+            x=x->next;
+        h1=x->next;
+        x->next=NULL;
+        return h1;
+    }
+};

BinaryTreeTilt.cpp

@@ -0,0 +1,28 @@
+/**
+ * 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:
+    int sumSubTree(TreeNode* root)
+    {
+        if (root == NULL)
+            return 0;
+        return root->val + sumSubTree(root->left) + sumSubTree(root->right);
+    }
+    int findTilt(TreeNode* root)
+    {
+        if (root == NULL)
+            return 0;
+        int curVal = 0;
+        curVal = abs(sumSubTree(root->left) - sumSubTree(root->right));
+        return curVal + findTilt(root->left) + findTilt(root->right);
+    }
+};

CampusBikes.cpp

@@ -0,0 +1,33 @@
+class Solution {
+public:
+    vector<int> assignBikes(vector<vector<int>>& workers, vector<vector<int>>& bikes) {
+        priority_queue< pair<int,pair<int,int>>, vector< pair<int,pair<int,int>> >, greater< pair< int, pair<int,int> > > >pq;
+        int i,wor = workers.size(), bik = bikes.size(),j,x,y,dist;
+        vector<int>visited(wor,-1);
+        for(i=0;i<wor;i++)
+        {
+            x = workers[i][0];
+            y = workers[i][1];
+            for(j=0;j<bik;j++)
+            {
+                dist = abs(x-bikes[j][0]) + abs(y-bikes[j][1]);
+                pq.push(make_pair(dist,make_pair(i,j)));
+            }
+        }
+
+        unordered_set<int>assigned;
+        while(!pq.empty())
+        {
+            pair<int, pair<int,int> >fron = pq.top();
+            pq.pop();
+            if((visited[fron.second.first]==-1) && (assigned.count(fron.second.second)==0))
+            {
+                visited[fron.second.first]=fron.second.second;
+                assigned.insert(fron.second.second);
+            }
+            if(assigned.size()==wor)
+                break;
+        }
+        return visited;
+    }
+};

ClosedIslands.cpp

@@ -0,0 +1,90 @@
+class Solution {
+public:
+    vector<vector<int>> dir = {{-1,0},{1,0},{0,1},{0,-1}};
+    void dfs(vector<vector<int>>& grid, vector<vector<int>>& visited, int x,int y)
+    {
+         if((x<0)||(x>=grid.size())||(y<0)||(y>=grid[0].size())||(visited[x][y]==1)||(grid[x][y]!=0))
+                    return;
+        visited[x][y]=1;
+        int i;
+        for(i=0;i<4;i++)
+        {
+            dfs(grid,visited,x+dir[i][0],y+dir[i][1]);
+        }
+    }
+    void bfs(vector<vector<int>>& grid, vector<vector<int>>& visited, queue< pair<int,int> >& q )
+    {
+        int i,x,y,newx,newy;
+        while(!q.empty())
+        {
+            x=q.front().first;
+            y=q.front().second;
+            q.pop();
+            //cout<<x<<
+            for(i=0;i<4;i++)
+            {
+                newx=x+dir[i][0];
+                newy=y+dir[i][1];
+                if((newx<0)||(newx>=grid.size())||(newy<0)||(newy>=grid[0].size())||(visited[newx][newy]==1)||(grid[newx][newy]!=0))
+                    continue;
+                visited[newx][newy]=1;
+                q.push(make_pair(newx,newy));
+                grid[newx][newy]=1;
+            }
+        }
+    }
+    int closedIsland(vector<vector<int>>& grid) {
+        int i,j,m=grid.size(),n,res=0,con=0;
+        if(m==0)
+            return res;
+         n=grid[0].size();
+         vector<vector<int>>visited(m,vector<int>(n,0));
+         queue< pair<int,int> >q;
+        for(i=0;i<m;i++)
+        {
+            if(grid[i][0]==0)
+            {
+                visited[i][0]=1;
+                q.push(make_pair(i,0));
+                grid[i][0]=1;
+            }
+            if(grid[i][n-1]==0)
+            {
+                visited[i][n-1]=1;
+                q.push(make_pair(i,n-1));
+                grid[i][n-1]=1;
+            }
+        }
+        for(i=0;i<n;i++)
+        {
+            if((grid[0][i]==0) && (!visited[0][i]))
+            {
+                visited[0][i]=1;
+                q.push(make_pair(0,i));
+                grid[0][i]=1;
+            }
+            if((grid[m-1][i]==0) && (!visited[m-1][i]))
+            {
+                visited[m-1][i]=1;
+                q.push(make_pair(m-1,i));
+                grid[m-1][i]=1;
+            }
+        }
+        bfs(grid,visited,q);
+        for(i=0;i<m;i++)
+            for(j=0;j<n;j++)
+                visited[i][j]=0;
+        for(i=0;i<m;i++)
+        {
+            for(j=0;j<n;j++)
+            {
+                if((grid[i][j]==0) && (!visited[i][j]))
+                {
+                    con++;
+                    dfs(grid,visited,i,j);
+                }
+            }
+        }
+        return con;
+    }
+};

ConsecutivegroupsofsizeW.cpp

@@ -0,0 +1,68 @@
+class Solution {
+public:
+    bool isNStraightHand(vector<int>& hand, int W) {
+        priority_queue<int, vector<int>, greater<int>>pq;
+        int i,sz=hand.size(),con=0,fron;
+        if(sz%W!=0)
+            return false;
+        for(i=0;i<sz;i++)
+            pq.push(hand[i]);
+        vector<int>straight;
+        while(!pq.empty())
+        {
+            vector<int>temp;
+            vector<int>dump;
+            while(!pq.empty() && temp.size()<W)
+            {
+                fron = pq.top();
+                pq.pop();
+                if((temp.size()==0) || (fron == temp.back() + 1))
+                    temp.push_back(fron);
+                else
+                    dump.push_back(fron);
+            }
+            for(i=0;i<temp.size();i++)
+                straight.push_back(temp[i]);
+            if(temp.size()<W)
+                return false;
+            else
+            {
+                for(i=0;i<dump.size();i++)
+                    pq.push(dump[i]);
+            }
+        }
+        for(i=0;i<straight.size();i++)
+            cout<<straight[i]<<" ";
+        return true;
+    }
+};
+
+
+class Solution {
+public:
+    bool isPossibleDivide(vector<int>& nums, int k) {
+     int i,j,sz=nums.size(),fron;
+        if(sz%k!=0)
+            return false;
+        map<int,int>mp;
+        for(i=0;i<sz;i++)
+            mp[nums[i]]++;
+        while(!mp.empty())
+        {
+            auto it= mp.begin();
+            fron = it->first;
+            for(i=fron;i<fron+k;i++)
+            {
+                if(mp.find(i)==mp.end())
+                    return false;
+                else
+                {
+                    mp[i]--;
+                    if(mp[i]==0)
+                        mp.erase(i);
+                }
+            }
+        }
+        return true;
+    }
+};