Skip to content
Related Articles

Related Articles

Check for star graph

Improve Article
Save Article
  • Difficulty Level : Basic
  • Last Updated : 05 Aug, 2022
Improve Article
Save Article

You are given an n * n matrix which represents a graph with n-vertices, check whether the input matrix represents a star graph or not.

Example: 

Input : Mat[][] = {{0, 1, 0},
                   {1, 0, 1},
                   {0, 1, 0}}
Output : Star graph

Input : Mat[][] = {{0, 1, 0},
                   {1, 1, 1},
                   {0, 1, 0}}
Output : Not a Star graph

Star graph: Star graph is a special type of graph in which n-1 vertices have degree 1 and a single vertex have degree n – 1. This looks like n – 1 vertex is connected to a single central vertex. A star graph with total n – vertex is termed as Sn.
Here is an illustration for the star graph : 
 

Check for star graph

Approach: Just traverse whole matrix and record the number of vertices having degree 1 and degree n-1. If number of vertices having degree 1 is n-1 and number of vertex having degree n-1 is 1 then our graph should be a star graph other-wise it should be not. 

Note:

  • For S1, there must be only one vertex with no edges.
  • For S2, there must be two vertices each with degree one or can say, both are connected by a single edge.
  • For Sn (n>2) simply check the above-explained criteria.

Implementation:

C++




// CPP to find whether given graph is star or not
#include<bits/stdc++.h>
using namespace std;
 
// define the size of incidence matrix
#define size 4
 
// function to find star graph
bool checkStar(int mat[][size])
{
    // initialize number of vertex
    // with deg 1 and n-1
    int vertexD1 = 0, vertexDn_1 = 0;
 
    // check for S1
    if (size == 1)
        return (mat[0][0] == 0);
     
    // check for S2
    if (size == 2)   
       return (mat[0][0] == 0 && mat[0][1] == 1 &&
               mat[1][0] == 1 && mat[1][1] == 0 );
 
    // check for Sn (n>2)
    for (int i = 0; i < size; i++)
    {
        int degreeI = 0;
        for (int j = 0; j < size; j++)
            if (mat[i][j])
                degreeI++;
 
        if (degreeI == 1)
            vertexD1++;
        else if (degreeI == size-1)
            vertexDn_1++;
    }
     
    return (vertexD1 == (size-1) &&
            vertexDn_1 == 1);
}
 
// driver code
int main()
{
    int mat[size][size] = { {0, 1, 1, 1},
                            {1, 0, 0, 0},
                            {1, 0, 0, 0},
                            {1, 0, 0, 0}};
 
    checkStar(mat) ? cout << "Star Graph" :
                     cout << "Not a Star Graph";
    return 0;
}

Java




// Java program to find whether
// given graph is star or not
import java.io.*;
 
class GFG
{
    // define the size of
    // incidence matrix
    static int size = 4;
     
    // function to find
    // star graph
    static boolean checkStar(int mat[][])
    {
        // initialize number of
        // vertex with deg 1 and n-1
        int vertexD1 = 0,
            vertexDn_1 = 0;
     
        // check for S1
        if (size == 1)
            return (mat[0][0] == 0);
         
        // check for S2
        if (size == 2)
        return (mat[0][0] == 0 &&
                mat[0][1] == 1 &&
                mat[1][0] == 1 &&
                mat[1][1] == 0);
     
        // check for Sn (n>2)
        for (int i = 0; i < size; i++)
        {
            int degreeI = 0;
            for (int j = 0; j < size; j++)
                if (mat[i][j] == 1)
                    degreeI++;
     
            if (degreeI == 1)
                vertexD1++;
            else if (degreeI == size - 1)
                vertexDn_1++;
        }
         
        return (vertexD1 == (size - 1) &&
                vertexDn_1 == 1);
    }
     
    // Driver code
    public static void main(String args[])
    {
        int mat[][] = {{0, 1, 1, 1},
                       {1, 0, 0, 0},
                       {1, 0, 0, 0},
                       {1, 0, 0, 0}};
     
        if (checkStar(mat))
            System.out.print("Star Graph");
        else
            System.out.print("Not a Star Graph");
    }
}
 
// This code is contributed by
// Manish Shaw(manishshaw1)

Python3




# Python to find whether
# given graph is star
# or not
 
# define the size
# of incidence matrix
size = 4
 
# def to
# find star graph
def checkStar(mat) :
 
    global size
     
    # initialize number of
    # vertex with deg 1 and n-1
    vertexD1 = 0
    vertexDn_1 = 0
 
    # check for S1
    if (size == 1) :
        return (mat[0][0] == 0)
     
    # check for S2
    if (size == 2) :
        return (mat[0][0] == 0 and
                mat[0][1] == 1 and
                mat[1][0] == 1 and
                mat[1][1] == 0)
 
    # check for Sn (n>2)
    for i in range(0, size) :
 
        degreeI = 0
        for j in range(0, size) :
            if (mat[i][j]) :
                degreeI = degreeI + 1
 
        if (degreeI == 1) :
            vertexD1 = vertexD1 + 1
 
        elif (degreeI == size - 1):
            vertexDn_1 = vertexDn_1 + 1
     
    return (vertexD1 == (size - 1) and
            vertexDn_1 == 1)
 
