🚀 16-Apr-2022

Author: sureshmangs

competitive programming/codeforces/1656A - Good Pairs.cpp

@@ -0,0 +1,82 @@
+You are given an array a1,a2,…,an of positive integers. A good pair is a pair of indices (i,j) with 1=i,j=n such that, for all 1=k=n, the following equality holds:
+
+|ai-ak|+|ak-aj|=|ai-aj|,
+where |x| denotes the absolute value of x.
+
+Find a good pair. Note that i can be equal to j.
+
+Input
+The input consists of multiple test cases. The first line contains a single integer t (1=t=1000) — the number of test cases. Description of the test cases follows.
+
+The first line of each test case contains an integer n (1=n=105) — the length of the array.
+
+The second line of each test case contains n integers a1,a2,…,an (1=ai=109) where ai is the i-th element of the array.
+
+The sum of n for all test cases is at most 2·105.
+
+Output
+For each test case, print a single line with two space-separated indices i and j which form a good pair of the array. 
+The case i=j is allowed. It can be shown that such a pair always exists. If there are multiple good pairs, print any of them.
+
+Example
+inputCopy
+3
+3
+5 2 7
+5
+1 4 2 2 3
+1
+2
+outputCopy
+2 3
+1 2
+1 1
+Note
+In the first case, for i=2 and j=3 the equality holds true for all k:
+
+k=1: |a2-a1|+|a1-a3|=|2-5|+|5-7|=5=|2-7|=|a2-a3|,
+k=2: |a2-a2|+|a2-a3|=|2-2|+|2-7|=5=|2-7|=|a2-a3|,
+k=3: |a2-a3|+|a3-a3|=|2-7|+|7-7|=5=|2-7|=|a2-a3|.
+
+
+
+
+
+
+#include<bits/stdc++.h>
+using namespace std;
+ 
+void solve() {
+	int n;
+	cin >> n;
+	
+	vector <int> v(n);
+	for (auto &x: v) cin >> x;
+	
+	int minv = INT_MAX, maxv = INT_MIN, mini = 0, maxi = 0;
+	
+	for (int i = 0; i < n; i++) {
+		if (v[i]  < minv) {
+			minv = v[i];
+			mini = i;
+		}
+		if (v[i] > maxv) {
+			maxv = v[i];
+			maxi = i;
+		}
+	}
+	
+	cout << mini + 1 << " " << maxi + 1 << endl;
+}
+ 
+int main(){
+    ios_base::sync_with_stdio(false);
+	cin.tie(NULL);
+	
+	int t = 1;
+	cin >> t;
+	
+	while (t--)  solve();
+	
+    return 0;
+}

competitive programming/leetcode/11. Container With Most Water.cpp

@@ -0,0 +1,50 @@
+You are given an integer array height of length n. 
+There are n vertical lines drawn such that the two endpoints of the ith line are (i, 0) and (i, height[i]).
+
+Find two lines that together with the x-axis form a container, such that the container contains the most water.
+
+Return the maximum amount of water a container can store.
+
+Notice that you may not slant the container.
+
+ 
+
+Example 1:
+
+
+Input: height = [1,8,6,2,5,4,8,3,7]
+Output: 49
+Explanation: 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.
+Example 2:
+
+Input: height = [1,1]
+Output: 1
+ 
+
+Constraints:
+
+n == height.length
+2 <= n <= 105
+0 <= height[i] <= 104
+
+
+
+
+
+
+
+class Solution {
+public:
+    int maxArea(vector<int>& height) {
+        int res = 0, start = 0, end = height.size() - 1;
+        
+        while (start <= end) {
+            int water = min(height[start], height[end]) * (end - start);
+            res = max(res, water);
+            if (height[start] <= height[end]) start++;
+            else end--;
+        }
+        return res;
+    }
+};

competitive programming/leetcode/1557. Minimum Number of Vertices to Reach All Nodes.cpp

@@ -1,6 +1,8 @@
-Given a directed acyclic graph, with n vertices numbered from 0 to n-1, and an array edges where edges[i] = [fromi, toi] represents a directed edge from node fromi to node toi.
+Given a directed acyclic graph, with n vertices numbered from 0 to n-1, 
+and an array edges where edges[i] = [fromi, toi] represents a directed edge from node fromi to node toi.
 
