Graph GFG

Author: harshit2608

BinarySearch/179. Conway's Game of Life.cpp

@@ -0,0 +1,53 @@
+bool isSafe(int i, int j, int n, int m)
+{
+    if (i < 0 || i >= n || j < 0 || j >= m)
+    {
+        return false;
+    }
+    return true;
+}
+
+vector<vector<int>> solve(vector<vector<int>> &matrix)
+{
+    vector<vector<int>> ans(matrix.begin(), matrix.end());
+    int dx[8] = {1, 1, 0, -1, -1, -1, 0, 1};
+    int dy[8] = {0, 1, 1, 1, 0, -1, -1, -1};
+
+    // count the surrounding 1 for a given cell
+    // if count ==2 || count ==3
+    // cell = 1
+    // else cell = 0
+
+    int n = matrix.size();
+    int m = matrix[0].size();
+
+    for (int i = 0; i < n; ++i)
+    {
+        for (int j = 0; j < m; ++j)
+        {
+            int count = 0;
+            for (int k = 0; k < 8; ++k)
+            {
+                int newi = i + dx[k];
+                int newj = j + dy[k];
+                if (isSafe(newi, newj, n, m) && matrix[newi][newj] == 1)
+                {
+                    count++;
+                }
+            }
+            if (matrix[i][j] == 1 && (count == 2 || count == 3))
+            {
+                ans[i][j] = 1;
+            }
+            else if (matrix[i][j] == 0 && (count == 3))
+            {
+                ans[i][j] = 1;
+            }
+            else
+            {
+                ans[i][j] = 0;
+            }
+        }
+    }
+    return ans;
+}

GeeksForGeeks/Alien Dictionary.cpp

@@ -0,0 +1,58 @@
+class Solution
+{
+public:
+    void dfs(vector<int> adj[], vector<int> &visited, stack<int> &st, int src)
+    {
+        visited[src] = 1;
+        for (auto it : adj[src])
+        {
+            if (!visited[it])
+            {
+                dfs(adj, visited, st, it);
+            }
+        }
+        st.push(src);
+    }
+
+    string topo(vector<int> adj[], int vertices)
+    {
+        stack<int> st;
+        vector<int> visited(vertices, 0);
+        for (int i = 0; i < vertices; ++i)
+        {
+            if (!visited[i])
+            {
+                dfs(adj, visited, st, i);
+            }
+        }
+
+        string ans;
+        while (!st.empty())
+        {
+            ans.push_back(st.top() + 'a');
+            st.pop();
+        }
+        return ans;
+    }
+
+    string findOrder(string dict[], int N, int K)
+    {
+        vector<int> adj[26];
+        for (int i = 0; i < N - 1; ++i)
+        {
+            string s1 = dict[i];
+            string s2 = dict[i + 1];
+            for (int j = 0; j < min(s1.size(), s2.size()); ++j)
+            {
+                if (s1[j] != s2[j])
+                {
+                    int idx1 = s1[j] - 'a';
+                    int idx2 = s2[j] - 'a';
+                    adj[idx1].push_back(idx2);
+                    break;
+                }
+            }
+        }
+        return topo(adj, K);
+    }
+};

GeeksForGeeks/Bridge edge in a graph.cpp

@@ -0,0 +1,31 @@
+class Solution
+{
+public:
+    // Function to find if the given edge is a bridge in graph.
+    void dfs(vector<int> adj[], vector<int> &visited, int src, int c, int d)
+    {
+        visited[src] = true;
+        for (auto it : adj[src])
+        {
+            if ((src == c && it == d) || (src == d && it == c))
+            {
+                continue;
+            }
+            if (!visited[it])
+            {
+                dfs(adj, visited, it, c, d);
+            }
+        }
+    }
+
+    int isBridge(int V, vector<int> adj[], int c, int d)
+    {
+        vector<int> visited(V, 0);
+        dfs(adj, visited, c, c, d);
+        if (!visited[d])
+        {
+            return true;
+        }
+        return false;
+    }
+};

GeeksForGeeks/Hamiltonian Path.cpp

