graphs problems

Author: prajwal714

Leetcode/Arrays/contains-duplicate-iii.cpp

@@ -0,0 +1,35 @@
+class Solution {
+public:
+    bool containsNearbyAlmostDuplicate(vector<int>& nums, int k, int t) {
+        
+        
+        int n=nums.size();
+        multiset<long> s;
+        if(n<=0 || k<=0)
+            return false;
+        
+        int i;
+        for(i=0;i<n;i++)
+        {
+            long num=(long)nums[i];
+            if(i>k)
+            {
+                s.erase(nums[i-k-1]);
+            }
+            
+            auto pos=s.lower_bound(num-t);
+            
+            if(pos!=s.end() && (long)*pos-num<=t)
+                return true;
+            
+            s.insert(nums[i]);
+            
+        }
+        
+        return false;
+        
+        
+    }
+};
+
+//complexity: nlogk  logk complexity for set operations, n times for each element in array

Leetcode/Arrays/contains-duplicate.cpp

@@ -0,0 +1,29 @@
+class Solution {
+public:
+    bool containsNearbyDuplicate(vector<int>& nums, int k) {
+        
+        
+        unordered_map<int,int> mp;
+        
+        int n=nums.size();
+        
+        if(n<=0 || k<=0)
+            return false;
+        
+        
+        for(int i=0;i<n;i++)
+        {
+            if(i>k)
+            {
+                mp[nums[i-k-1]]--;
+            }
+            
+            mp[nums[i]]++;
+            
+            if(mp[nums[i]]>1)
+                return true;
+        }
+        
+        return false;
+    }
+};

Leetcode/Graphs/flood-fill.cpp

@@ -0,0 +1,37 @@
+class Solution {
+public:
+    vector<vector<int>> floodFill(vector<vector<int>>& image, int sr, int sc, int newColor) {
+        
+        int m=image.size(), n=image[0].size();
+        
+        queue<pair<int,int>> q;
+        q.push({sr,sc});
+        int color=image[sr][sc];
+        image[sr][sc]=newColor;
+        vector<vector<int>> dir={{0,1}, {1,0}, {0,-1}, {-1,0}};
+        vector<vector<bool>> visited(m, vector<bool>(n, false));
+        
+        visited[sr][sc]=true;
+        
+        while(!q.empty())
+        {
+            pair<int,int> temp=q.front();
+            q.pop();
+            
+            for(auto d: dir)
+            {
+                int x=temp.first+d[0];
+                int y=temp.second+d[1];
+                
+                if(x>=0 && x<m && y>=0 && y<n && image[x][y]==color && visited[x][y]==false)
+                {
+                    image[x][y]=newColor;
+                    q.push({x,y});
+                    visited[x][y]=true;
+                }
+            }
+        }
+        
+        return image;
+    }
+};

Leetcode/Graphs/max-area-of-islands.cpp

@@ -0,0 +1,37 @@
+class Solution {
+public:
+    int maxAreaOfIsland(vector<vector<int>>& grid) {
+        
+        int ans=INT_MIN;
+        
+        int m=grid.size(), n=grid[0].size();
+        
+        for(int i=0;i<m;i++)
+        {
+            for(int j=0;j<n;j++)
+            {
+                if(grid[i][j]==1)
+                    ans=max(ans, dfs(grid, i,j));
+            }
+        }
+        if(ans==INT_MIN)
+            return 0;
+        else
+        return ans;
+        
+        
+    }
+    
+    int dfs(vector<vector<int>> &grid, int x, int y)
+    {
+        if(x<0 || y<0 || x>=grid.size() || y>=grid[0].size() || grid[x][y]==0 || grid[x][y]==-1)
+            return 0;
+        
+        grid[x][y]=-1;
+        
+        return 1+ dfs(grid,x+1,y)+dfs(grid, x, y+1)+ dfs(grid, x-1, y) + dfs(grid, x,y-1);
+        
+        
+        
+    }
+};

Leetcode/Graphs/number-of-islands.cpp

@@ -0,0 +1,35 @@
+class Solution {
+public:
+    int numIslands(vector<vector<char>>& grid) {
+        
+        int res=0;
+        
+        for(int i=0;i<grid.size();i++)
+        {
+            for(int j=0;j<grid[0].size();j++)
+            {
+                if(grid[i][j]=='1')
+                {
+                    dfs(grid,i,j);
+                    res++;
+                }
+            }
+        }
+        
+        return res;
+        
+    }
+    
+    void dfs(vector<vector<char>> &grid, int x, int y)
+    {
+        if(x<0 || x>=grid.size()|| y<0 || y>=grid[0].size() || grid[x][y]=='0')
+            return;
+        
+        grid[x][y]='0';
+        
+        dfs(grid, x+1,y);
+        dfs(grid, x,y+1);
+        dfs(grid,x,y-1);
+        dfs(grid, x-1,y);
+    }
+};

Leetcode/Graphs/perimeter-of-island.cpp

@@ -0,0 +1,32 @@
+class Solution {
+public:
+    int islandPerimeter(vector<vector<int>>& grid) {
+        
+        int m=grid.size();
+        int n=grid[0].size();
+        
+        int res=0;
+        
+        for(int i=0;i<m;i++)
+        {
+            for(int j=0;j<n;j++)
+            {
+                if(grid[i][j]==1)
+                {
+                  if(i==0 || grid[i-1][j]==0)
+                      res++;
+                    if(i==m-1 || grid[i+1][j]==0)
+                        res++;
+                    if(j==0 || grid[i][j-1]==0)
+                        res++;
+                    
+                    if(j==n-1 || grid[i][j+1]==0)
+                        res++;
+                }
+            }
+        }
+        
+        return res;
+        
+    }
+};

Leetcode/backtracking/largest-time-for-given-digits.cpp

@@ -0,0 +1,74 @@
+class Solution {
+public:
+    int res;
+    bool valid=false;
+    string largestTimeFromDigits(vector<int>& arr) {
+        
+        unordered_map<int,bool> used;
+        vector<int> temp;
+        res=0;
+        backtrack(arr, temp, used);
+        
+        string ans="";
+        
+        if(!valid)
+            return "";
+        
+        int hr=res/100;
+        int min=res%100;
+        
+            if(hr==0)
+                ans+="00";
+            else if(hr/10==0)
+                ans+="0"+to_string(hr);
+            else
+                ans+=to_string(hr);
+        
+            ans+=":";
+        
+            if(min==0)
+                ans+="00";
+            else if(min/10==0)
+                ans+="0"+to_string(min);
+            else
+                ans+=to_string(min);
+        
+        return ans;
+                
+                
+            
+        
+    }
+    
+    void backtrack(vector<int> arr, vector<int> temp, unordered_map<int,bool> used)
+    {
+        if(temp.size()==arr.size())
+        {
+            int hr=temp[0]*10+temp[1];
+            int min=temp[2]*10+temp[3];
+            
+            if(hr<24 && min < 60)
+            {
+                res=max(res,hr*100+min);
+                valid=true;
+                return;
+            }
+        }
+            
+            for(int i=0;i<arr.size();i++)
+            {
+                if(used[i] || (i>0 && arr[i]==arr[i-1] && !used[i-1]))
+                    continue;
+                
+                temp.push_back(arr[i]);
+                used[i]=true;
+                backtrack(arr, temp, used);
+                used[i]=false;
+                temp.pop_back();
+            }
+            
+            return;
+                
+        }
+    
+};