Algorithms

Create a recurrence function to represent the following algorithm's time complexity and use the master method to analyse the following algorithm:

/* The function f(x) is unimodal over the range [min, max] and can be evaluated in Θ(1) time
 * ε > 0 is the precision of the algorithm, typically ε is very small
 * max > min
 * n = (max - min)/ε, n > 0, where n is the problem size */
Algorithm(max, min)
{
     if ((max - min) < ε)
     {
           return (max - min)/2   // return the answer
     }


     leftThird = (2 * min + max) / 3      // represents the point which is 1/3 of the way from min to max
     rightThird = (min + 2 * max) / 3   // represents the point which is 2/3 of the way from min to max

     if (f(leftThird) < f(rightThird))
     {
           return Algorithm(leftThird, max)   // look for the answer in the interval between leftThird and max
     }
     else
     {
           return Algorithm(min, rightThird)  // look for the answer in the interval between min and rightThird
     }
}

public void AddNumber(int value, int power) // 10^3 = power1, 10^4 = power 2, 10^5 = power 3 etc.
        {
            if (power == 0)
            {
                NumberContainer[0] += value;
                while (NumberContainer[0] >= 1000)
                {
                    NumberContainer[0] -= 1000;
                    AddNumber(1, 1);
                }
            } else if(power < mPower)
            {
                NumberContainer[power] += value;
                while( NumberContainer[power] >= 10)
                {
                    NumberContainer[power] -= 10;
                    AddNumber(1, power + 1);
                }
            }else
            {
                //power too large
            }
        }

        public static NumberControl operator +(NumberControl c1, NumberControl c2)
        {
            //set new maxpower to largest of the two
            int mMaxp = c1.mPower;
            if (c2.mPower > mMaxp) mMaxp = c2.mPower;

            NumberControl nc = new NumberControl(mMaxp);

            for(int i = 0;i < c1.NumberContainer.Count;i++)
            {
                nc.AddNumber(c1.NumberContainer[i], i);
            }

            for (int i = 0; i < c2.NumberContainer.Count; i++)
            {
                nc.AddNumber(c2.NumberContainer[i], i);
            }

            return nc;
        }

Given k sets of integers A1,A2,..,Ak of total size O(n), you should determine whether exist a1A1, a2A2,...,akAk, such that a1+a2+..+ak-1 =ak. Your algorithm should run in Tk(n) time, where Tk(n) = O(n^(k/2)*log n) for even k, and O(n^((k+1)/2)) for odd values of k.