GRAPH, LinkList, Tree, Array

Author: shreymehul

100.IsSameTree.cs

@@ -0,0 +1,43 @@
+// 100. Same Tree
+
+// Given the roots of two binary trees p and q, write a function to check if they are the same or not.
+
+// Two binary trees are considered the same if they are structurally identical, and the nodes have the same value.
+
+ 
+
+// Example 1:
+
+
+// Input: p = [1,2,3], q = [1,2,3]
+// Output: true
+// Example 2:
+
+
+// Input: p = [1,2], q = [1,null,2]
+// Output: false
+
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public int val;
+ *     public TreeNode left;
+ *     public TreeNode right;
+ *     public TreeNode(int val=0, TreeNode left=null, TreeNode right=null) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+public class Solution {
+    public bool IsSameTree(TreeNode p, TreeNode q) {
+        if(p==null && q==null)
+            return true;
+        if(p==null || q==null)
+            return false;
+        if(p.val != q.val)
+            return false;
+        return IsSameTree(p.left,q.left) && IsSameTree(p.right,q.right);
+    }
+}

121.MaxProfit.cs

@@ -0,0 +1,37 @@
+// 121. Best Time to Buy and Sell Stock
+
+// You are given an array prices where prices[i] is the price of a given stock on the ith day.
+
+// You want to maximize your profit by choosing a single day to buy one stock and choosing a different day in the future to sell that stock.
+
+// Return the maximum profit you can achieve from this transaction. If you cannot achieve any profit, return 0.
+
+ 
+
+// Example 1:
+
+// Input: prices = [7,1,5,3,6,4]
+// Output: 5
+// Explanation: Buy on day 2 (price = 1) and sell on day 5 (price = 6), profit = 6-1 = 5.
+// Note that buying on day 2 and selling on day 1 is not allowed because you must buy before you sell.
+// Example 2:
+
+// Input: prices = [7,6,4,3,1]
+// Output: 0
+// Explanation: In this case, no transactions are done and the max profit = 0.
+
+public class Solution {
+    public int MaxProfit(int[] prices) {
+        int[] max = new int[prices.Length];
+        max[prices.Length-1] = prices[prices.Length-1];
+        for(int i=prices.Length-2;i>=0;i--){
+            max[i] = Math.Max(max[i+1],prices[i]);
+        }
+        int profit = 0;
+        for(int i=0;i<prices.Length-1;i++){
+            if(prices[i]<max[i])
+                profit = Math.Max(profit,max[i]-prices[i]);
+        }
+        return profit;
+    }
+}

122.MaxProfit.cs

@@ -0,0 +1,39 @@
+// 122. Best Time to Buy and Sell Stock II
+
+// You are given an integer array prices where prices[i] is the price of a given stock on the ith day.
+
+// On each day, you may decide to buy and/or sell the stock. You can only hold at most one share of the stock at any time. However, you can buy it then immediately sell it on the same day.
+
+// Find and return the maximum profit you can achieve.
+
+ 
+
+// Example 1:
+
+// Input: prices = [7,1,5,3,6,4]
+// Output: 7
+// Explanation: Buy on day 2 (price = 1) and sell on day 3 (price = 5), profit = 5-1 = 4.
+// Then buy on day 4 (price = 3) and sell on day 5 (price = 6), profit = 6-3 = 3.
+// Total profit is 4 + 3 = 7.
+// Example 2:
+
+// Input: prices = [1,2,3,4,5]
+// Output: 4
+// Explanation: Buy on day 1 (price = 1) and sell on day 5 (price = 5), profit = 5-1 = 4.
+// Total profit is 4.
+// Example 3:
+
+// Input: prices = [7,6,4,3,1]
+// Output: 0
+// Explanation: There is no way to make a positive profit, so we never buy the stock to achieve the maximum profit of 0.
+
+public class Solution {
+    public int MaxProfit(int[] prices) {
+        int profit = 0;
+        for(int i=0;i<prices.Length-1;i++){
+            if(prices[i]<prices[i+1])
+                profit += prices[i+1] - prices[i];
+        }
+        return profit;
+    }
+}

