Problem:
Score : 300 points

Problem Statement

You are given three integers A, B and C. Find the minimum number of operations required to make A, B and C all equal by repeatedly performing the following two kinds of operations in any order:

Choose two among A, B and C, then increase both by 1.

Choose one among A, B and C, then increase it by 2.

It can be proved that we can always make A, B and C all equal by repeatedly performing these operations.

Constraints

0 \leq A,B,C \leq 50

All values in input are integers.

Input

Input is given from Standard Input in the following format:

A B C

Output

Print the minimum number of operations required to make A, B and C all equal.

Sample Input 1

2 5 4

Sample Output 1

2

We can make A, B and C all equal by the following operations:

Increase A and C by 1. Now, A, B, C are 3, 5, 5, respectively.

Increase A by 2. Now, A, B, C are 5, 5, 5, respectively.

Sample Input 2

2 6 3

Sample Output 2

5

Sample Input 3

31 41 5

Sample Output 3

23

Solution in C# (Mono 4.6.2.0) (judge verdict: Time Limit Exceeded)

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main(string[] args)
    {
        var array = Console.ReadLine().Split(' ').Select(x => int.Parse(x)).ToArray();
        Queue<Node> queue = new Queue<Node>();
        HashSet<int[]> checker = new HashSet<int[]>();
        queue.Enqueue(new Node(0, array));
        bool isEnd = false;
        int count = 0;
        while (!isEnd)
        {
            count++;
            var node = queue.Dequeue();
            var A = node.A;
            var B = node.B;
            var C = node.C;
            var max = Math.Max(Math.Max(A, B), C);
            var min = Math.Min(Math.Min(A, B), C);
            if (A==B && B==C)
            {
                Console.WriteLine(node.Depth);
                break;
            }
            var a1 = new int[] { A + 2, B, C };
            var a2 = new int[] { A, B + 2, C };
            var a3 = new int[] { A, B, C + 2 };
            var a4 = new int[] { A + 1, B + 1, C };
            var a5 = new int[] { A, B + 1, C + 1 };
            var a6 = new int[] { A + 1, B, C + 1 };
            if (max != A && checker.Add(a1))queue.Enqueue(new Node(node.Depth + 1, a1));
            if (max != B && checker.Add(a2)) queue.Enqueue(new Node(node.Depth + 1, a2));
            if (max != C && checker.Add(a3)) queue.Enqueue(new Node(node.Depth + 1, a3));
            if (min != C && checker.Add(a4)) queue.Enqueue(new Node(node.Depth + 1, a4));
            if (min != A && checker.Add(a5)) queue.Enqueue(new Node(node.Depth + 1, a5));
            if (min != B && checker.Add(a6)) queue.Enqueue(new Node(node.Depth + 1, a6));
        }
    }
}
public class Node
{
    public Node(int depth, int[] array)
    {
        A = array[0];
        B = array[1];
        C = array[2];
        Depth = depth;
    }
    public int A { get; set; }
    public int B { get; set; }
    public int C { get; set; }
    public int Depth { get; set; }
}