Submission #62302

---

Source Code Expand

import java.io.*;
import java.math.BigInteger;
import java.util.*;



public class Main {
	private static final int mod = (int)1e9+7;

	//	static final int[] positive;
	void imosHexagon(final long[][] v, final int x, int y, int r, int val) {
		v[y-r+2][x] -= val;
		v[y-r+2][x+r-1] += val;

		v[y-r+1][x+r] -= val;
		v[y-r+1][x] += val;

		v[y+1][x+r-1] -= val;
		v[y+1][x+r] += val;


		v[y+1][x-r] -= val;
		v[y+1][x-r+1] += val;

		v[y+r+1][x-r] += val;
		v[y+r][x-r+1] -= val;

		v[y+r+1][x] -= val;
		v[y+r][x] += val;
	}

	void runImosHexagon(final long[][] v) {
		// 右
		for(int y = 0; y < v.length; y++) {
			for(int x = 1; x < v[y].length; x++) {
				v[y][x] += v[y][x-1];
			}
		}

		// 右上
		for(int x = 0; x < v[0].length; x++) {
			for(int y = 1; y < v.length; y++) {
				v[y][x] += v[y-1][x];
			}
		}
		
		// 左上
		for(int x_ = 0; x_ < v[0].length; x_++) {
			for(int y = 1, x = x_ - 1; 0 <= x && y < v.length; y++, x--) {
				v[y][x] += v[y-1][x+1];
			}
		}
		for(int y_ = 1; y_ < v.length - 1; y_++) {
			for(int y = y_ + 1, x = v[0].length - 2; 0 <= x && y < v.length; y++, x--) {
				v[y][x] += v[y-1][x+1];
			}
		}
	}
	
	void runTestImos() {
		final long[][] val = new long[10][10];
		imosHexagon(val, 5, 5, 1, 1);
		runImosHexagon(val);
		for(int y = val.length - 1; y >= 0; y--) {
			for(int x = 0; x < val[y].length; x++) {
				IOFast.out.printf("%02d ", val[y][x]);
			}
			IOFast.out.println();
		}
	}

	public void run() throws IOException {
//		runTestImos();
//		if(true) return;
		
		final int n = IOFast.nextInt();
		final long[][] val = new long[2011][2011];
		final int base = val.length / 2;
		
		for(int i = 0; i < n; i++) {
			final int t = IOFast.nextInt();
			final int x = IOFast.nextInt() + base;
			final int y = IOFast.nextInt() + base;
			final int s = IOFast.nextInt();

			if(t == 1) {
				imosHexagon(val, x, y, s, 1);
			}
			else if(t == 2) {
				for(int j = 1; j <= s; j++) {
					imosHexagon(val, x, y, j, 1);
				}
			}
			else {
				for(int j = s, k = 1; j >= 1; j--, k += 2) {
					imosHexagon(val, x, y, j, k);
				}
			}
		}
		
		runImosHexagon(val);
		long res = 0;
		for(int y = 0; y < val.length; y++) {
			for(int x = 0; x < val[y].length; x++) {
				res = Math.max(val[y][x], res);
			}
		}
		IOFast.out.println(res);
	}

	public static void main(String[] args) throws IOException {
		//		IOFast.setFileIO("rle-size.in", "rle-size.out");
		new Main().run();
		IOFast.out.flush();
	}



	static public class IOFast {
		private static BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		private static PrintWriter out = new PrintWriter(System.out);

		static void setFileIO(String ins, String outs) throws IOException {
			try {
				in = new BufferedReader(new FileReader(ins));
				out = new PrintWriter(new FileWriter(outs));
			}
			catch(IOException e) {
				System.err.println(e);
				throw e;
			}
		}

		//		private static final int BUFFER_SIZE = 50 * 200000;
		private static int pos, readLen;
		private static final char[] buffer = new char[1024 * 8];
		private static final StringBuilder buf = new StringBuilder();
		private static boolean[] isDigit = new boolean[256];
		private static boolean[] isSpace = 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;
		}

		static boolean endInput;

		private static int read() throws IOException {
			if(readLen == -1) {
				return -1;
			}

			if(pos >= readLen) {
				readLen = in.read(buffer);
				pos = 0;

				if(readLen <= 0) {
					return -1;
				}
			}

			return buffer[pos++];
		}

		private static int nextInt() throws IOException {
			boolean plus = false;
			int ret = 0;
			while(true) {
				final int c = read();

				if(c == -1) {
					endInput = true;
					return Integer.MIN_VALUE;
				}

				if(isDigit[c]) {
					if(c != '-') {
						plus = true;
						ret = c - '0';
					}
					break;
				}
			}

			while(true) {
				final int c = read();
				if(c == -1 || !isDigit[c]) {
					break;
				}
				ret = ret * 10 + c - '0';
			}

			return plus ? ret : -ret;
		}

		private static long nextLong() throws IOException {
			boolean plus = false;
			long ret = 0;
			while(true) {
				final int c = read();

				if(c == -1) {
					endInput = true;
					return Integer.MIN_VALUE;
				}

				if(isDigit[c]) {
					if(c != '-') {
						plus = true;
						ret = c - '0';
					}
					break;
				}
			}

			while(true) {
				final int c = read();
				if(c == -1 || !isDigit[c]) {
					break;
				}
				ret = ret * 10 + c - '0';
			}

			return plus ? ret : -ret;
		}

		private static char nextChar() throws IOException {
			while(true) {
				final int c = read();

				if(c == -1) {
					endInput = true;
					return '\0';
				}

				if(!isSpace[c]) {
					return (char)c;
				}
			}
		}

		private static String next() throws IOException {
			buf.setLength(0);

			while(true) {
				final int c = read();

				if(c == -1) {
					endInput = true;
					return "-1";
				}

				if(!isSpace[c]) {
					buf.append((char)c);
					break;
				}
			}

			while(true) {
				final int c = read();

				if(c == -1 || isSpace[c]) {
					break;
				}
				buf.append((char)c);
			}

			return buf.toString();
		}

		private static double nextDouble() throws IOException {
			return Double.parseDouble(next());
		}

	}

}

Submission Info

Judge Result