new soln

Author: shreymehul

100.IsSameTree.cs

@@ -40,4 +40,17 @@ public bool IsSameTree(TreeNode p, TreeNode q) {
             return false;
         return IsSameTree(p.left,q.left) && IsSameTree(p.right,q.right);
     }
+}
+
+public class Solution {
+    public bool IsSameTree(TreeNode p, TreeNode q) {
+        if(p == null && q == null)
+            return true;
+        else if(p == null || q == null)
+            return false;
+        else if(p.val == q.val)
+            return IsSameTree(p.left,q.left) && IsSameTree(p.right,q.right);
+        else
+            return false;
+    }
 }

1061.SmallestEquivalentString.cs

@@ -0,0 +1,56 @@
+// 1061. Lexicographically Smallest Equivalent String
+// You are given two strings of the same length s1 and s2 and a string baseStr.
+// We say s1[i] and s2[i] are equivalent characters.
+// For example, if s1 = "abc" and s2 = "cde", then we have 'a' == 'c', 'b' == 'd', and 'c' == 'e'.
+// Equivalent characters follow the usual rules of any equivalence relation:
+// Reflexivity: 'a' == 'a'.
+// Symmetry: 'a' == 'b' implies 'b' == 'a'.
+// Transitivity: 'a' == 'b' and 'b' == 'c' implies 'a' == 'c'.
+// For example, given the equivalency information from s1 = "abc" and s2 = "cde", "acd" and "aab" are equivalent strings of baseStr = "eed", and "aab" is the lexicographically smallest equivalent string of baseStr.
+// Return the lexicographically smallest equivalent string of baseStr by using the equivalency information from s1 and s2.
+// Example 1:
+// Input: s1 = "parker", s2 = "morris", baseStr = "parser"
+// Output: "makkek"
+// Explanation: Based on the equivalency information in s1 and s2, we can group their characters as [m,p], [a,o], [k,r,s], [e,i].
+// The characters in each group are equivalent and sorted in lexicographical order.
+// So the answer is "makkek".
+// Example 2:
+// Input: s1 = "hello", s2 = "world", baseStr = "hold"
+// Output: "hdld"
+// Explanation: Based on the equivalency information in s1 and s2, we can group their characters as [h,w], [d,e,o], [l,r].
+// So only the second letter 'o' in baseStr is changed to 'd', the answer is "hdld".
+// Example 3:
+// Input: s1 = "leetcode", s2 = "programs", baseStr = "sourcecode"
+// Output: "aauaaaaada"
+// Explanation: We group the equivalent characters in s1 and s2 as [a,o,e,r,s,c], [l,p], [g,t] and [d,m], thus all letters in baseStr except 'u' and 'd' are transformed to 'a', the answer is "aauaaaaada".
+// Constraints:
+// 1 <= s1.length, s2.length, baseStr <= 1000
+// s1.length == s2.length
+// s1, s2, and baseStr consist of lowercase English letters.
+
+public class Solution {
+    int[] parent = new int[26];
+    public string SmallestEquivalentString(string s1, string s2, string baseStr) {
+        Array.Fill(parent,-1);
+        for(int i = 0; i < s1.Length; i++)
+            Union(s1[i] - 'a', s2[i] - 'a');
+        string res = "";
+        for(int i = 0; i < baseStr.Length; i++){
+            char ch = (char)('a' + Find(baseStr[i] - 'a'));
+            res += ch;
+        }
+        return res;
+    }
+    int Find(int ch){
+        if(parent[ch] == -1)
+            return ch;
+        return parent[ch] = Find(parent[ch]);
+    }
+    void Union(int ch1, int ch2){
+        int p1 = Find(ch1);
+        int p2 = Find(ch2);
+
+        if(p1 != p2)
+            parent[Math.Max(p1,p2)] = Math.Min(p1,p2); 
+    }
+}

144.PreorderTraversal.cs

@@ -37,4 +37,20 @@ public void Preorder(TreeNode root, IList<int> result){
         if(root.right != null)
             Preorder(root.right, result);
     }
+}
+
+
+public class Solution {
+    public IList<int> PreorderTraversal(TreeNode root) {
+        IList<int> res = new List<int>();
+        Preorder(root, res);
+        return res;
+    }
+    public void Preorder(TreeNode root, IList<int> res){
+        if(root == null)
+            return;
+        res.Add(root.val);
+        Preorder(root.left, res);
+        Preorder(root.right, res);
+    }
 }

