GRAPH_LIVE_YOUTUBE - 3 problems

https://www.youtube.com/watch?v=4B0M0biIa3E

Author: rachitiitr

LeetCode/765.couples-holding-hands.cpp

@@ -0,0 +1,69 @@
+const int N = 70;
+set<int> g[N];
+bool vis[N];
+
+void fill_cluster_size(int u, int &cluster_size) {
+    vis[u] = 1;
+    // cout << "dfs::at couple " << u << endl;
+    cluster_size++;
+    for(int v: g[u]) {
+        if(!vis[v]) {
+            fill_cluster_size(v, cluster_size);
+        }
+    }
+}
+
+int get_couple_id(int person) {
+    return person / 2;
+}
+
+
+class Solution {
+public:
+    int minSwapsCouples(vector<int>& row) {
+        int n = row.size() / 2;
+        // normalizing the seating arrangement in terms of couple ids
+        for(int &x: row) x = get_couple_id(x);
+        
+        for(int i = 0; i < n; i++) {
+            g[i].clear();
+            vis[i] = 0;
+        }
+        
+        for(int i = 0; i < row.size(); i += 2) {
+            int c1 = row[i], c2 = row[i+1];
+            if( c1 == c2 ) continue;
+            g[c1].insert(c2);
+            g[c2].insert(c1);
+            // cout << i << " adding edge in couple " << c1 << " " << c2 << endl;
+        }
+        
+        int ans = 0;
+        for(int i = 0; i < n; i++) {
+            if(!vis[i]) {
+                int cluster_size = 0;
+                fill_cluster_size(i, cluster_size);
+                ans += cluster_size - 1;
+            }
+        }
+        return ans;
+    }
+};
+/*
+    0,3,1,2 -> 0,1,3,2
+    easy notation: 0,1,0,1
+    - Find a swap that can make two couples happy.
+    - 
+(0, 1) --- 1st couple --- couple id = 0
+(2, 3) --- 2nd couple --- couple id = 1
+(4, 5) -- 3rd couple --- couple id = 2
+    0,3,5,2,1,4 --> 0,1,2,1,0,2
+    
+    0---1---2
+    \______/
+
+x----y      <--- 1 swap
+x----y----z <--- 2 swaps
+
+C couples --- C-1 swaps
+*/

LeetCode/797.all-paths-from-source-to-target.cpp

@@ -0,0 +1,51 @@
+const int N = 20;
+vector<int> g[N];
+using path = vector<int>;
+set<path> get_all_paths(int src, int tar) {
+    // cout << src << endl;
+    if(src == tar) return { {tar} };
+    set<path> ans = {};
+    for(int v: g[src]) {
+        auto rem_paths = get_all_paths(v, tar);
+        for (path p: rem_paths) {
+            p.push_back(src);
+            ans.insert(p);
+        }
+    }
+    return ans;
+}
+
+
+class Solution {
+    
+public:
+    
+    vector<vector<int>> allPathsSourceTarget(vector<vector<int>>& graph) {
+        // paths from 0 to 4
+        // iterate on children v of 0
+        // find paths from child v to 4
+        // [0,1,3,4]
+        int n = graph.size();
+        
+        if(n == 0) return {};
+        for(int i = 0; i < n; i++) g[i].clear();
+        
+        for(int i = 0; i < n; i++) {
+            for(int v: graph[i]) {
+                g[i].push_back(v);
+            }
+        }
+        
+        vector<path> ans = {};
+        set<path> paths = get_all_paths(0, n-1);
+        
+        
+        // O(# of paths * avg_size of path)
+        for(auto p: paths) {
+            reverse(p.begin(), p.end());
+            ans.push_back(p);
+        }
+        
+        return ans;
+    }
+};

LeetCode/997.find-the-town-judge.cpp

@@ -0,0 +1,26 @@
+class Solution {
+public:
+    int findJudge(int n, vector<vector<int>>& trust) {
+        vector<int> followers(n+1, 0); // 1 based indexing
+        vector<int> does_follow(n+1, 0);
+        
+        map<int, int> followers, does_follow; // O(logN)
+        
+        for(auto edge: trust) {
+            int u = edge[0], v = edge[1];
+            // person u trusts v
+            followers[v]++; // O(1) v/s in maps O(logN) --> O(1)
+            does_follow[u] = 1;
+        }
+        
+        vector<int> final_candidates = {};
+        for(int i = 1; i <= n; i++) {
+            if(followers[i] == n-1 && does_follow[i] == 0) {
+                final_candidates.push_back(i);
+            }
+        }
+        
+        if(final_candidates.size() != 1) return -1;
+        return final_candidates[0];
+    }
+};