Problem:
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});

Problem I:
Sweet War

There are two countries, Imperial Cacao and Principality of Cocoa. Two girls, Alice (the Empress of Cacao) and Brianna (the Princess of Cocoa) are friends and both of them love chocolate very much.

One day, Alice found a transparent tube filled with chocolate balls (Figure I.1). The tube has only one opening at its top end. The tube is narrow, and the chocolate balls are put in a line. Chocolate balls are identified by integers 1, 2, . . ., $N$ where $N$ is the number of chocolate balls. Chocolate ball 1 is at the top and is next to the opening of the tube. Chocolate ball 2 is next to chocolate ball 1, . . ., and chocolate ball $N$ is at the bottom end of the tube. The chocolate balls can be only taken out from the opening, and therefore the chocolate balls must be taken out in the increasing order of their numbers.

Figure I.1. Transparent tube filled with chocolate balls

Alice visited Brianna to share the tube and eat the chocolate balls together. They looked at the chocolate balls carefully, and estimated that the $nutrition value$ and the $deliciousness$ of chocolate ball $i$ are $r_i$ and $s_i$, respectively. Here, each of the girls wants to maximize the sum of the deliciousness of chocolate balls that she would eat. They are sufficiently wise to resolve this
conflict peacefully, so they have decided to play a game, and eat the chocolate balls according to the rule of the game as follows:

Alice and Brianna have initial energy levels, denoted by nonnegative integers $A$ and $B$, respectively.

Alice and Brianna takes one of the following two actions in turn:

Pass: she does not eat any chocolate balls. She gets a little hungry $-$ specifically, her energy level is decreased by 1. She cannot pass when her energy level is 0.

Eat: she eats the topmost chocolate ball $-$ let this chocolate ball $i$ (that is, the chocolate ball with the smallest number at that time). Her energy level is increased by $r_i$, the nutrition value of chocolate ball $i$ (and NOT decreased by 1). Of course, chocolate ball $i$ is removed from the tube.

Alice takes her turn first.

The game ends when all chocolate balls are eaten.

You are a member of the staff serving for Empress Alice. Your task is to calculate the sums of deliciousness that each of Alice and Brianna can gain, when both of them play optimally.

Input

The input consists of a single test case. The test case is formatted as follows.

$N$ $A$ $B$

$r_1$ $s_1$

$r_2$ $s_2$

.

.

.

$r_N$ $s_N$

The first line contains three integers, $N$, $A$ and $B$. $N$ represents the number of chocolate balls. $A$ and $B$ represent the initial energy levels of Alice and Brianna, respectively. The following $N$ lines describe the chocolate balls in the tube. The chocolate balls are numbered from 1 to $N$, and each of the lines contains two integers, $r_i$ and $s_i$ for $1 \leq i \leq N$. $r_i$ and $s_i$ represent the nutrition value and the deliciousness of chocolate ball $i$, respectively. The input satisfies

$1 \leq N \leq 150$,

$0 \leq A, B, r_i \leq 10^9$,

$0 \leq s_i$, and

$\sum^N_{i=1} s_i \leq 150$

Output

Output two integers that represent the total deliciousness that Alice and Brianna can obtain when they play optimally

Sample Input 1

2 5 4
5 7
4 8

Sample Output 1

8 7

Sample Input 2

3 50 1
49 1
0 10
0 1

Sample Output 2

10 2

Sample Input 3

4 3 2
1 5
2 46
92 40
1 31

Sample Output 3

77 45

Sample Input 4

5 2 5
56 2
22 73
2 2
1 55
14 18

Sample Output 4

57 93

Solution in C# (judge verdict: Accepted)

using System;
using System.Collections.Generic;
using System.Linq;
using Debug = System.Diagnostics.Debug;
//using System.Numerics;
//using static System.Math;
using Number = System.Int64;

using C = System.Double;
using V = System.Double;

