LeetCode Questions

1-two-sum/README.md

@@ -0,0 +1,41 @@
+<h2><a href="https://leetcode.com/problems/two-sum">Two Sum</a></h2> <img src='https://img.shields.io/badge/Difficulty-Easy-brightgreen' alt='Difficulty: Easy' /><hr><p>Given an array of integers <code>nums</code>&nbsp;and an integer <code>target</code>, return <em>indices of the two numbers such that they add up to <code>target</code></em>.</p>
+
+<p>You may assume that each input would have <strong><em>exactly</em> one solution</strong>, and you may not use the <em>same</em> element twice.</p>
+
+<p>You can return the answer in any order.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [2,7,11,15], target = 9
+<strong>Output:</strong> [0,1]
+<strong>Explanation:</strong> Because nums[0] + nums[1] == 9, we return [0, 1].
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [3,2,4], target = 6
+<strong>Output:</strong> [1,2]
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [3,3], target = 6
+<strong>Output:</strong> [0,1]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>2 &lt;= nums.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>-10<sup>9</sup> &lt;= nums[i] &lt;= 10<sup>9</sup></code></li>
+	<li><code>-10<sup>9</sup> &lt;= target &lt;= 10<sup>9</sup></code></li>
+	<li><strong>Only one valid answer exists.</strong></li>
+</ul>
+
+<p>&nbsp;</p>
+<strong>Follow-up:&nbsp;</strong>Can you come up with an algorithm that is less than <code>O(n<sup>2</sup>)</code><font face="monospace">&nbsp;</font>time complexity?

1-two-sum/two-sum.cpp

@@ -0,0 +1,19 @@
+class Solution {
+public:
+    vector<int> twoSum(vector<int>& nums, int target) {
+        map<int,int> m;
+
+        int i=0;
+
+        while(i<nums.size()){
+            int ele = nums[i];
+            if(m.find(target-ele)!=m.end()){
+                return {i,m[target-ele]};
+            }else{
+                m[ele] = i;
+            }
+            i++;
+        }
+        return {-1,-1};
+    }
+};

1036-rotting-oranges/README.md

@@ -0,0 +1,45 @@
+<h2><a href="https://leetcode.com/problems/rotting-oranges">Rotting Oranges</a></h2> <img src='https://img.shields.io/badge/Difficulty-Medium-orange' alt='Difficulty: Medium' /><hr><p>You are given an <code>m x n</code> <code>grid</code> where each cell can have one of three values:</p>
+
+<ul>
+	<li><code>0</code> representing an empty cell,</li>
+	<li><code>1</code> representing a fresh orange, or</li>
+	<li><code>2</code> representing a rotten orange.</li>
+</ul>
+
+<p>Every minute, any fresh orange that is <strong>4-directionally adjacent</strong> to a rotten orange becomes rotten.</p>
+
+<p>Return <em>the minimum number of minutes that must elapse until no cell has a fresh orange</em>. If <em>this is impossible, return</em> <code>-1</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2019/02/16/oranges.png" style="width: 650px; height: 137px;" />
+<pre>
+<strong>Input:</strong> grid = [[2,1,1],[1,1,0],[0,1,1]]
+<strong>Output:</strong> 4
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> grid = [[2,1,1],[0,1,1],[1,0,1]]
+<strong>Output:</strong> -1
+<strong>Explanation:</strong> The orange in the bottom left corner (row 2, column 0) is never rotten, because rotting only happens 4-directionally.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> grid = [[0,2]]
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> Since there are already no fresh oranges at minute 0, the answer is just 0.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>m == grid.length</code></li>
+	<li><code>n == grid[i].length</code></li>
+	<li><code>1 &lt;= m, n &lt;= 10</code></li>
+	<li><code>grid[i][j]</code> is <code>0</code>, <code>1</code>, or <code>2</code>.</li>
+</ul>

1036-rotting-oranges/rotting-oranges.cpp

@@ -0,0 +1,51 @@
+class Solution {
+public:
+    int bfs(vector<vector<int>>& grid,vector<vector<int>>& vis,queue<pair<pair<int,int>,int>> &q){
+        int m = grid.size();
+        int n = grid[0].size();
+
+        int minute = 0;
+        while(!q.empty()){
+            int row = q.front().first.first;
+            int col = q.front().first.second;
+            int t = q.front().second;
+            minute = max(minute,t);
+            q.pop();
+            vector<pair<int,int>> dir{{0,-1},{0,1},{-1,0},{1,0}};
+            for(auto [dr,dc]:dir){
+                int nbrRow = row + dr;
+                int nbrCol = col + dc;
+                if(nbrRow>=0 && nbrCol>=0 && nbrRow<m && nbrCol<n &&
+                 vis[nbrRow][nbrCol]!=2 && grid[nbrRow][nbrCol]==1){
+                    q.push({{nbrRow,nbrCol},t+1});
+                    vis[nbrRow][nbrCol] = 2;
+                 }
+            }
+        }
+        return minute;
+    }
+    int orangesRotting(vector<vector<int>>& grid) {
+        int m = grid.size();
+        int n = grid[0].size();
+        vector<vector<int>> vis(m,vector<int>(n,0));
+        queue<pair<pair<int,int>,int>> q;
+        for(int i=0;i<m;i++){
+            for(int j = 0;j<n;j++){
+                if(grid[i][j]==2){
+                    q.push({{i,j},0});
+                    vis[i][j] = 2;
+                }
+            }
+        }
+        int time = 0;
+        time = bfs(grid,vis,q);
+        for(int i=0;i<m;i++){
+            for(int j = 0;j<n;j++){
+                if(vis[i][j]!=2 && grid[i][j]==1){
+                    return -1;
+                }
+            }
+        }
+        return time;
+    }
+};

