Minimum and maximum number of connected components

using System;
using System.Collections.Generic;

public class GFG {
    // Depth first search
    static void DFS(int V, int parent, ref int flag,
                    List<int> vis, List<List<int> > adj)
    {
        // Mark visited
        vis[V] = 1;

        // Iterating over V's neighbors
        foreach(int U in adj[V])
        {
            // If U is not visited
            if (vis[U] == 0) {
                // Call DFS function for node U with parent
                // V
                DFS(U, V, ref flag, vis, adj);
            }
            // If U is already visited and it is
            // not the last node that we visited,
            // then there is a loop in connected
            // components, so mark flag as 1
            else if (U != parent && parent != -1) {
                flag = 1;
            }
        }
    }

    // Function to find minimum and maximum
    // connected components
    static void FindMinMaxCC(int[] A, int N)
    {
        // Creating adjacency list
        List<List<int> > adj = new List<List<int> >();
        for (int i = 0; i <= N; i++) {
            adj.Add(new List<int>());
        }

        // Filling the adjacency list
        for (int i = 0; i < N; i++) {
            // There is an undirected edge from i+1 to A[i]
            adj[i + 1].Add(A[i]);
            adj[A[i]].Add(i + 1);
        }

        // Counters for looped and without
        // looped connected components
        int loopConnectedComponents = 0;
        int withoutLoopConnectedComponents = 0;

        // Creating a visited array for DFS
        List<int> vis = new List<int>();
        for (int i = 0; i <= N; i++) {
            vis.Add(0);
        }

        // Flag to check if a given connected
        // component has a loop
        int flag = 0;

        // Iterating for all N nodes
        for (int i = 1; i <= N; i++) {
            // If node i is not visited,
            // call DFS for that node
            if (vis[i] == 0) {
                // Call DFS function
                DFS(i, -1, ref flag, vis, adj);

                // If the flag is true, increment looped
                // connected component counter by 1
                if (flag == 1) {
                    loopConnectedComponents++;
                }
                // If not, increment without looped
                // connected components counter by 1
                else {
                    withoutLoopConnectedComponents++;
                }

                // Reset the flag
                flag = 0;
            }
        }

        // Maximum connected components
        int maxConnectedComponents
            = loopConnectedComponents
              + withoutLoopConnectedComponents;

        // Minimum connected components
        int minConnectedComponents
            = loopConnectedComponents;

        // Unify all connected components which
        // do not have a loop as 1 connected component
        if (withoutLoopConnectedComponents != 0) {
            minConnectedComponents++;
        }

        // Printing the answer of minimum and
        // maximum connected components
        Console.WriteLine(minConnectedComponents + " "
                          + maxConnectedComponents);
    }

    public static void Main(string[] args)
    {
        // Input 1
        int[] A = { 2, 1, 4, 3, 6, 5 };
        int N = 6;

        // Function Call
        FindMinMaxCC(A, N);

        // Input 2
        int[] A1 = { 2, 3, 1, 5, 6, 4 };
        int N1 = 6;

        // Function Call
        FindMinMaxCC(A1, N1);
    }
}