algorithm-class/大厂刷题班/class39/Code04_JumpGameOnMatrix.java

package class39;

// 来自京东
// 给定一个二维数组matrix，matrix[i][j] = k代表:
// 从(i,j)位置可以随意往右跳<=k步，或者从(i,j)位置可以随意往下跳<=k步
// 如果matrix[i][j] = 0，代表来到(i,j)位置必须停止
// 返回从matrix左上角到右下角，至少要跳几次
// 已知matrix中行数n <= 5000, 列数m <= 5000
// matrix中的值，<= 5000
// 最弟弟的技巧也过了。最优解 -> dp+枚举优化(线段树，体系学习班)
public class Code04_JumpGameOnMatrix {

	// 暴力方法，仅仅是做对数器
	// 如果无法到达会返回系统最大值
	public static int jump1(int[][] map) {
		return process(map, 0, 0);
	}

	// 当前来到的位置是(row,col)
	// 目标：右下角
	// 当前最大能跳多远，map[row][col]值决定，只能向右、或者向下
	// 返回，到达右下角，最小跳几次？
	// 5000 * 5000 = 25000000 -> 2 * (10 ^ 7)
	public static int process(int[][] map, int row, int col) {
		if (row == map.length - 1 && col == map[0].length - 1) {
			return 0;
		}
		// 如果没到右下角
		if (map[row][col] == 0) {
			return Integer.MAX_VALUE;
		}
		// 当前位置，可以去很多的位置，next含义：
		// 在所有能去的位置里，哪个位置最后到达右下角，跳的次数最少，就是next
		int next = Integer.MAX_VALUE;
		// 往下能到达的位置，全试一遍
		for (int down = row + 1; down < map.length && (down - row) <= map[row][col]; down++) {
			next = Math.min(next, process(map, down, col));
		}
		// 往右能到达的位置，全试一遍
		for (int right = col + 1; right < map[0].length && (right - col) <= map[row][col]; right++) {
			next = Math.min(next, process(map, row, right));
		}
		// 如果所有下一步的位置，没有一个能到右下角，next = 系统最大！
		// 返回系统最大！
		// next != 系统最大 7 + 1
		return next != Integer.MAX_VALUE ? (next + 1) : next;
	}

	// 优化方法, 利用线段树做枚举优化
	// 因为线段树，下标从1开始
	// 所以，该方法中所有的下标，请都从1开始，防止乱！
	public static int jump2(int[][] arr) {
		int n = arr.length;
		int m = arr[0].length;
		int[][] map = new int[n + 1][m + 1];
		for (int a = 0, b = 1; a < n; a++, b++) {
			for (int c = 0, d = 1; c < m; c++, d++) {
				map[b][d] = arr[a][c];
			}
		}
		SegmentTree[] rowTrees = new SegmentTree[n + 1];
		for (int i = 1; i <= n; i++) {
			rowTrees[i] = new SegmentTree(m);
		}
		SegmentTree[] colTrees = new SegmentTree[m + 1];
		for (int i = 1; i <= m; i++) {
			colTrees[i] = new SegmentTree(n);
		}
		rowTrees[n].update(m, m, 0, 1, m, 1);
		colTrees[m].update(n, n, 0, 1, n, 1);
		for (int col = m - 1; col >= 1; col--) {
			if (map[n][col] != 0) {
				int left = col + 1;
				int right = Math.min(col + map[n][col], m);
				int next = rowTrees[n].query(left, right, 1, m, 1);
				if (next != Integer.MAX_VALUE) {
					rowTrees[n].update(col, col, next + 1, 1, m, 1);
					colTrees[col].update(n, n, next + 1, 1, n, 1);
				}
			}
		}
		for (int row = n - 1; row >= 1; row--) {
			if (map[row][m] != 0) {
				int up = row + 1;
				int down = Math.min(row + map[row][m], n);
				int next = colTrees[m].query(up, down, 1, n, 1);
				if (next != Integer.MAX_VALUE) {
					rowTrees[row].update(m, m, next + 1, 1, m, 1);
					colTrees[m].update(row, row, next + 1, 1, n, 1);
				}
			}
		}
		for (int row = n - 1; row >= 1; row--) {
			for (int col = m - 1; col >= 1; col--) {
				if (map[row][col] != 0) {
					// (row,col) 往右是什么范围呢？[left,right]
					int left = col + 1;
					int right = Math.min(col + map[row][col], m);
					int next1 = rowTrees[row].query(left, right, 1, m, 1);
					// (row,col) 往下是什么范围呢？[up,down]
					int up = row + 1;
					int down = Math.min(row + map[row][col], n);
					int next2 = colTrees[col].query(up, down, 1, n, 1);
					int next = Math.min(next1, next2);
					if (next != Integer.MAX_VALUE) {
						rowTrees[row].update(col, col, next + 1, 1, m, 1);
						colTrees[col].update(row, row, next + 1, 1, n, 1);
					}
				}
			}
		}
		return rowTrees[1].query(1, 1, 1, m, 1);
	}

