Implementing a Graph bipartition checker in Python

Iran Neto — Wed, 18 Dec 2019 00:40:07 +0000

As a software developer I try make a routine that includes the practicing of my skills to solve mathematic/algorithm problems. Some days ago I found out a Google annual code competition called Code Jam and the very first problem I saw puzzled me (I will talk about it). After some research I was able to solve it through a graph bipartition checker algorithm and decided to write the path I took to come up with the solution.
Let’s do it.

Graph

A Graph is a non-linear abstract data structure well known in mathematics. They are used to model pairwise relations between objects through structures/concepts as nodes (or simply “points”) and edges (also called “links”, “arcs” or “lines” that connects two nodes) [1][2]. The study of graphs and its properties is called Graph Theory and was developed by Dénes König in 1936, a brilliant mathematician which wrote the very first book about graph theory [3]. Graphs are used to model lots of situations that happens in real world like most efficient airplane path from x to y or shortest distance between two points of a city (GPS algorithms), and so on.

The problem

2014 Grad Test — Practice round.

Bad Horse Problem

As the leader of the Evil League of Evil, Bad Horse has a lot of problems to deal with. Most recently, there have been far too many arguments and far too much backstabbing in the League, so much so that Bad Horse has decided to split the league into two departments in order to separate troublesome members. Being the Thoroughbred of Sin, Bad Horse isn’t about to spend his valuable time figuring out how to split the League members by himself. That what he’s got you — his loyal henchman — for.

https://code.google.com/codejam/contest/2933486/dashboard

Solution

After reading the description some ideas came to my mind before initiate to code a possible solution.

First, I will have to store pair’s names and somehow represent the relation between then. Also, I have to be able to check the possibility to separate the pairs into 2 groups — No pair should be in the same group. With a bit more searches I’ve found out that this is classic problem of graph bipartite.

I’ve realized it’s a important step before start coding in super matrix hacker style. Analyse it, get into problem’s head.

Bipartite Graph

A bipartite graph is a graph which all its nodes can be separated in two groups so that each element of one group is only related to elements of the other group. It’s also knows as bicolored graph (each group would represent a color, so every element in the graph is only related to another color element). They are very used in Petri Networks (Concurrency Systems resources simulation) and others real world situations [4].

Algorithm

The algorithm to check a graph bipartition can be very similar to DFS in trees data structures (Depth First Search). DFS algorithm it’s used to find the depth of a tree and works by choosing the root element and dive into their neighbors until there aren’t no element’s child or leaf.

Curious fact: Every tree is a graph bipartite

To add the function of bipartition check we need to initiate another structure to store the group (or color) information of each element. Besides that, it’s necessary also to check the groups belonging to each graph node given its neighbors group

The pseudocode analysis will be divided in two parts to a better understanding.

Pseudocode - Controller

Let’s check the pseudo algorithm.

The first part will function as a initialize or “controller” assuring that the routine will be executed for all nodes in graph.

OBS: To explain the pseudocode I’m going to assume the following constants
V = graph node
C1 = group 01 value
graph = the data structure represented in code
C2 = group 02 value

FOR each graph node v
    Initialize v group/color c with a neutral value, representing no color/group
end FOR

FOR each graph node V
    Initialize V group value C = C1
end FOR
FOR every graph node V
    IF group C is C1:
        IF NOT SET_GROUP_VALUE(graph, V, C1)
            return FALSE
        end IF
    end IF
end FOR
return TRUE

At the first loop we’re going to initiate all nodes with group 01 value. At the second loop for every node that has the group 01 value we’re going to check its neighbors and, if possible, set it a different group value.

Pseudocode — Recursive Search

The second part is the recursive algorithm that holds the logic to check if a node can be part of a different group than his neighbors.

-- Start a routine SET_GROUP_VALUE(graph, V, C) -- Ignore this line

SET the group of V as C
FOR every neighbors W of V
    IF group value C of W is neutral
        IF NOT SET_GROUP_VALUE(graph, W, C2)
            return FALSE
        end IF
    ELSE
        IF group value of W is C
            return FALSE
        end IF
    end ELSE
