Hi!

I was teacher of some online courses for students preparing themselves for IOI. I recorded my course sessions in some video files and they can be useful for Iranian (or who knows Persian) high school and also university students.

If anybody wants the videos contact me here or my Gmail with address [email protected] or telegram id @kerpoo .

The first course was about introduction to programming with C++ and the content of the course was:

1. Introduction to the general programming tools with c++ syntax (Variables, Arrays, Conditions, Loops, Functions & ...)

2. Recursive functions

3. Time and memory complexity

4. Sort algorithms and implementation of Merge-sort

5. Algorithms about Prime numbers and Eratosthenes sieve

6. Introduction to big numbers and their algorithms

7. Introduction to binary search trees (BST)

8. Working with files by fstream library

9. Introduction to important libraries and structures for competitive programming (Pair, Vector, Sort function and custom sort, Next_permutation function, String, Set, Map, Struct & ...)

10. Solving and implementing some projecteuler.net problems.

After this course you will be able to accept about 25 problems of projecteuler.net and a lot of programming exercises.

The second course was about introduction to algorithms and data structures and the content of the course was:

• Dynamic programming:

1. Simple dp and memorization

2. Interval dp

3. Bitmasks and subset dp

4. Dp on trees

• Greedy algorithms

• Divide and conquer method

• Brute force with bitmasks

• Binary search

• Graph algorithms:

1. Bfs and shortest path

2. Dfs

3. Floyed warshal

4. Dijkstra

5. Prim (MST)

6. Kruscal (MST)

7. Eulerian tour (Fleury)

8. Topological sort

9. Strongly connected components (SCC)

10. Directed acyclic graphs (DAG)

11. 2-sat

12. Cut vertices

13. Cut edges

• Data structures:

1. Disjoint sets union (DSU)

2. Segment tree

3. Lazy segment tree

4. Fenwick tree (BIT)

5. Red black tree

6. Mo’s algorithm

7. working with offline queries

8. Lowest common ancestor (LCA)

9. Sparse table

• Modular inverses and combinatorics problems

All the above algorithms are introduced and implemented by C++ and also There are a lot of problems from various online judges about each of them as exercises.

There is also a course in graph theory topic (that is completely theory).

Hi everyone! Saba programming contest 3 is coming...

The contest will be held on April 18th at Shahid Bahonar University of Kerman (IRAN).

The contest is on-site for Iranian programmers!

The contest website

telegram channel of the contest

The contest will have 9 problems and 3 hours to solve them!

Also we have good news, this year the contest will be also held online as April Circuit'19 in 9 days for international participants and there will be prizes too , it will be held on Hackerearth website on April 19th.

online contest page

To make the challenge more interesting, problems added to the contest in this order:

• Day 0: Very-Easy, Easy, Approximation.
• Day 1: Easy-Medium, Medium.
• Day 4: Medium, Medium-Hard.
• Day 6: Medium-Hard.
• Day 9: Challenge ends.

As usual, there will be some nice prizes for the top five competitors:

• First place: $100 Amazon gift card + HE t-shirt.
• Second place: $75 Amazon gift card + HE t-shirt.
• Third place: $50 Amazon gift card + HE t-shirrt.
• Fourth place: HE t-shirt.
• Fifth place: HE t-shirt.

The online and on-site contests have 7 common problems that all of them have been prepared by me, ManiSadati, mohammadsh, Danial Mohammadi, Dalgerok (Approximation problem) and tested by Danial Erfanian.

Saba invites you to participate at the on-site contest if you’re from IRAN and to participate the online contest if you’re an international participant.

We’ve spent a lot time to design good problems for the participants , saba and hackerearth hope to see as many as possible contestants at both contests!

We are hoping to hold the contest on a global scale for the next year!

Saba programming contest team thanks Dalgerok for preparing Approximation problem and Danial for his valuable work with the problem testing and special thanks to Hackerearth for hosting our contest and their help!