# Driver code
mat = [[0, 1, 1, 1],
       [1, 0, 0, 0],
       [1, 0, 0, 0],
       [1, 0, 0, 0]]
  
if(checkStar(mat)) :
    print ("Star Graph")
else :
    print ("Not a Star Graph")
     
# This code is contributed by
# Manish Shaw(manishshaw1)

C#




// C# to find whether given
// graph is star or not
using System;
 
class GFG
{
    // define the size of
    // incidence matrix
    static int size = 4;
     
    // function to find
    // star graph
    static bool checkStar(int [,]mat)
    {
        // initialize number of
        // vertex with deg 1 and n-1
        int vertexD1 = 0, vertexDn_1 = 0;
     
        // check for S1
        if (size == 1)
            return (mat[0, 0] == 0);
         
        // check for S2
        if (size == 2)
        return (mat[0, 0] == 0 &&
                mat[0, 1] == 1 &&
                mat[1, 0] == 1 &&
                mat[1, 1] == 0);
     
        // check for Sn (n>2)
        for (int i = 0; i < size; i++)
        {
            int degreeI = 0;
            for (int j = 0; j < size; j++)
                if (mat[i, j] == 1)
                    degreeI++;
     
            if (degreeI == 1)
                vertexD1++;
            else if (degreeI == size - 1)
                vertexDn_1++;
        }
         
        return (vertexD1 == (size - 1) &&
                vertexDn_1 == 1);
    }
     
    // Driver code
    static void Main()
    {
        int [,]mat = new int[4, 4]{{0, 1, 1, 1},
                                   {1, 0, 0, 0},
                                   {1, 0, 0, 0},
                                   {1, 0, 0, 0}};
     
        if (checkStar(mat))
            Console.Write("Star Graph");
        else
            Console.Write("Not a Star Graph");
    }
}
// This code is contributed by
// Manish Shaw(manishshaw1)

PHP




<?php
// PHP to find whether
// given graph is star
// or not
 
// define the size
// of incidence matrix
$size = 4;
 
// function to
// find star graph
function checkStar($mat)
{
    global $size;
     
    // initialize number of
    // vertex with deg 1 and n-1
    $vertexD1 = 0;
    $vertexDn_1 = 0;
 
    // check for S1
    if ($size == 1)
        return ($mat[0][0] == 0);
     
    // check for S2
    if ($size == 2)
    return ($mat[0][0] == 0 &&
            $mat[0][1] == 1 &&
            $mat[1][0] == 1 &&
            $mat[1][1] == 0 );
 
    // check for Sn (n>2)
    for ($i = 0; $i < $size; $i++)
    {
        $degreeI = 0;
        for ($j = 0; $j < $size; $j++)
            if ($mat[$i][$j])
                $degreeI++;
 
        if ($degreeI == 1)
            $vertexD1++;
        else if ($degreeI == $size - 1)
            $vertexDn_1++;
    }
     
    return ($vertexD1 == ($size - 1) &&
            $vertexDn_1 == 1);
}
 
// Driver code
$mat = array(array(0, 1, 1, 1),
             array(1, 0, 0, 0),
             array(1, 0, 0, 0),
             array(1, 0, 0, 0));
 
if(checkStar($mat))
    echo ("Star Graph");
else
    echo ("Not a Star Graph");
     
// This code is contributed by
// Manish Shaw(manishshaw1)
?>

Javascript




<script>
 
// Javascript to find whether given
// graph is star or not
 
// define the size of incidence matrix
var size = 4;
 
// function to find star graph
function checkStar( mat)
{
    // initialize number of vertex
    // with deg 1 and n-1
    var vertexD1 = 0, vertexDn_1 = 0;
 
    // check for S1
    if (size == 1)
        return (mat[0][0] == 0);
     
    // check for S2
    if (size == 2)   
       return (mat[0][0] == 0 && mat[0][1] == 1 &&
               mat[1][0] == 1 && mat[1][1] == 0 );
 
    // check for Sn (n>2)
    for (var i = 0; i < size; i++)
    {
        var degreeI = 0;
        for (var j = 0; j < size; j++)
            if (mat[i][j])
                degreeI++;
 
        if (degreeI == 1)
            vertexD1++;
        else if (degreeI == size-1)
            vertexDn_1++;
    }
     
    return (vertexD1 == (size-1) &&
            vertexDn_1 == 1);
}
 
// driver code
var mat = [ [0, 1, 1, 1],
                        [1, 0, 0, 0],
                        [1, 0, 0, 0],
                        [1, 0, 0, 0]];
checkStar(mat) ? document.write( "Star Graph") :
                 document.write( "Not a Star Graph");
 
</script>

Output

Star Graph

My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!