1073-number-of-enclaves/README.md

@@ -0,0 +1,32 @@
+<h2><a href="https://leetcode.com/problems/number-of-enclaves">Number of Enclaves</a></h2> <img src='https://img.shields.io/badge/Difficulty-Medium-orange' alt='Difficulty: Medium' /><hr><p>You are given an <code>m x n</code> binary matrix <code>grid</code>, where <code>0</code> represents a sea cell and <code>1</code> represents a land cell.</p>
+
+<p>A <strong>move</strong> consists of walking from one land cell to another adjacent (<strong>4-directionally</strong>) land cell or walking off the boundary of the <code>grid</code>.</p>
+
+<p>Return <em>the number of land cells in</em> <code>grid</code> <em>for which we cannot walk off the boundary of the grid in any number of <strong>moves</strong></em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/02/18/enclaves1.jpg" style="width: 333px; height: 333px;" />
+<pre>
+<strong>Input:</strong> grid = [[0,0,0,0],[1,0,1,0],[0,1,1,0],[0,0,0,0]]
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> There are three 1s that are enclosed by 0s, and one 1 that is not enclosed because its on the boundary.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/02/18/enclaves2.jpg" style="width: 333px; height: 333px;" />
+<pre>
+<strong>Input:</strong> grid = [[0,1,1,0],[0,0,1,0],[0,0,1,0],[0,0,0,0]]
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> All 1s are either on the boundary or can reach the boundary.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>m == grid.length</code></li>
+	<li><code>n == grid[i].length</code></li>
+	<li><code>1 &lt;= m, n &lt;= 500</code></li>
+	<li><code>grid[i][j]</code> is either <code>0</code> or <code>1</code>.</li>
+</ul>

1073-number-of-enclaves/number-of-enclaves.cpp

@@ -0,0 +1,49 @@
+class Solution {
+public:
+    void dfs(vector<vector<int>>& grid,vector<vector<int>>& vis,int row,int col){
+        int m = grid.size();
+        int n = grid[0].size();
+        vis[row][col] = 1;
+        vector<pair<int,int>> dir{{0,1},{0,-1},{1,0},{-1,0}};
+        for(auto [dr,dc]:dir){
+                int nbrRow = row +dr;
+                int nbrCol = col + dc;
+                if(nbrRow>=0 && nbrCol>=0 && nbrRow<m && nbrCol<n &&
+                 !vis[nbrRow][nbrCol] && grid[nbrRow][nbrCol]!=0){
+                    dfs(grid,vis,nbrRow,nbrCol);
+                 }
+            }
+    }
+    int numEnclaves(vector<vector<int>>& grid) {
+        int m = grid.size();
+        int n = grid[0].size();
+        vector<vector<int>> vis(m,vector<int> (n,0));
+
+        for(int j = 0 ; j<n;j++) { 
+            if(!vis[0][j] && grid[0][j] == 1) {
+                dfs(grid, vis, 0, j); 
+            }
+            if(!vis[m-1][j] && grid[m-1][j] == 1) {
+                dfs(grid, vis,m-1,j); 
+            }
+        }
+        for(int i = 0;i<m;i++) {
+            if(!vis[i][0] && grid[i][0] == 1) {
+                dfs(grid,vis,i,0); 
+            }
+
+            if(!vis[i][n-1] && grid[i][n-1] == 1) {
+                dfs(grid,vis,i,n-1); 
+            }
+        }
+        int count = 0;
+         for(int i = 0;i<m;i++){
+            for(int j = 0;j<n;j++){
+                if(grid[i][j]==1 && vis[i][j]==0){
+                    count++;
+                }
+            }
+        }
+        return count;
+    }
+};

11-container-with-most-water/README.md