@@ -0,0 +1,48 @@
+class Solution
+{
+ic:
+    bool dfs(int node,  int c , vector<int> adj[ ], int  n, vector<int> &
+    vis)
+    { 
+           
+        if (c == n)
+             return   true;
+        
+        vis[no de] = 1;      
+            
+        for (auto x : adj[node])
+        {
+            if (!vis[x] && dfs(x, c + 1, adj, n, vis))
+            {
+                return true;
+            }
+    }
+        vis[node] = 0 ; 
+        return false;
+    }   
+    
+        
+     bool check(int N, int M, vector<vector<int>> Edges)
+     {
+c        for (auto &v : Edges)
+         {   
+              adj[v[0]] .push_b ack(
+        v[1]);
+             a dj[v[1]].
+            push_back(v[0]);
+         }     
+                
+         vector<int> vis(N + 1, 0);
+         for (int i = 1; i <= N; i++)
+         {
+             if (!vis[i])
+             {
+                if (dfs(i, 1, adj, N, vis))
+                {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+};

GeeksForGeeks/Knight Walk.cpp

@@ -0,0 +1,56 @@
+class Solution
+{
+public:
+    int dx[8] = {1, 1, -1, -1, 2, 2, -2, -2};
+    int dy[8] = {2, -2, 2, -2, 1, -1, 1, -1};
+
+    bool isSafe(int i, int j, int n)
+    {
+        if (i < 1 || i > n || j < 1 || j > n)
+        {
+            return false;
+        }
+        return true;
+    }
+
+    int minStepToReachTarget(vector<int> &start, vector<int> &end, int N)
+    {
+        int ans = 0;
+        queue<pair<int, int>> q;
+        vector<vector<int>> visited(N + 1, vector<int>(N + 1, 0));
+
+        int s0 = start[0], s1 = start[1];
+        q.push({s0, s1});
+        visited[s0][s1] = 1;
+
+        while (!q.empty())
+        {
+            int sx = q.size();
+            while (sx--)
+            {
+                pair<int, int> curr = q.front();
+                q.pop();
+                int x = curr.first;
+                int y = curr.second;
+
+                if (x == end[0] && y == end[1])
+                {
+                    return ans;
+                }
+
+                for (int i = 0; i < 8; ++i)
+                {
+                    int newx = x + dx[i];
+                    int newy = y + dy[i];
+                    if (isSafe(newx, newy, N) && !visited[newx][newy])
+                    {
+                        q.push({newx, newy});
+                        visited[newx][newy] = 1;
+                    }
+                }
+            }
+            ans++;
+        }
+        return ans;
+    }
+};

SPOJ/COLORFUL ARRAY.cpp

@@ -0,0 +1,95 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+#define HAR_HAR_MAHADEV int main()
+
+#define mod int(1e9 + 7)
+#define ll long long
+#define tc    \
+    int t;    \
+    cin >> t; \
+    while (t--)
+#define fastIO                        \
+    ios_base::sync_with_stdio(false); \
+    cin.tie(0);                       \
+    cout.tie(0)
+
+class Graph
+{
+public:
+    Graph(ll vertex)
+        : V(vertex)
+    {
+        adj = new vector<pair<ll, ll>>[V];
+    }
+
+    void addEdge(ll u, ll v, ll weight)
+    {
+        adj[u].push_back({v, weight});
+        adj[v].push_back({u, weight});
+    }
+
+    void print(vector<ll> &ans);
+    ll holiday();
+
+private:
+    ll V;
+    vector<pair<ll, ll>> *adj;
+};
+
+ll Graph::holiday()
+{
+    vector<ll> visited(V, 0);
+    vector<ll> distance(V, 1);
+    function<ll(vector<ll> & visited, vector<ll> & distance, ll src, ll & ans)> dfs;
+    dfs = [&](vector<ll> &visited, vector<ll> &distance, ll src, ll &ans)
+    {
+        visited[src] = 1;
+        for (auto itr : adj[src])
+        {
+            ll node = itr.first;
+            ll weight = itr.second;
+            if (visited[node] == 0)
+            {
+                distance[src] += dfs(visited, distance, node, ans);
+                ans += 2 * min(distance[node], V - 1 - distance[node]) * weight;
+            }
+        }
+        return distance[src];
+    };
+
+    ll ans = 0;
+    dfs(visited, distance, 1, ans);
+    return ans;
+}
+
+void solve()
+{
+    int n;
+    cin >> n;
+    Graph g(n + 1);
+    for (int i = 1; i < n; ++i)
+    {
+        int u, v, w;
+        cin >> u >> v >> w;
+        g.addEdge(u, v, w);
+    }
+    cout << g.holiday();
+}
+
+HAR_HAR_MAHADEV
+{
+    fastIO;
+    int counter = 1;
+#ifndef ONLINE_JUDGE
+    cerr << "HEllo";
+#endif
+    tc
+    {
+        cout << "Case #" << counter << ": ";
+        solve();
+        cout << "\n";
+        counter++;
+    }
+    return 0;
+}