-Find the smallest set of vertices from which all nodes in the graph are reachable. It's guaranteed that a unique solution exists.
+Find the smallest set of vertices from which all nodes in the graph are reachable. 
+It's guaranteed that a unique solution exists.
 
 Notice that you can return the vertices in any order.
 
@@ -12,14 +14,16 @@ Example 1:
 
 Input: n = 6, edges = [[0,1],[0,2],[2,5],[3,4],[4,2]]
 Output: [0,3]
-Explanation: It's not possible to reach all the nodes from a single vertex. From 0 we can reach [0,1,2,5]. From 3 we can reach [3,4,2,5]. So we output [0,3].
+Explanation: It's not possible to reach all the nodes from a single vertex. 
+From 0 we can reach [0,1,2,5]. From 3 we can reach [3,4,2,5]. So we output [0,3].
 Example 2:
 
 
 
 Input: n = 5, edges = [[0,1],[2,1],[3,1],[1,4],[2,4]]
 Output: [0,2,3]
-Explanation: Notice that vertices 0, 3 and 2 are not reachable from any other node, so we must include them. Also any of these vertices can reach nodes 1 and 4.
+Explanation: Notice that vertices 0, 3 and 2 are not reachable from any other node, 
+so we must include them. Also any of these vertices can reach nodes 1 and 4.
 
 
 Constraints:
@@ -41,15 +45,23 @@ All pairs (fromi, toi) are distinct.
 class Solution {
 public:
     vector<int> findSmallestSetOfVertices(int n, vector<vector<int>>& edges) {
-        vector<bool> incEdge(n, false);
-        vector<int> res;
-        for(auto &it: edges){
-            incEdge[it[1]]=true;
+        vector <bool> incEdge(n, false);
+        vector <int> res;
+        for (auto &it: edges) {
+            incEdge[it[1]] = true;
         }
-        for(int i=0;i<n;i++){
-            if(incEdge[i]==false) res.push_back(i);
+        
+        for (int i = 0; i < n; i++) {
+            if (incEdge[i] == false) res.push_back(i);
         }
 
         return res;
     }
 };
+
+
+
+
+// A node that does not have any incoming edge can only be reached by itself.
+// Any other node with incoming edges can be reached from some other node.
+// We only have to count the number of nodes with zero incoming edges.

competitive programming/leetcode/1791. Find Center of Star Graph.cpp

@@ -0,0 +1,79 @@
+There is an undirected star graph consisting of n nodes labeled from 1 to n.
+A star graph is a graph where there is one center node and exactly n - 1 edges 
+that connect the center node with every other node.
+
+You are given a 2D integer array edges where each edges[i] = [ui, vi] 
+indicates that there is an edge between the nodes ui and vi. 
+Return the center of the given star graph.
+
+ 
+
+Example 1:
+
+
+Input: edges = [[1,2],[2,3],[4,2]]
+Output: 2
+Explanation: As shown in the figure above, node 2 is connected to every other node, so 2 is the center.
+Example 2:
+
+Input: edges = [[1,2],[5,1],[1,3],[1,4]]
+Output: 1
+ 
+
+Constraints:
+
+3 <= n <= 105
+edges.length == n - 1
+edges[i].length == 2
+1 <= ui, vi <= n
+ui != vi
+The given edges represent a valid star graph.
+
+
+
+
+
+// using indegree concept
+
+class Solution {
+public:
+    int findCenter(vector<vector<int>>& edges) {
+        int n = edges.size() + 1;
+        
+        vector <int> adj[n + 1];
+        
+        for (auto &edge: edges) {
+            adj[edge[0]].push_back(edge[1]);
+            adj[edge[1]].push_back(edge[0]);
+        }
+        
+        for (int i = 1; i < n + 1; i++) {
+            if (n - 1 == adj[i].size()) return i;
+        }
+        
+        return -1; // no star
+    }
+};
+
+
+
+
+
+
+
+
+// star node will be a part of all the edges
+// star node will have (n - 1) indegree and also the edges.size() is equal to (n - 1)
+
+class Solution {
+public:
+    int findCenter(vector<vector<int>>& edges) {
+        int a = edges[0][0];
+        int b = edges[0][1];
+        int c = edges[1][0];
+        int d = edges[1][1];
+        
+        if (a == c || a == d) return a;
+        else return b;
+    }
+};