Open In App

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy

Difference Between sum of degrees of odd and even degree nodes in an Undirected Graph

Given an undirected graph with N vertices and M edges, the task is to find the absolute difference Between the sum of degrees of odd degree nodes and even degree nodes in an undirected Graph.

Examples: 



Input: N = 4, edges[][] = { { 1, 2 }, { 1, 3 }, { 1, 4 }, { 2, 3 }, { 2, 4 }, { 3, 4 } } 
Output: 12 
Explanation: 
Below is the graph for the above information:  



Node -> Degree 
1 -> 3 
2 -> 3 
3 -> 3 
4 -> 3
Sum of odd degree node = 3 + 3 + 3 + 3 = 12 
Sum of even degree node = 0 
Difference = 12

Input: N = 5, edges[][] = { { 1, 2 }, { 1, 3 }, { 2, 4 }, { 2, 5 } } 
Output: 4

Approach: 

  1. For each vertex, the degree can be calculated by the length of the Adjacency List of the given graph at the corresponding vertex.
  2. Count the sum of degrees of odd degree nodes and even degree nodes and print the difference.

Below is the implementation of the above approach:




// C++ implementation to print the
// Difference Between sum of degrees
// of odd degree nodes and even
// degree nodes.
#include <bits/stdc++.h>
using namespace std;
 
// Function to print the difference
// Between sum of degrees of odd
// degree nodes and even degree nodes.
int OddEvenDegree(int N, int M,
                    int edges[][2])
{
    // To store Adjacency List of
    // a Graph
    vector<int> Adj[N + 1];
     
    int EvenSum = 0;
    int OddSum = 0;
 
    // Make Adjacency List
    for (int i = 0 ; i < M ; i++) {
        int x = edges[i][0];
        int y = edges[i][1];
 
        Adj[x].push_back(y);
        Adj[y].push_back(x);
    }
 
    // Traverse each vertex
    for (int i = 1; i <= N; i++) {
 
        // Find size of Adjacency List
        int x = Adj[i].size();
 
        // If length of Adj[i] is
        // an odd number, add
        // length in OddSum
        if (x % 2 != 0)
        {
            OddSum += x;
        }
        else
        {
            // If length of Adj[i] is
            // an even number, add
            // length in EvenSum
            EvenSum += x;
        }
             
    }
     
    return abs(OddSum - EvenSum);
}
 
// Driver code
int main()
{
    // Vertices and Edges
    int N = 4, M = 6;
 
    // Edges
    int edges[M][2] = { { 1, 2 }, { 1, 3 }, { 1, 4 },
                       { 2, 3 }, { 2, 4 }, { 3, 4 } };
 
    // Function Call
    cout<< OddEvenDegree(N, M, edges);
 
    return 0;
}
 





                        























                                    



                                    




                                    




                                    


                                



















// Java implementation to print the


// difference between sum of degrees


// of odd degree nodes and even 


// degree nodes.



import java.util.*;



 



class GFG{



 


// Function to print the difference


// between sum of degrees of odd


// degree nodes and even degree nodes.



static int OddEvenDegree(int N, int M,




                         int edges[][])



{



     



    // To store adjacency list 




    // of a graph




    @SuppressWarnings("unchecked")




    Vector<Integer> []Adj = new Vector[N + 1];




     



    for(int i = 0; i < N + 1; i++)




    {




       Adj[i] = new Vector<Integer>();




    }




     



    int EvenSum = 0;




    int OddSum = 0;



 



    // Make adjacency list




    for(int i = 0; i < M; i++)




    {




       int x = edges[i][0];




       int y = edges[i][1];




        



       Adj[x].add(y);




       Adj[y].add(x);




    }



 



    // Traverse each vertex




    for(int i = 1; i <= N; i++)




    {




         



       // Find size of adjacency list




       int x = Adj[i].size();




        



       // If length of Adj[i] is




       // an odd number, add




       // length in OddSum




       if (x % 2 != 0)




       {




           OddSum += x;




       }




       else




       {




            



           // If length of Adj[i] is




           // an even number, add 




           // length in EvenSum




           EvenSum += x;




       }




    }




    return Math.abs(OddSum - EvenSum);



}


 


// Driver code



public static void main(String[] args)



{



     



    // Vertices and edges




    int N = 4, M = 6;



 



    // Edges




    int edges[][] = { { 1, 2 }, { 1, 3 }, { 1, 4 },




                      { 2, 3 }, { 2, 4 }, { 3, 4 } };



 



    // Function call




    System.out.print(OddEvenDegree(N, M, edges));



}


}


 