	// 区间查询最小值的线段树
	// 注意下标从1开始，不从0开始
	// 比如你传入size = 8
	// 则位置对应为1~8，而不是0~7
	public static class SegmentTree {
		private int[] min;
		private int[] change;
		private boolean[] update;

		public SegmentTree(int size) {
			int N = size + 1;
			min = new int[N << 2];
			change = new int[N << 2];
			update = new boolean[N << 2];
			update(1, size, Integer.MAX_VALUE, 1, size, 1);
		}

		private void pushUp(int rt) {
			min[rt] = Math.min(min[rt << 1], min[rt << 1 | 1]);
		}

		private void pushDown(int rt, int ln, int rn) {
			if (update[rt]) {
				update[rt << 1] = true;
				update[rt << 1 | 1] = true;
				change[rt << 1] = change[rt];
				change[rt << 1 | 1] = change[rt];
				min[rt << 1] = change[rt];
				min[rt << 1 | 1] = change[rt];
				update[rt] = false;
			}
		}

		// 最后三个参数是固定的, 每次传入相同的值即可:
		// l = 1(固定)
		// r = size(你设置的线段树大小)
		// rt = 1(固定)
		public void update(int L, int R, int C, int l, int r, int rt) {
			if (L <= l && r <= R) {
				update[rt] = true;
				change[rt] = C;
				min[rt] = C;
				return;
			}
			int mid = (l + r) >> 1;
			pushDown(rt, mid - l + 1, r - mid);
			if (L <= mid) {
				update(L, R, C, l, mid, rt << 1);
			}
			if (R > mid) {
				update(L, R, C, mid + 1, r, rt << 1 | 1);
			}
			pushUp(rt);
		}

		// 最后三个参数是固定的, 每次传入相同的值即可:
		// l = 1(固定)
		// r = size(你设置的线段树大小)
		// rt = 1(固定)
		public int query(int L, int R, int l, int r, int rt) {
			if (L <= l && r <= R) {
				return min[rt];
			}
			int mid = (l + r) >> 1;
			pushDown(rt, mid - l + 1, r - mid);
			int left = Integer.MAX_VALUE;
			int right = Integer.MAX_VALUE;
			if (L <= mid) {
				left = query(L, R, l, mid, rt << 1);
			}
			if (R > mid) {
				right = query(L, R, mid + 1, r, rt << 1 | 1);
			}
			return Math.min(left, right);
		}

	}

	// 为了测试
	public static int[][] randomMatrix(int n, int m, int v) {
		int[][] ans = new int[n][m];
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < m; j++) {
				ans[i][j] = (int) (Math.random() * v);
			}
		}
		return ans;
	}

	// 为了测试
	public static void main(String[] args) {
		// 先展示一下线段树的用法，假设N=100
		// 初始化时，1~100所有位置的值都是系统最大
		System.out.println("线段树展示开始");
		int N = 100;
		SegmentTree st = new SegmentTree(N);
		// 查询8~19范围上的最小值
		System.out.println(st.query(8, 19, 1, N, 1));
		// 把6~14范围上对应的值都修改成56
		st.update(6, 14, 56, 1, N, 1);
		// 查询8~19范围上的最小值
		System.out.println(st.query(8, 19, 1, N, 1));
		// 以上是线段树的用法，你可以随意使用update和query方法
		// 线段树的详解请看体系学习班
		System.out.println("线段树展示结束");

		// 以下为正式测试
		int len = 10;
		int value = 8;
		int testTimes = 10000;
		System.out.println("对数器测试开始");
		for (int i = 0; i < testTimes; i++) {
			int n = (int) (Math.random() * len) + 1;
			int m = (int) (Math.random() * len) + 1;
			int[][] map = randomMatrix(n, m, value);
			int ans1 = jump1(map);
			int ans2 = jump2(map);
			if (ans1 != ans2) {
				System.out.println("出错了!");
			}
		}
		System.out.println("对数器测试结束");
	}

}