P.S: The online contest start time has been changed from April 19'th to April 26'th!

I love this implementation of Edmond's Blossoms :-)

Edmond's Blossoms algorithm give a maximum matching in general graphs (non-bipartite)

/*
GETS:
V->number of vertices
E->number of edges
pair of vertices as edges (vertices are 1..V)

GIVES:
output of edmonds() is the maximum matching
match[i] is matched pair of i (-1 if there isn't a matched pair)
 */

#include <bits/stdc++.h>
using namespace std;
const int M=500;
struct struct_edge{int v;struct_edge* n;};
typedef struct_edge* edge;
struct_edge pool[M*M*2];
edge top=pool,adj[M];
int V,E,match[M],qh,qt,q[M],father[M],base[M];
bool inq[M],inb[M],ed[M][M];
void add_edge(int u,int v)
{
  top->v=v,top->n=adj[u],adj[u]=top++;
  top->v=u,top->n=adj[v],adj[v]=top++;
}
int LCA(int root,int u,int v)
{
  static bool inp[M];
  memset(inp,0,sizeof(inp));
  while(1)
    {
      inp[u=base[u]]=true;
      if (u==root) break;
      u=father[match[u]];
    }
  while(1)
    {
      if (inp[v=base[v]]) return v;
      else v=father[match[v]];
    }
}
void mark_blossom(int lca,int u)
{
  while (base[u]!=lca)
    {
      int v=match[u];
      inb[base[u]]=inb[base[v]]=true;
      u=father[v];
      if (base[u]!=lca) father[u]=v;
    }
}
void blossom_contraction(int s,int u,int v)
{
  int lca=LCA(s,u,v);
  memset(inb,0,sizeof(inb));
  mark_blossom(lca,u);
  mark_blossom(lca,v);
  if (base[u]!=lca)
    father[u]=v;
  if (base[v]!=lca)
    father[v]=u;
  for (int u=0;u<V;u++)
    if (inb[base[u]])
      {
	base[u]=lca;
	if (!inq[u])
	  inq[q[++qt]=u]=true;
      }
}
int find_augmenting_path(int s)
{
  memset(inq,0,sizeof(inq));
  memset(father,-1,sizeof(father));
  for (int i=0;i<V;i++) base[i]=i;
  inq[q[qh=qt=0]=s]=true;
  while (qh<=qt)
    {
      int u=q[qh++];
      for (edge e=adj[u];e;e=e->n)
        {
	  int v=e->v;
	  if (base[u]!=base[v]&&match[u]!=v)
	    if ((v==s)||(match[v]!=-1 && father[match[v]]!=-1))
	      blossom_contraction(s,u,v);
	    else if (father[v]==-1)
	      {
		father[v]=u;
		if (match[v]==-1)
		  return v;
		else if (!inq[match[v]])
		  inq[q[++qt]=match[v]]=true;
	      }
        }
    }
  return -1;
}
int augment_path(int s,int t)
{
  int u=t,v,w;
  while (u!=-1)
    {
      v=father[u];
      w=match[v];
      match[v]=u;
      match[u]=v;
      u=w;
    }
  return t!=-1;
}
int edmonds()
{
  int matchc=0;
  memset(match,-1,sizeof(match));
  for (int u=0;u<V;u++)
    if (match[u]==-1)
      matchc+=augment_path(u,find_augmenting_path(u));
  return matchc;
}
int main()
{
  int u,v;
  cin>>V>>E;
  while(E--)
    {
      cin>>u>>v;
      if (!ed[u-1][v-1])
	{
	  add_edge(u-1,v-1);
	  ed[u-1][v-1]=ed[v-1][u-1]=true;
	}
    }
  cout<<edmonds()<<endl;
  for (int i=0;i<V;i++)
    if (i<match[i])
      cout<<i+1<<" "<<match[i]+1<<endl;
}

thanks a lot to boleyn.su