1443.MinTime.cs

@@ -0,0 +1,47 @@
+// 1443. Minimum Time to Collect All Apples in a Tree
+// Given an undirected tree consisting of n vertices numbered from 0 to n-1, which has some apples in their vertices. You spend 1 second to walk over one edge of the tree. Return the minimum time in seconds you have to spend to collect all apples in the tree, starting at vertex 0 and coming back to this vertex.
+// The edges of the undirected tree are given in the array edges, where edges[i] = [ai, bi] means that exists an edge connecting the vertices ai and bi. Additionally, there is a boolean array hasApple, where hasApple[i] = true means that vertex i has an apple; otherwise, it does not have any apple.
+// Example 1:
+// Input: n = 7, edges = [[0,1],[0,2],[1,4],[1,5],[2,3],[2,6]], hasApple = [false,false,true,false,true,true,false]
+// Output: 8 
+// Explanation: The figure above represents the given tree where red vertices have an apple. One optimal path to collect all apples is shown by the green arrows.  
+// Example 2:
+// Input: n = 7, edges = [[0,1],[0,2],[1,4],[1,5],[2,3],[2,6]], hasApple = [false,false,true,false,false,true,false]
+// Output: 6
+// Explanation: The figure above represents the given tree where red vertices have an apple. One optimal path to collect all apples is shown by the green arrows.  
+// Example 3:
+// Input: n = 7, edges = [[0,1],[0,2],[1,4],[1,5],[2,3],[2,6]], hasApple = [false,false,false,false,false,false,false]
+// Output: 0
+// Constraints:
+// 1 <= n <= 105
+// edges.length == n - 1
+// edges[i].length == 2
+// 0 <= ai < bi <= n - 1
+// hasApple.length == n
+
+public class Solution {
+    public int MinTime(int n, int[][] edges, IList<bool> hasApple) {
+        List<List<int>> adj = new List<List<int>>();
+        for(int i = 0; i < n; i++){
+            adj.Add(new List<int>());
+        }
+        foreach(var edge in edges){
+            adj[edge[0]].Add(edge[1]);
+            adj[edge[1]].Add(edge[0]);
+        }
+        return MinTimeToCollectApples(0, adj, hasApple, 0);
+    }
+    // Helper function
+    int MinTimeToCollectApples(int index, List<List<int>> adj, 
+    IList<bool> hasApple, int parent){
+        int total = 0;
+        foreach(var nbr in adj[index]){
+            if (nbr == parent)
+             continue;
+            total += MinTimeToCollectApples(nbr, adj, hasApple, index);
+        }
+        if( index != 0 && (hasApple[index] || total > 0))
+          total += 2;
+        return total;
+    }
+}

1519.CountSubTrees.cs

