Problem:
Problem I: Beautiful Spacing

Text is a sequence of words, and a word consists of characters. Your task is to put words into a grid with W columns and sufficiently many lines. For the beauty of the layout, the following conditions have to be satisfied.

The words in the text must be placed keeping their original order. The following figures show correct and incorrect layout examples for a 4 word text "This is a pen" into 11 columns.

Figure I.1: A good layout.

Figure I.2: BAD | Do not reorder words.

Between two words adjacent in the same line, you must place at least one space character. You sometimes have to put more than one space in order to meet other conditions.

Figure I.3: BAD | Words must be separated by spaces.

A word must occupy the same number of consecutive columns as the number of characters in it. You cannot break a single word into two or more by breaking it into lines or by inserting spaces.

Figure I.4: BAD | Characters in a single word must be contiguous.

The text must be justified to the both sides. That is, the first word of a line must startfrom the first column of the line, and except the last line, the last word of a line must end at the last column.

Figure I.5: BAD | Lines must be justi ed to both the left and the right sides.

The text is the most beautifully laid out when there is no unnecessarily long spaces. For instance, the layout in Figure I.6 has at most 2 contiguous spaces, which is more beautiful than that in Figure I.1, having 3 contiguous spaces. Given an input text and the number of columns, please find a layout such that the length of the longest contiguous spaces between words is minimum.

Figure I.6: A good and the most beautiful layout.

Input

The input consists of multiple datasets, each in the following format.

    W N

    x1 x2 ... xN

W, N, and xi are all integers. W is the number of columns (3 ≤ W ≤ 80,000). N is the number of words (2 ≤ N ≤ 50,000). xi is the number of characters in the i-th word (1 ≤ xi ≤ (W−1)/2 ). Note that the upper bound on xi assures that there always exists a layout satisfying the conditions.

The last dataset is followed by a line containing two zeros.

Output

For each dataset, print the smallest possible number of the longest contiguous spaces between words.

Sample Input

11 4
4 2 1 3
5 7
1 1 1 2 2 1 2
11 7
3 1 3 1 3 3 4
100 3
30 30 39
30 3
2 5 3
0 0

Output for the Sample Input

2
1
2
40
1

Solution in C++ (judge verdict: Accepted)

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <climits>
#include <cfloat>
#include <ctime>
#include <cassert>
#include <map>
#include <utility>
#include <set>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <sstream>
#include <complex>
#include <stack>
#include <queue>
#include <numeric>
#include <list>
#include <iomanip>
#include <fstream>
#include <bitset>
   
using namespace std;
   
 
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define foreach(it, c) for (__typeof__((c).begin()) it=(c).begin(); it != (c).end(); ++it)
#define rforeach(it, c) for (__typeof__((c).rbegin()) it=(c).rbegin(); it != (c).rend(); ++it)
#define all(c) (c).begin(), (c).end()
#define rall(c) (c).rbegin(), (c).rend()
#define CL(arr, val) memset(arr, val, sizeof(arr))
#define COPY(dest, src) memcpy(dest, src, sizeof(dest))
#define ten(n) ((long long)(1e##n))
#define bin(n) (1LL << (n))
#define erep(i, n) for (int i = 0; i <= (int)(n); ++i)
#define revrep(i, n) for (int i = (n); i >= 0; --i)
#define pb push_back

template <class T> void chmax(T& a, const T& b) { a = max(a, b); }
template <class T> void chmin(T& a, const T& b) { a = min(a, b); }
 
template <class T> void uniq(vector<T>& c) { sort(c.begin(), c.end()); c.erase(unique(c.begin(), c.end()), c.end()); }
 
template <class T> string to_s(const T& a) { ostringstream os; os << a; return os.str(); }
template <class T> T to_T(const string& s) { istringstream is(s); T res; is >> res; return res; }
  
template <class T, class U> ostream& operator<<(ostream& os, pair<T, U>& p) { os << "( " << p.first << ", " << p.second << " )"; return os; }
  
