Check if given graph is connected or not after removal of ith node sequential

using System;
using System.Collections.Generic;

public class DSU
{
    // Declaring array
    private List<int> parent;

    // initializing every nodes parent to be -1 initially
    public DSU(int N)
    {
        parent = new List<int>(N + 1);
        for (int i = 0; i <= N; i++)
        {
            parent.Add(-1);
        }
    }

    // get parent for x
    public int Get(int x)
    {
        return parent[x] < 0 ? x : parent[x] = Get(parent[x]);
    }

    // function to check whether node a and node b
    // belongs to same component or not
    public bool SameSet(int a, int b)
    {
        return Get(a) == Get(b);
    }

    // check size of component that node x belongs to
    public int Size(int x)
    {
        return -parent[Get(x)];
    }

    // connect component containing x and y (make them same
    // component)
    public bool Union(int x, int y)
    {
        // get parents of x and y
        x = Get(x);
        y = Get(y);

        // if x and y are same nodes return false;
        if (x == y)
            return false;

        // if parent of x is greater than parent of y swap x
        // and y
        if (parent[x] > parent[y])
        {
            int temp = x;
            x = y;
            y = temp;
        }

        // add all nodes of y to x
        parent[x] += parent[y];

        // parent of y is x
        parent[y] = x;

        // return true to end the function
        return true;
    }
}

public class Graph
{
    // Check if given graph is connected or not
    // after removal of i'th node
    public static void IsGraphConnected(int N, int[,] edges, int M, int[] A)
    {
        // Initializing Disjoing Union data structure
        DSU dsu = new DSU(N + 1);

        // Declare adjacency list
        List<List<int>> adj = new List<List<int>>(N + 1);

        // fill the adjacency list
        for (int i = 0; i < N + 1; i++)
        {
            adj.Add(new List<int>());
        }

        for (int i = 0; i < M; i++)
        {
            // there is undirected edge from edges[i, 0] to
            // edges[i, 1]
            adj[edges[i, 0]].Add(edges[i, 1]);
            adj[edges[i, 1]].Add(edges[i, 0]);
        }

        // visited array so we will keep inserting all nodes
        List<int> isInserted = new List<int>(N + 1);
        for (int i = 0; i <= N; i++)
        {
            isInserted.Add(0);
        }

        // previous node
        int firstNodeToBeInserted = A[N - 1];

        // storing answer in ans variable
        List<string> ans = new List<string>();

        // start inserting nodes from backwards
        for (int i = N - 1; i >= 0; i--)
        {
            // if number of nodes in component of first node
            // that was inserted in this case A[N - 1] have size
            // equal to number of total nodes inserted till now
            // then graph is connected or if there are no nodes
            // inserted then also graph is connected since graph
            // will be empty graph
            if (dsu.Size(firstNodeToBeInserted) == (N - 1 - i)
                || i == N - 1)
                ans.Add("YES");

            // otherwise
            else
                ans.Add("NO");

            // current node to be inserted
            int V = A[i];

            // marking current node as true which signifies
            // current node is inserted in graph
            isInserted[V] = 1;

            // iterating over adjacents V which are inserted
            foreach (var U in adj[V])
            {
                if (isInserted[U] == 1)
                    dsu.Union(V, U);
            }
        }

        // reverse the ans so insertion from last to first node
        // becomes deletion from first node to last node
        ans.Reverse();

        // print answer whether given graph is connected after
        // deletion of i'th node
        foreach (var item in ans)
        {
            Console.Write(item + " ");
        }
        Console.WriteLine();
    }
}

public class Program
{
    // Driver Code
    public static void Main(string[] args)
    {
        // Input
        int N = 5, M = 5;
        int[,] edges = { { 1, 2 }, { 1, 3 }, { 3, 5 }, { 2, 5 }, { 5, 4 } };
        int[] A = { 3, 5, 2, 4, 1 };

        // Function Call
        Graph.IsGraphConnected(N, edges, M, A);
    }
}