end FOR
return TRUE

The first loop start to dive into the subset of V nodes (subtree with root in V). If V’s neighbor W have group 01 value then the algorithm will check if it’s possible to give group 02 value.

Implementation

As described in the problem, our goal is to execute T test cases of M element pairs described in a file. The first line of this file will contain the T value followed by M number of pairs, thus, the next M lines will contain the M pairs information. The output will be also a file that describes the test case number and if the set of M pairs names can be divided into two groups, or, if the set of pairs can be represented as a bipartite graph.

-- Input file example -- Ignore this line
2
1
Dead_Bowie Fake_Thomas_Jefferson
3
Dead_Bowie Fake_Thomas_Jefferson
Fake_Thomas_Jefferson Fury_Leika
Fury_Leika Dead_Bowie

-- Output file example -- Ignore this line
Case #1: Yes
Case #2: No

There are some ways to represent a graph in code [5], one of them is an adjacency matrix and that is how it’s gonna be represent in this article, but with some small modifications the solution can be able to work as well. Here, I will represent it as a python dictionary: The keys will be the nodes and the key’s value will be a list of all its neighbors. Here’s an example

g = { 
    “a” : [“d”],
    “b” : [“c”],
    “c” : [“b”, “c”, “d”, “e”],
    “d” : [“a”, “c”],
    “e” : [“c”],
    “f” : []
}

Code

Let’s check my implementation of pseudocode.
OBS: color = group value

From line 1 to 27 is implemented the algorithm we’ve seen before in the pseudocode. In line 31, I’m getting from input file (which was in the same directory of this code) the number of tests which will be done.

From line 35 until the end of the file we’re going to:

For each test case (iTestCase), retrieve the number of pairs (nPairs) that’s going to be analyzed.
For each pair, we’re going to get the names described.
From line 40 until 50, it’s going to construct the dictionary based on the pair connection described in file.

The output tell us which test case is represents a bipartite graph or not.

...

I’m a Junior software developer in Brazil and I just fascinated by technology and programming.

So please, any doubts, hints or comments are more than welcome!

Follow me in Github, Twitter or Linkedin.

...

References

[1] https://mathworld.wolfram.com/Graph.html
[2] https://en.wikipedia.org/wiki/Graph_theory
[3] https://pt.wikipedia.org/wiki/D%C3%A9nes_K%C3%B6nig
[4] https://pt.wikipedia.org/wiki/Grafo_bipartido
[5] https://www.geeksforgeeks.org/graph-and-its-representations/

Design Patterns to a beginner developer

Iran Neto — Sat, 14 Dec 2019 19:01:56 +0000

As a beginner developer and fresh graduated boy I’ve started to look into some base concepts of programming in order to keep growing up as a professional. I realized that there are dozens of concepts that students usually take for granted and are really important in “real life”. One of them is Design Patterns.

Design Patterns

Design Patterns aren’t the silver bullet that solve all your problems. After years of programming languages been used in the world, software developers noticed that some logical solutions have been used repeatedly over and over again. In 1995, four developers published Design Patterns: Elements of Reusable Object-Oriented Software with 23 patterns solving various problems of object-oriented design and became a best-seller very quickly. Nowadays it’s known by the GoF book. GoF = Gang of Four.

That’s what make Design Patterns really important, they’re manuals of how to deal with logical problems in programming. If you’re a developer you should know and study about it because during your carrer you will face this problems every day.

Every design pattern can be described in terms of three aspects:

Intent briefly describes both the problem and the solution.
Motivation explains the problem and the solution the pattern makes possible.
Structure shows each part of the pattern and how they are related.

Patterns also can be classified into groups of intents

Creational patterns provide object creation mechanisms that increase flexibility and reuse of existing code.
Structural patterns explain how to assemble objects and classes into larger structures, while keeping the structures flexible and efficient.
Behavioral patterns take care of effective communication and the assignment of responsibilities between objects.

References:

https://refactoring.guru/

Any hints or comments are welcome, as many information and discussion better :)

DEV Community: Iran Neto