Problem:
Score : 1000 points

Problem Statement

There are N barbecue restaurants along a street.
The restaurants are numbered 1 through N from west to east, and the distance between restaurant i and restaurant i+1 is A_i.

Joisino has M tickets, numbered 1 through M.
Every barbecue restaurant offers barbecue meals in exchange for these tickets.
Restaurant i offers a meal of deliciousness B_{i,j} in exchange for ticket j.
Each ticket can only be used once, but any number of tickets can be used at a restaurant.

Joisino wants to have M barbecue meals by starting from a restaurant of her choice, then repeatedly traveling to another barbecue restaurant and using unused tickets at the restaurant at her current location.
Her eventual happiness is calculated by the following formula: "(The total deliciousness of the meals eaten) - (The total distance traveled)".
Find her maximum possible eventual happiness.

Constraints

All input values are integers.

2≤N≤5×10^3

1≤M≤200

1≤A_i≤10^9

1≤B_{i,j}≤10^9

Input

The input is given from Standard Input in the following format:

N M
A_1 A_2 ... A_{N-1}
B_{1,1} B_{1,2} ... B_{1,M}
B_{2,1} B_{2,2} ... B_{2,M}
:
B_{N,1} B_{N,2} ... B_{N,M}

Output

Print Joisino's maximum possible eventual happiness.

Sample Input 1

3 4
1 4
2 2 5 1
1 3 3 2
2 2 5 1

Sample Output 1

11

The eventual happiness can be maximized by the following strategy: start from restaurant 1 and use tickets 1 and 3, then move to restaurant 2 and use tickets 2 and 4.

Sample Input 2

5 3
1 2 3 4
10 1 1
1 1 1
1 10 1
1 1 1
1 1 10

Sample Output 2

20

Solution in Java8 (OpenJDK 1.8.0) (judge verdict: Time Limit Exceeded)

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.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Stack;
import java.util.StringTokenizer;

public class Main {

	static class TaskF {

		public void solve(int testNumber, InputReader in, PrintWriter out) {
			int N = in.nextInt();
			int M = in.nextInt();
			long[] A = new long[N];
			for (int i = 1; i < N; ++i) {
				A[i] = in.nextInt();
			}
			int[][] B = new int[M][N];// (4*N)*(4*M)<=40KB*800B=32MB
			for (int i = 0; i < N; ++i) {
				for (int j = 0; j < M; ++j) {
					B[j][i] = in.nextInt();
				}
			}

			int[][] a = new int[N][2];// 4*2*N<=80KB
			int[] mate = new int[N];// 4*N<=40KB
			boolean[] vis = new boolean[N];// 4*N<=40KB

			ArrayList<int[]>[] pq = new ArrayList[N + 1];
			for (int i = 0; i < pq.length; ++i) {
				pq[i] = new ArrayList<>(100);
			}
			for (int i = 0; i < M; ++i) {
				for (int j = 0; j < N; ++j) {
					a[j][0] = j;
					a[j][1] = B[i][j];
				}
				B[i] = null;
				Arrays.sort(a, new Comparator<int[]>() {
					@Override
					public int compare(int[] o1, int[] o2) {
						return Integer.compare(o1[1], o2[1]);
					}
				});
				Arrays.fill(vis, false);
				for (int j = 0; j < N; ++j) {
					mate[j] = j;
				}
				for (int j = 0; j < N; ++j) {
					int idx = a[j][0];
					int l = idx, r = idx;
					if (idx > 0 && vis[idx - 1]) {
						l = mate[idx - 1];
					}
					if (idx + 1 < N && vis[idx + 1]) {
						r = mate[idx + 1];
					}
					pq[l].add(new int[] { idx, a[j][1] });
					pq[idx + 1].add(new int[] { r + 1, a[j][1] });
					pq[l].add(new int[] { r + 1, -a[j][1] });
					pq[idx + 1].add(new int[] { idx, -a[j][1] });
					vis[idx] = true;
					if (idx > 0 && idx + 1 < N && vis[idx - 1] && vis[idx + 1]) {
						mate[l] = r;
						mate[r] = l;
					} else if (idx > 0 && vis[idx - 1]) {
						mate[l] = idx;
						mate[idx] = l;
					} else if (idx + 1 < N && vis[idx + 1]) {
						mate[r] = idx;
						mate[idx] = r;
					}
				}
			}
			long[] sum = new long[N];
			for (int i = 0; i < N; ++i) {
				if (i > 0)
					A[i] += A[i - 1];
			}
			long best = 0;
			long[] lazy = new long[N + 1];
			for (int i = 0; i < N; ++i) {
				Arrays.fill(lazy, 0);
				for (int[] q : pq[i]) {
					lazy[q[0]] += q[1];
				}
				for (int j = i; j < N; ++j) {
					if (j > 0)
						lazy[j] += lazy[j - 1];
					sum[j] += lazy[j];
					best = Math.max(best, sum[j] - (A[j] - A[i]));
				}
			}
			out.println(best);
		}
	}

	static void tr(Object... objects) {
		System.out.println(Arrays.deepToString(objects));
	}

	InputStream is;
	PrintWriter out;
	String INPUT = "";

	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskF solver = new TaskF();
		solver.solve(1, in, out);
		out.close();
	}

	static class InputReader {
		public BufferedReader reader;
		public StringTokenizer tokenizer;

		public InputReader(InputStream stream) {
			reader = new BufferedReader(new InputStreamReader(stream), 32768);
			tokenizer = null;
		}

		public String next() {
			while (tokenizer == null || !tokenizer.hasMoreTokens()) {
				try {
					tokenizer = new StringTokenizer(reader.readLine());
				} catch (IOException e) {
					throw new RuntimeException(e);
				}
			}
			return tokenizer.nextToken();
		}

		public int nextInt() {
			return Integer.parseInt(next());
		}

	}

}