@@ -0,0 +1,32 @@
+<h2><a href="https://leetcode.com/problems/container-with-most-water">Container With Most Water</a></h2> <img src='https://img.shields.io/badge/Difficulty-Medium-orange' alt='Difficulty: Medium' /><hr><p>You are given an integer array <code>height</code> of length <code>n</code>. There are <code>n</code> vertical lines drawn such that the two endpoints of the <code>i<sup>th</sup></code> line are <code>(i, 0)</code> and <code>(i, height[i])</code>.</p>
+
+<p>Find two lines that together with the x-axis form a container, such that the container contains the most water.</p>
+
+<p>Return <em>the maximum amount of water a container can store</em>.</p>
+
+<p><strong>Notice</strong> that you may not slant the container.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://s3-lc-upload.s3.amazonaws.com/uploads/2018/07/17/question_11.jpg" style="width: 600px; height: 287px;" />
+<pre>
+<strong>Input:</strong> height = [1,8,6,2,5,4,8,3,7]
+<strong>Output:</strong> 49
+<strong>Explanation:</strong> The above vertical lines are represented by array [1,8,6,2,5,4,8,3,7]. In this case, the max area of water (blue section) the container can contain is 49.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> height = [1,1]
+<strong>Output:</strong> 1
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == height.length</code></li>
+	<li><code>2 &lt;= n &lt;= 10<sup>5</sup></code></li>
+	<li><code>0 &lt;= height[i] &lt;= 10<sup>4</sup></code></li>
+</ul>

11-container-with-most-water/container-with-most-water.cpp

@@ -0,0 +1,16 @@
+class Solution {
+public:
+    int maxArea(vector<int>& nums) {
+        int n = nums.size();
+        int j = n-1;
+        int i = 0;
+        int maxArea = INT_MIN;
+        while(i<j){
+            int area = min(nums[i],nums[j]) * (j-i);
+            maxArea = max(area,maxArea);
+            if(nums[i]<nums[j]) i++;
+            else j--;
+        }
+        return maxArea;
+    }
+};

1171-shortest-path-in-binary-matrix/README.md

@@ -0,0 +1,42 @@
+<h2><a href="https://leetcode.com/problems/shortest-path-in-binary-matrix">Shortest Path in Binary Matrix</a></h2> <img src='https://img.shields.io/badge/Difficulty-Medium-orange' alt='Difficulty: Medium' /><hr><p>Given an <code>n x n</code> binary matrix <code>grid</code>, return <em>the length of the shortest <strong>clear path</strong> in the matrix</em>. If there is no clear path, return <code>-1</code>.</p>
+
+<p>A <strong>clear path</strong> in a binary matrix is a path from the <strong>top-left</strong> cell (i.e., <code>(0, 0)</code>) to the <strong>bottom-right</strong> cell (i.e., <code>(n - 1, n - 1)</code>) such that:</p>
+
+<ul>
+	<li>All the visited cells of the path are <code>0</code>.</li>
+	<li>All the adjacent cells of the path are <strong>8-directionally</strong> connected (i.e., they are different and they share an edge or a corner).</li>
+</ul>
+
+<p>The <strong>length of a clear path</strong> is the number of visited cells of this path.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/02/18/example1_1.png" style="width: 500px; height: 234px;" />
+<pre>
+<strong>Input:</strong> grid = [[0,1],[1,0]]
+<strong>Output:</strong> 2
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/02/18/example2_1.png" style="height: 216px; width: 500px;" />
+<pre>
+<strong>Input:</strong> grid = [[0,0,0],[1,1,0],[1,1,0]]
+<strong>Output:</strong> 4
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> grid = [[1,0,0],[1,1,0],[1,1,0]]
+<strong>Output:</strong> -1
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == grid.length</code></li>
+	<li><code>n == grid[i].length</code></li>
+	<li><code>1 &lt;= n &lt;= 100</code></li>
+	<li><code>grid[i][j] is 0 or 1</code></li>
+</ul>

1171-shortest-path-in-binary-matrix/shortest-path-in-binary-matrix.cpp

@@ -0,0 +1,34 @@
+class Solution {
+public:
+    int shortestPathBinaryMatrix(vector<vector<int>>& grid) {
+        int n = grid.size();
+        vector<vector<int>> dist(n,vector<int> (n,1e9));
+        queue< pair<int,pair<int,int>> > q;
+
+        vector<int> dx{-1, -1, -1,  0, 0, 1, 1, 1};
+        vector<int> dy{-1,  0,  1, -1, 1, -1, 0, 1};
+
+        if(grid[0][0]!=1){
+            q.push({1,{0,0}});
+            dist[0][0] = 1;
+        }
+        while(!q.empty()){
+            int cost = q.front().first;
+            int row = q.front().second.first;
+            int col = q.front().second.second;
+            q.pop();
+            for(int i=0;i<8;i++){
+                int nurow = dx[i] + row;
+                int nucol = dy[i] + col;
+
+                if(nurow >= 0 && nurow < n && nucol >= 0 && nucol < n &&
+                    (cost+1<dist[nurow][nucol]) && grid[nurow][nucol]==0){
+                        dist[nurow][nucol] = cost + 1;
+                        q.push({cost+1,{nurow,nucol}});
+                    }
+            }
+        }
+        if(dist[n-1][n-1]==1e9) return -1;
+        return dist[n-1][n-1];
+    }
+};