template <class T> void print(T a, int n, const string& deli = " ", int br = 1) { for (int i = 0; i < n; ++i) { cout << a[i]; if (i + 1 != n) cout << deli; } while (br--) cout << endl; }
template <class T> void print(const T& c, const string& deli = " ", int br = 1) { foreach (it, c) { cout << *it; if (++it != c.end()) cout << deli;--it; } while (br--) cout << endl; }
template <class T> void print2d(T a, int w, int h, int width = -1, int br = 1) { for (int i = 0; i < h; ++i) { for (int j = 0; j < w; ++j) {    if (width != -1) cout.width(width); cout << a[i][j] << ' '; } cout << endl; } while (br--) cout << endl; }
   
template <class T> void input(T& a, int n) { for (int i = 0; i < n; ++i) cin >> a[i]; }
template <class T> void input(T* a, int n) { for (int i = 0; i < n; ++i) cin >> a[i]; }

void fix_pre(int n) { cout.setf(ios::fixed, ios::floatfield); cout.precision(10); }
void fast_io() { cin.tie(0); ios::sync_with_stdio(false); }
#define trace(x) (cout << #x << ": " << (x) << endl)
 
bool in_rect(int x, int y, int w, int h) { return 0 <= x && x < w && 0 <= y && y < h; }
 

typedef long long ll;
typedef pair<int, int> pint;
 
// y(v): v>^<  y(^): ^>v<
const int dx[] = { 0, 1, 0, -1 };
const int dy[] = { 1, 0, -1, 0 };

const double PI = acos(-1.0);

#define F first
#define S second



const int M = 5 * ten(4) + 100;
const int inf = ten(8);

int w, n, x[M];
int sum_x[M];

// [i, j]
bool can_place_in_line(int i, int j)
{
    int rem_space = w - (sum_x[j + 1] - sum_x[i]);
    int num_interval = j - i;
    return num_interval > 0 && rem_space >= num_interval;
}
// [i, j]
int max_space(int i, int j)
{
    int rem_space = w - (sum_x[j + 1] - sum_x[i]);
    int num_interval = j - i;
    if (num_interval > 0 && rem_space >= num_interval)
        return (rem_space + (num_interval - 1)) / num_interval;
    else
        return inf;
}
bool can_place_in_last(int i)
{
    int rem_space = w - (sum_x[n] - sum_x[i]);
    int num_interval = n - i - 1;
    return rem_space >= num_interval;
}
bool check(int upper_space)
{
    int dp[M]; // can place i in beginning if sum_x[i=0..i](dp[i]) > 0
    fill_n(dp, n + 1, 0);
    dp[0] = 1;
    dp[1] = -1;

    int left = 0, right = 0;
    rep(i, n)
    {
        if (dp[i] > 0)
        {
            // can place [i..j](j = [left..right)) in one line
            chmax(left, i + 1);
            while (left < n && can_place_in_line(i, left) && max_space(i, left) > upper_space)
                ++left;

            chmax(right, left + 1);
            while (right < n && can_place_in_line(i, right) && max_space(i, right) <= upper_space)
                ++right;

            if (max_space(i, left) <= upper_space)
            {
                ++dp[left + 1];
                --dp[right + 1];
            }
        }

        dp[i + 1] += dp[i];
    }

    rep(i, n)
        if (dp[i] && can_place_in_last(i))
            return true;
    return false;
}
int main()
{
    while (scanf("%d%d", &w, &n), n)
    {
        rep(i, n)
            scanf("%d", x + i);

        sum_x[0] = 0;
        rep(i, n)
            sum_x[i + 1] = sum_x[i] + x[i];

        int low = 0, high = w - 2;
        while (high - low > 1)
        {
            int mid = (low + high) / 2;
            if (check(mid))
                high = mid;
            else
                low = mid;
        }
        printf("%d\n", high);
    }
}