/**
 * Intended solution building the tree in O(n) with a stack
 */

#include <iostream>
#include <stack>
#include <vector>

using namespace std;

typedef struct Node {
	Node() : parent(nullptr), left(nullptr), right(nullptr) {}

	Node *parent;
	Node *left;
	Node *right;
	long long level;
	long long worth;
	long long req_lvl;
} Node;

static void build_heap(vector<Node> &nodes)
{
	stack<Node *> st;
	for(auto it = nodes.begin(), end_it = nodes.end(); it != end_it; ++it){
		while(!st.empty() && st.top()->level < it->level)
			st.pop();

		if(!st.empty()) {
			// potentially overwrite right child; only happens for smth like 5 3 4
			// we fix that in 2nd iteration
			st.top()->right = &*it;
			it->parent = st.top();
		}

		st.push(&*it);
	}

	st = stack<Node *>();

	for(auto it = nodes.rbegin(), end_it = nodes.rend(); it != end_it; ++it){
		// We don't want two nodes with the same level having each other as parent
		// => this time less equal
		while(!st.empty() && st.top()->level <= it->level)
			st.pop();

		if(!st.empty()) {
			if(!it->parent || it->parent->level >= st.top()->level) {
				// update parent and fix overwrite from 1st iteration
				st.top()->left = &*it;
				it->parent = st.top();
			}
		}

		st.push(&*it);
	}
}

static void fill(Node &node) {
	node.worth = node.level;
	node.req_lvl = node.level;

	if(node.left) {
		fill(*node.left);
		node.worth += node.left->worth;
		node.req_lvl = min(node.req_lvl, max(node.left->req_lvl,
					node.level - node.left->worth));
	}

	if(node.right) {
		fill(*node.right);
		node.worth += node.right->worth;
		node.req_lvl = min(node.req_lvl, max(node.right->req_lvl,
					node.level - node.right->worth));
	}
}

int main() {
	size_t n;
	cin >> n;
	vector<Node> nodes(n);
	vector<long long> levels(n);
	long long highest_level = 0;
	size_t highest_level_index = 0;
	for(size_t i = 0; i < n; ++i) {
		long long level;
		cin >> level;
		levels[i] = level;
		if(level > highest_level) {
			highest_level_index = i;
			highest_level = level;
		}
	}

	size_t i = highest_level_index;
	for(Node &node : nodes) {
		node.level = levels[i];
		i = (i + 1) % n;
	}

	build_heap(nodes);

	Node *root = nullptr;
	for(Node &node : nodes) {
		if(!node.parent)
			root = &node;
	}

	fill(*root);

	cout << root->req_lvl << endl;

	return 0;
}