namespace Program {
    public class Solver {
        //const long MOD = (long)1e9 + 7;
        public void Solve() {
            var n = ri;
            var A = ri;
            var B = ri;
            var r = new int[n];
            var s = new int[n];
            for (int i = 0; i < n; i++) {
                r[i] = ri;
                s[i] = ri;
            }
            var rem = new int[n];
            for (int i = 0; i < n; i++)
                for (int j = i; j < n; j++)
                    rem[i] += s[j];

            var max = rem[0];
            //dp[k,i] = ?????? k ????±???? i ???????????????????????????????????¢?????????????????????????°????
            var dp = new long[n + 1, max + 1];
            for (int i = 0; i < n + 1; i++)
                for (int j = 0; j <= max; j++)
                    dp[i, j] = long.MaxValue;
            Func<int, int, long> dfs = null;
            dfs = (k, x) => {
                if (x <= 0) return -INF;
                if (k == n) return INF;
                if (dp[k, x] != long.MaxValue) return dp[k, x];
                var ret = INF;
                //pass
                ret = Math.Min(ret, Math.Max(1, 1 + dfs(k + 1, x) + r[k]));
                //eat
                ret = Math.Min(ret, -dfs(k + 1, rem[k] - x + 1) + 1 - r[k]);

                return dp[k, x] = ret;
            };
            for (int i = max; i >= 0; i--)
                if (dfs(0, i) <= A - B) {
                    Console.WriteLine("{0} {1}", i, max - i);
                    return;
                }

        }
        const long INF = 1L << 60;
        //int[] dx = { 1, 0, -1, 0 };
        //int[] dy = { 0, 1, 0, -1 };
        //*
        int ri { get { return sc.Integer(); } }
        long rl { get { return sc.Long(); } }
        double rd { get { return sc.Double(); } }
        string rs { get { return sc.Scan(); } }
        //*/

        public IO.StreamScanner sc = new IO.StreamScanner(Console.OpenStandardInput());
        static T[] Enumerate<T>(int n, Func<int, T> f) { var a = new T[n]; for (int i = 0; i < n; ++i) a[i] = f(i); return a; }
        static public void Swap<T>(ref T a, ref T b) { var tmp = a; a = b; b = tmp; }
    }
}

#region main
static class Ex {
    static public string AsString(this IEnumerable<char> ie) { return new string(ie.ToArray()); }
    static public string AsJoinedString<T>(this IEnumerable<T> ie, string st = " ") {
        return string.Join(st, ie.Select(x => x.ToString()).ToArray());
        //return string.Join(st, ie);
    }
    static public void Main() {
        Console.SetOut(new System.IO.StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false });
        var solver = new Program.Solver();
        solver.Solve();
        Console.Out.Flush();
    }
}
#endregion
#region Ex
namespace Program.IO {
    using System.Globalization;
    using System.IO;
    using System.Text;
    public class Printer: StreamWriter {
        public override IFormatProvider FormatProvider { get { return CultureInfo.InvariantCulture; } }
        public Printer(Stream stream) : base(stream, new UTF8Encoding(false, true)) { }
    }
    public class StreamScanner {
        public StreamScanner(Stream stream) { str = stream; }
        public readonly Stream str;
        private readonly byte[] buf = new byte[1024];
        private int len, ptr;
        public bool isEof = false;
        public bool IsEndOfStream { get { return isEof; } }
        private byte read() {
            if (isEof) return 0;
            if (ptr >= len) { ptr = 0; if ((len = str.Read(buf, 0, 1024)) <= 0) { isEof = true; return 0; } }
            return buf[ptr++];
        }
        public char Char() { byte b = 0; do b = read(); while ((b < 33 || 126 < b) && !isEof); return (char)b; }

        public string Scan() {
            var sb = new StringBuilder();
            for (var b = Char(); b >= 33 && b <= 126; b = (char)read())
                sb.Append(b);
            return sb.ToString();
        }
        public string ScanLine() {
            var sb = new StringBuilder();
            for (var b = Char(); b != '\n' && b != 0; b = (char)read())
                if (b != '\r') sb.Append(b);
            return sb.ToString();
        }
        public long Long() { return isEof ? long.MinValue : long.Parse(Scan()); }
        public int Integer() { return isEof ? int.MinValue : int.Parse(Scan()); }
        public double Double() { return isEof ? double.NaN : double.Parse(Scan(), CultureInfo.InvariantCulture); }
    }
}
#endregion