// This code is contributed by PrinciRaj1992


















                        






                        























                                    



                                    




                                    




                                    


                                



















# Python3 implementation to print the


# Difference Between sum of degrees


# of odd degree nodes and even 


# degree nodes.


 


# Function to print the difference


# Between sum of degrees of odd


# degree nodes and even degree nodes.



def OddEvenDegree(N, M, edges):



 



    # To store Adjacency 




    # List of a Graph




    Adj = [[] for i in range(N + 1)]




      



    EvenSum = 0;




    OddSum = 0;




  



    # Make Adjacency List




    for i in range(M):




        x = edges[i][0];




        y = edges[i][1];




  



        Adj[x].append(y);




        Adj[y].append(x);




  



    # Traverse each vertex




    for i in range(1, N + 1):




  



        # Find size of 




        # Adjacency List




        x = len(Adj[i])




  



        # If length of Adj[i] is




        # an odd number, add




        # length in OddSum




        if (x % 2 != 0):




            OddSum += x;        




        else:




             



            # If length of Adj[i] is




            # an even number, add 




            # length in EvenSum




            EvenSum += x;        




      



    return abs(OddSum - EvenSum);



 


# Driver code



if __name__ == "__main__":




     



    # Vertices and Edges




    N = 4




    M = 6




  



    # Edges




    edges = [[1, 2], [1, 3], 




             [1, 4], [2, 3], 




             [2, 4], [3, 4]]




  



    # Function Call




    print(OddEvenDegree(N, M, 




                        edges));



 


# This code is contributed by rutvik_56


















                        






                        























                                    



                                    




                                    




                                    


                                



















// C# implementation to print the


// difference between sum of degrees


// of odd degree nodes and even 


// degree nodes.



using System;




using System.Collections.Generic;




class GFG{



 


// Function to print the difference


// between sum of degrees of odd


// degree nodes and even degree nodes.



static int OddEvenDegree(int N, int M,




                         int [,]edges)



{



  // To store adjacency list 




  // of a graph




  List<int> []Adj = new List<int>[N + 1];



 



  for(int i = 0; i < N + 1; i++)




  {




    Adj[i] = new List<int>();




  }



 



  int EvenSum = 0;




  int OddSum = 0;



 



  // Make adjacency list




  for(int i = 0; i < M; i++)




  {




    int x = edges[i, 0];




    int y = edges[i, 1];



 



    Adj[x].Add(y);




    Adj[y].Add(x);




  }



 



  // Traverse each vertex




  for(int i = 1; i <= N; i++)




  {




    // Find size of adjacency list




    int x = Adj[i].Count;



 



    // If length of Adj[i] is




    // an odd number, add




    // length in OddSum




    if (x % 2 != 0)




    {




      OddSum += x;




    }




    else




    {




      // If length of Adj[i] is




      // an even number, add 




      // length in EvenSum




      EvenSum += x;




    }




  }




  return Math.Abs(OddSum - EvenSum);



}


 


// Driver code



public static void Main(String[] args)



{



  // Vertices and edges




  int N = 4, M = 6;



 



  // Edges




  int [,]edges = {{1, 2}, {1, 3}, {1, 4},




                  {2, 3}, {2, 4}, {3, 4}};



 



  // Function call




  Console.Write(OddEvenDegree(N, M, edges));



}


}


 