1319.MakeConnected.cs

@@ -0,0 +1,68 @@
+// 1319. Number of Operations to Make Network Connected
+
+// There are n computers numbered from 0 to n - 1 connected by ethernet cables connections forming a network where connections[i] = [ai, bi] represents a connection between computers ai and bi. Any computer can reach any other computer directly or indirectly through the network.
+
+// You are given an initial computer network connections. You can extract certain cables between two directly connected computers, and place them between any pair of disconnected computers to make them directly connected.
+
+// Return the minimum number of times you need to do this in order to make all the computers connected. If it is not possible, return -1.
+
+ 
+
+// Example 1:
+
+
+// Input: n = 4, connections = [[0,1],[0,2],[1,2]]
+// Output: 1
+// Explanation: Remove cable between computer 1 and 2 and place between computers 1 and 3.
+// Example 2:
+
+
+// Input: n = 6, connections = [[0,1],[0,2],[0,3],[1,2],[1,3]]
+// Output: 2
+// Example 3:
+
+// Input: n = 6, connections = [[0,1],[0,2],[0,3],[1,2]]
+// Output: -1
+// Explanation: There are not enough cables.
+
+
+public class Solution {
+    public bool[] Visited = new bool[100000];
+    public int MakeConnected(int n, int[][] connections)
+    {
+        if (connections.Length - (n - 1) < 0)
+            return - 1;
+        List<int>[] edges = new List<int>[n];
+        for (int i = 0; i < n; i++)
+        {
+            edges[i] = new List<int>();
+        }
+        for (int i = 0; i < connections.Length; i++)
+        {
+            edges[connections[i][0]].Add(connections[i][1]);
+            edges[connections[i][1]].Add(connections[i][0]);
+        }
+        int noOfConected = 0;
+        for (int i = 0; i < n; i++)
+        {
+            if (!Visited[i])
+            {
+                connectedComponent(edges, i);
+                noOfConected++;
+            }
+        }
+        return noOfConected - 1;
+    }
+
+    public void connectedComponent(List<int>[] edges, int src)
+    {
+        if (Visited[src])
+            return;
+        Visited[src] = true;
+        foreach (var edge in edges[src])
+        {
+            if (!Visited[edge])
+                connectedComponent(edges, edge);
+        }
+    }
+}

1971.ValidPath.cs

@@ -0,0 +1,59 @@
+// 1971. Find if Path Exists in Graph
+
+// There is a bi-directional graph with n vertices, where each vertex is labeled from 0 to n - 1 (inclusive). The edges in the graph are represented as a 2D integer array edges, where each edges[i] = [ui, vi] denotes a bi-directional edge between vertex ui and vertex vi. Every vertex pair is connected by at most one edge, and no vertex has an edge to itself.
+
+// You want to determine if there is a valid path that exists from vertex source to vertex destination.
+
+// Given edges and the integers n, source, and destination, return true if there is a valid path from source to destination, or false otherwise.
+
+ 
+
+// Example 1:
+
+
+// Input: n = 3, edges = [[0,1],[1,2],[2,0]], source = 0, destination = 2
+// Output: true
+// Explanation: There are two paths from vertex 0 to vertex 2:
+// - 0 → 1 → 2
+// - 0 → 2
+// Example 2:
+
+
+// Input: n = 6, edges = [[0,1],[0,2],[3,5],[5,4],[4,3]], source = 0, destination = 5
+// Output: false
+// Explanation: There is no path from vertex 0 to vertex 5.
+
+public class Solution {
+    public Dictionary<int, bool> visited = new Dictionary<int, bool>();
+    public bool ValidPath(int n, int[][] edges, int source, int destination)
+    {
+        List<int>[] Path = new List<int>[n];
+        for (int i = 0; i < n; i++)
+        {
+            Path[i] = new List<int>();
+            visited.Add(i, false);
+        }
+        foreach (var item in edges)
+        {
+            Path[item[0]].Add(item[1]);
+            Path[item[1]].Add(item[0]);
+        }
+        
+        return HasPath(Path, source, destination);
+    }
+    public bool HasPath(List<int>[] Path,
+                          int source, int destination)
+    {
+        if (source == destination)
+            return true;
+        if (visited[source])
+            return false;
+        visited[source] = true;
+        foreach (var item in Path[source])
+        {
+            if (HasPath(Path, item, destination))
+                return true;
+        }
+        return false;
+    }
+}

