import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.TreeMap;

/**
 * Built using CHelper plug-in Actual solution is at the top
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		MyInput in = new MyInput(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		CLexicographicConstraints solver = new CLexicographicConstraints();
		solver.solve(1, in, out);
		out.close();
	}

	static class CLexicographicConstraints {
		int n;
		int[] a;
		TreeMap<Integer, Integer> map;

		public void solve(int testNumber, MyInput in, PrintWriter out) {

			n = in.nextInt();
			a = in.nextIntArray(n);

			map = new TreeMap<>();
			int l = 0, r = n;
			while (r - l > 1) {
				int m = (r + l) / 2;
				if (check(m)) {
					r = m;
				} else {
					l = m;
				}
			}

			out.println(r);
		}

		boolean check(int k) {
			map.clear();

			int now = 0;
			for (int i : a) {
				if (i > now) {
					now = i;
				} else {
					if (k == 1) return false;
					while (!map.isEmpty() && map.lastKey() >= i) {
						map.pollLastEntry();
					}
					int p = i-1;
					while (true) {
						if (p < 0) return false;
						int str = map.containsKey(p) ? map.get(p) : 0;
						str++;
						map.put(p, str);
						if (str == k) {
							map.remove(p);
							p--;
						} else {
							break;
						}
					}
				}
				now = i;
			}
			return true;
		}

	}

	static class MyInput {
		private final BufferedReader in;
		private static int pos;
		private static int readLen;
		private static final char[] buffer = new char[1024 * 8];
		private static char[] str = new char[500 * 8 * 2];
		private static boolean[] isDigit = new boolean[256];
		private static boolean[] isSpace = new boolean[256];
		private static boolean[] isLineSep = new boolean[256];

		static {
			for (int i = 0; i < 10; i++) {
				isDigit['0' + i] = true;
			}
			isDigit['-'] = true;
			isSpace[' '] = isSpace['\r'] = isSpace['\n'] = isSpace['\t'] = true;
			isLineSep['\r'] = isLineSep['\n'] = true;
		}

		public MyInput(InputStream is) {
			in = new BufferedReader(new InputStreamReader(is));
		}

		public int read() {
			if (pos >= readLen) {
				pos = 0;
				try {
					readLen = in.read(buffer);
				} catch (IOException e) {
					throw new RuntimeException();
				}
				if (readLen <= 0) {
					throw new MyInput.EndOfFileRuntimeException();
				}
			}
			return buffer[pos++];
		}

		public int nextInt() {
			int len = 0;
			str[len++] = nextChar();
			len = reads(len, isSpace);
			int i = 0;
			int ret = 0;
			if (str[0] == '-') {
				i = 1;
			}
			for (; i < len; i++)
				ret = ret * 10 + str[i] - '0';
			if (str[0] == '-') {
				ret = -ret;
			}
			return ret;
		}

		public char nextChar() {
			while (true) {
				final int c = read();
				if (!isSpace[c]) {
					return (char) c;
				}
			}
		}

		int reads(int len, boolean[] accept) {
			try {
				while (true) {
					final int c = read();
					if (accept[c]) {
						break;
					}
					if (str.length == len) {
						char[] rep = new char[str.length * 3 / 2];
						System.arraycopy(str, 0, rep, 0, str.length);
						str = rep;
					}
					str[len++] = (char) c;
				}
			} catch (MyInput.EndOfFileRuntimeException e) {
			}
			return len;
		}

		public int[] nextIntArray(final int n) {
			final int[] res = new int[n];
			for (int i = 0; i < n; i++) {
				res[i] = nextInt();
			}
			return res;
		}

		public int[] nextIntArrayDec(final int n) {
			final int[] res = new int[n];
			for (int i = 0; i < n; i++) {
				res[i] = nextInt() - 1;
			}
			return res;
		}

		static class EndOfFileRuntimeException extends RuntimeException {
		}

	}
}


Measured memory_bytes: 91724