// This code is contributed by Princi Singh


















                        






                        























                                    



                                    




                                    




                                    


                                



















<script>


 


// Javascript implementation to print the


// Difference Between sum of degrees


// of odd degree nodes and even 


// degree nodes.


 


// Function to print the difference


// Between sum of degrees of odd


// degree nodes and even degree nodes.



function OddEvenDegree(N, M, edges)



{



    // To store Adjacency List of




    // a Graph




    var Adj = Array.from(Array(N+1), ()=>Array());




     



    var EvenSum = 0;




    var OddSum = 0;



 



    // Make Adjacency List




    for (var i = 0 ; i < M ; i++) {




        var x = edges[i][0];




        var y = edges[i][1];



 



        Adj[x].push(y);




        Adj[y].push(x);




    }



 



    // Traverse each vertex




    for (var i = 1; i <= N; i++) {



 



        // Find size of Adjacency List




        var x = Adj[i].length;



 



        // If length of Adj[i] is




        // an odd number, add




        // length in OddSum




        if (x % 2 != 0)




        {




            OddSum += x;




        }




        else




        {




            // If length of Adj[i] is




            // an even number, add 




            // length in EvenSum




            EvenSum += x;




        }




             



    }




     



    return Math.abs(OddSum - EvenSum);



}


 


// Driver code


// Vertices and Edges



var N = 4, M = 6;



// Edges



var edges = [ [ 1, 2 ], [ 1, 3 ], [ 1, 4 ],




                   [ 2, 3 ], [ 2, 4 ], [ 3, 4 ] ];



// Function Call


document.write( OddEvenDegree(N, M, edges));


 


 


</script>


















                        






                        








Output

12




	

        Article Tags : 
        

            Algorithms
Competitive Programming
DSA
Graph        


	


      

      

          
Recommended Articles

      

      

          
          
1. Sum of degrees of all nodes of a undirected graph

          
2. Nodes with prime degree in an undirected Graph

          
3. What is Undirected Graph? | Undirected Graph meaning

          
4. Detect cycle in the graph using degrees of nodes of graph

          
5. Absolute difference between sum of even elements at even indices & odd elements at odd indices in given Array

          
6. Modify Binary Tree by replacing all nodes at even and odd levels by their nearest even or odd perfect squares respectively

          
7. Check if a cycle exists between nodes S and T in an Undirected Graph with only S and T repeating

          
8. Check if a cycle exists between nodes S and T in an Undirected Graph with only S and T repeating | Set - 2

          
9. Minimum edges to be removed from given undirected graph to remove any existing path between nodes A and B

          
10. Check if there is a cycle with odd weight sum in an undirected graph

          
11. Maximum sum of values of nodes among all connected components of an undirected graph

          
12. Minimum degree of three nodes forming a triangle in a given Graph

          
13. Difference between sum of even and odd valued nodes in a Binary Tree

          
14. Find the nearest odd and even perfect squares of odd and even array elements respectively

          
15. Count of integers in a range which have even number of odd digits and odd number of even digits

          
16. Check if a number has an odd count of odd divisors and even count of even divisors

          
17. Count numbers from given range having odd digits at odd places and even digits at even places

          
18. Even numbers at even index and odd numbers at odd index

          
19. Print levels with odd number of nodes and even number of nodes

          
20. Convert the undirected graph into directed graph such that there is no path of length greater than 1

          
21. Convert undirected connected graph to strongly connected directed graph

          
22. Maximize the difference of sum of elements at even indices and odd indices by shifting an odd sized subarray to end of given Array.

          
23. Kth largest node among all directly connected nodes to the given node in an undirected graph

          
24. Maximum GCD of all nodes in a connected component of an Undirected Graph

          
25. Count of nodes with maximum connection in an undirected graph