@@ -0,0 +1,61 @@
+// 1519. Number of Nodes in the Sub-Tree With the Same Label
+// You are given a tree (i.e. a connected, undirected graph that has no cycles) consisting of n nodes numbered from 0 to n - 1 and exactly n - 1 edges. The root of the tree is the node 0, and each node of the tree has a label which is a lower-case character given in the string labels (i.e. The node with the number i has the label labels[i]).
+// The edges array is given on the form edges[i] = [ai, bi], which means there is an edge between nodes ai and bi in the tree.
+// Return an array of size n where ans[i] is the number of nodes in the subtree of the ith node which have the same label as node i.
+// A subtree of a tree T is the tree consisting of a node in T and all of its descendant nodes.
+// Example 1:
+// Input: n = 7, edges = [[0,1],[0,2],[1,4],[1,5],[2,3],[2,6]], labels = "abaedcd"
+// Output: [2,1,1,1,1,1,1]
+// Explanation: Node 0 has label 'a' and its sub-tree has node 2 with label 'a' as well, thus the answer is 2. Notice that any node is part of its sub-tree.
+// Node 1 has a label 'b'. The sub-tree of node 1 contains nodes 1,4 and 5, as nodes 4 and 5 have different labels than node 1, the answer is just 1 (the node itself).
+// Example 2:
+// Input: n = 4, edges = [[0,1],[1,2],[0,3]], labels = "bbbb"
+// Output: [4,2,1,1]
+// Explanation: The sub-tree of node 2 contains only node 2, so the answer is 1.
+// The sub-tree of node 3 contains only node 3, so the answer is 1.
+// The sub-tree of node 1 contains nodes 1 and 2, both have label 'b', thus the answer is 2.
+// The sub-tree of node 0 contains nodes 0, 1, 2 and 3, all with label 'b', thus the answer is 4.
+// Example 3:
+// Input: n = 5, edges = [[0,1],[0,2],[1,3],[0,4]], labels = "aabab"
+// Output: [3,2,1,1,1]
+// Constraints:
+// 1 <= n <= 105
+// edges.length == n - 1
+// edges[i].length == 2
+// 0 <= ai, bi < n
+// ai != bi
+// labels.length == n
+// labels is consisting of only of lowercase English letters.
+
+public class Solution {
+    public int[] CountSubTrees(int n, int[][] edges, string labels) {
+       int[] res = new int[n];
+        List<List<int>> adj = new List<List<int>>();
+        for (int i = 0; i < n; i++)
+            adj.Add(new List<int>());
+        foreach (var edge in edges)
+        {
+            adj[edge[0]].Add(edge[1]);
+            adj[edge[1]].Add(edge[0]);
+        }
+        DFS(0, -1, adj, labels, res);
+        return res;
+    }
+    int[] DFS(int idx, int parent, List<List<int>> adj,
+                string labels, int[] res)
+    {
+        int[] freq = new int[26];
+        freq[labels[idx] - 'a'] = 1;
+        foreach (var nbr in adj[idx])
+        {
+            if (nbr != parent)
+            {
+                int[] temp = DFS(nbr, idx, adj, labels, res);
+                for(int i = 0; i < 26; i++)
+                    freq[i] += temp[i];
+            }
+        }
+        res[idx] = freq[labels[idx] - 'a'];
+        return freq;
+    }
+}

2246.LongestPath.cs

@@ -0,0 +1,50 @@
+// 2246. Longest Path With Different Adjacent Characters
+// You are given a tree (i.e. a connected, undirected graph that has no cycles) rooted at node 0 consisting of n nodes numbered from 0 to n - 1. The tree is represented by a 0-indexed array parent of size n, where parent[i] is the parent of node i. Since node 0 is the root, parent[0] == -1.
+// You are also given a string s of length n, where s[i] is the character assigned to node i.
+// Return the length of the longest path in the tree such that no pair of adjacent nodes on the path have the same character assigned to them.
+// Example 1:
+// Input: parent = [-1,0,0,1,1,2], s = "abacbe"
+// Output: 3
+// Explanation: The longest path where each two adjacent nodes have different characters in the tree is the path: 0 -> 1 -> 3. The length of this path is 3, so 3 is returned.
+// It can be proven that there is no longer path that satisfies the conditions. 
+// Example 2:
+// Input: parent = [-1,0,0,0], s = "aabc"
+// Output: 3
+// Explanation: The longest path where each two adjacent nodes have different characters is the path: 2 -> 0 -> 3. The length of this path is 3, so 3 is returned.
+// Constraints:
+// n == parent.length == s.length
+// 1 <= n <= 105
+// 0 <= parent[i] <= n - 1 for all i >= 1
+// parent[0] == -1
+// parent represents a valid tree.
+// s consists of only lowercase English letters.
+
+public class Solution {
+    int max = 0;
+    public int LongestPath(int[] parent, string s) {
+        List<List<int>> adj = new();
+        for(int i = 0; i < parent.Length; i++)
+            adj.Add(new List<int>());
+        for(int i = 1; i < parent.Length; i++){
+            adj[parent[i]].Add(i);
+        }
+        Traverse(s,adj,0);
+        return max;
+    }
+    int Traverse(string s, List<List<int>> adj, int idx){
+        int ch1Len = 0, ch2Len = 0;
+        foreach(var nbr in adj[idx]){
+            int len = Traverse(s,adj,nbr);
+            max = Math.Max(len,max);
+            if(s[idx] == s[nbr]) continue;
+            if(len > ch1Len){
+                ch2Len = ch1Len;
+                ch1Len = len;
+            }
+            else
+                ch2Len = Math.Max(len,ch2Len);
+        }
+        max = Math.Max(max, 1+ch1Len+ch2Len);
+       return 1 + ch1Len;
+    }
+}