Solution Notes: This problem is solved by dynamic programming. Let good[n][B_2][B_3] be "true" if one can reach a state using only bales 1..n in which B_2 and B_3 denote the total amount of hay in barns 2 and 3 (just as in the problem statement). Note that we don't need to include B_1 in our state space, since B_1 is determined by knowing n, B_2, and B_3: B_1 is the total size of bales 1..n minus B_2 minus B_3. We now fill in the table of all good[][][] values, and the solution is obtained by looking at good[N][][] for the "true" entry with the smallest value of max(B_1,B_2,B_3). To make the algorithm as memory-efficient as possible, we note that we only need to store two "levels" of the table (for n and n-1) at a time. Furthermore, we know that the optimal solution is at most the sum of all bale sizes divided by 3, so we can upper bound the optimal solution by at most 700, limiting the maximum necessary size of dimensions 2 and 3 in our state space to 700 and speeding up the running time considerably.

#include <iostream>
#include <fstream>

using namespace std;
const int MAXS = 700;

ifstream fin ("baleshare.in");
ofstream fout ("baleshare.out");

int n, bale, tsum;
bool good[2][MAXS+100][MAXS+100];

int main()
{
    for (int i = 0; i < 2; i++)
        for (int j = 0; j < MAXS; j++)
            for (int k = 0; k < MAXS; k++)
                good[i][j][k] = false;
    good[0][0][0] = true;
    tsum = 0;
    
    fin >> n;
    for (int i = 0; i < n; i++)
    {
        fin >> bale;
        tsum += bale;
        for (int j = 0; j < MAXS; j++)
            for (int k = 0; k < MAXS; k++)
            {
                if (good[i%2][j][k])
                {
                    good[(i+1)%2][j][k] = true;
                    good[(i+1)%2][j+bale][k] = true;
                    good[(i+1)%2][j][k+bale] = true;
                }
            }
    }
    
    int ans = MAXS;
    for (int i = 0; i < MAXS; i++)
        for (int j = 0; j < MAXS; j++)
            if (good[n%2][i][j])
                ans = min (ans, max (i, max (j, tsum - (i + j))));
    fout << ans << "\n";
    return 0;
}