200.NumIslands.cs

@@ -0,0 +1,61 @@
+// 200. Number of Islands
+
+// Given an m x n 2D binary grid grid which represents a map of '1's (land) and '0's (water), return the number of islands.
+
+// An island is surrounded by water and is formed by connecting adjacent lands horizontally or vertically. You may assume all four edges of the grid are all surrounded by water.
+
+ 
+
+// Example 1:
+
+// Input: grid = [
+//   ["1","1","1","1","0"],
+//   ["1","1","0","1","0"],
+//   ["1","1","0","0","0"],
+//   ["0","0","0","0","0"]
+// ]
+// Output: 1
+// Example 2:
+
+// Input: grid = [
+//   ["1","1","0","0","0"],
+//   ["1","1","0","0","0"],
+//   ["0","0","1","0","0"],
+//   ["0","0","0","1","1"]
+// ]
+// Output: 3
+
+public class Solution {
+    bool[,] visited = new bool[300,300];
+    public int NumIslands(char[][] grid)
+    {
+        
+        int count=0;
+        for(int i = 0; i < grid.Length; i++)
+        {
+            for(int j = 0; j < grid[i].Length; j++)
+            {
+                if (grid[i][j] == '1' && !visited[i,j])
+                {
+                    FindConectedPath(grid, i, j);
+                    count++;
+                }
+            }
+        }
+        return count;
+    }
+    public void FindConectedPath(char[][] grid, int i,int j)
+    {
+        if (i<0 ||j<0 || i>=grid.Length|| j >= grid[0].Length ||
+            grid[i][j] == '0' || visited[i,j])
+        {
+            return;
+        }
+        
+        visited[i,j] = true;
+        FindConectedPath(grid, i + 1, j);
+        FindConectedPath(grid, i -1, j);
+        FindConectedPath(grid, i , j-1);
+        FindConectedPath(grid, i, j+1);
+    }
+}

239.MaxSlidingWindow.cs

@@ -4,7 +4,7 @@
 
 // Return the max sliding window.
 
-//Deque with List
+//Deque implementation via List
 public class Solution {
     public int[] MaxSlidingWindow(int[] nums, int k) {
         int[] res = new int[nums.Length - k + 1];

3.LengthOfLongestSubstring.cs

@@ -0,0 +1,57 @@
+// 3. Longest Substring Without Repeating Characters
+// Medium
+
+// 28833
+
+// 1229
+
+// Add to List
+
+// Share
+// Given a string s, find the length of the longest substring without repeating characters.
+
+ 
+
+// Example 1:
+
+// Input: s = "abcabcbb"
+// Output: 3
+// Explanation: The answer is "abc", with the length of 3.
+// Example 2:
+
+// Input: s = "bbbbb"
+// Output: 1
+// Explanation: The answer is "b", with the length of 1.
+// Example 3:
+
+// Input: s = "pwwkew"
+// Output: 3
+// Explanation: The answer is "wke", with the length of 3.
+// Notice that the answer must be a substring, "pwke" is a subsequence and not a substring.
+
+public class Solution {
+    public int LengthOfLongestSubstring(string s) {
+        if (string.IsNullOrEmpty(s) )
+			return 0;
+        int[] freq = new int[95];
+        int left,right;
+        left = 0;
+        right =0;
+        int max = 0;
+        while(right<s.Length){
+            if(freq[s[right] - ' '] == 0){
+                freq[s[right] - ' '] ++;
+            }
+            else{
+                while(left < right && freq[s[right] - ' '] !=0){
+                    freq[s[left] - ' '] --;
+                    left++;
+                }
+                freq[s[right] - ' '] ++;
+            }
+            right++;
+            max = Math.Max(max, (right-left));
+        }
+        return max;
+    }
+}