题目一 

策略：

每次将绳子右端点放在一个点上，看绳子往左可以覆盖多少个点。

如何知道左边覆盖几个点？

在绳子右端点cur左边有序区域找第一个大于等于arr[cur]-L的位置

滑动窗口

每次绳子左侧放在一个点上，然后有边界向右走，要求【绳子长度arr[R]-arr[L]+1】超过绳子长度L

每次R不能继续往右动，就移动左边界，然后再看有边界能否继续右动。。。周而复始【窗口边界都不回头的】 => O(N)

	// 长度为L的绳子最多覆盖几个点，请保证arr有序
	public static int maxPoint(int[] arr, int L) {
		int res = 1;
		for (int i = 0; i < arr.length; i++) {
			int nearest = nearestIndex(arr, i, arr[i] - L);
			res = Math.max(res, i - nearest + 1);
		}
		return res;
	}

	// 在arr[0..R]范围上，找满足>=value的最左位置
	public static int nearestIndex(int[] arr, int R, int value) {
		int L = 0;
		int index = R;
		while (L < R) {
			int mid = L + ((R - L) >> 1);
			if (arr[mid] >= value) {
				index = mid;
				R = mid - 1;
			} else {
				L = mid + 1;
			}
		}
		return index;
	}

	public static void main(String[] args) {
		int[] arr = { 0, 13, 24, 35, 46, 57, 60, 72, 87 };
		int L = 6;

		System.out.println(maxPoint(arr, L));

	}

---

 题目二：

普通的解法：

算出可以使用最多8类型袋子M=N/8，然后看剩余苹果是否可以用6类型袋子搞定。不行，尝试M-1个8类型袋子，然后看剩余苹果是否可以用6类型袋子搞定。。。周而复始

如果剩余苹果超过24就不需要进行尝试了，因为前面一定是已经试过的了。【6和8最小公倍数特点】

	public static int minBags(int apple) {
		if (apple < 0) {
			return -1;
		}
		int bag6 = -1;
		int bag8 = apple / 8;
		int rest = apple - 8 * bag8;
		while (bag8 >= 0 && rest < 24) {
			int restUse6 = minBagBase6(rest);
			if (restUse6 != -1) {
				bag6 = restUse6;
				break;
			}
			rest = apple - 8 * (--bag8);
		}
		return bag6 == -1 ? -1 : bag6 + bag8;
	}

	// 如果剩余苹果rest可以被6个苹果的袋子搞定，返回袋子数量
	// 不能搞定返回-1
	public static int minBagBase6(int rest) {
		return rest % 6 == 0 ? (rest / 6) : -1;
	}

---

题目三： 

预处理之后，后续频繁查询可以很快 => 用空间换时间

	// RGRGR -> RRRGG
	public static int minPaint(String s) {
		if (s == null || s.length() < 2) {
			return 0;
		}
		char[] chs = s.toCharArray(); // 转换成字符串数组
		int[] right = new int[chs.length]; // 开一个数组记录arr[i..N-1]有多少个R
		right[chs.length - 1] = chs[chs.length - 1] == 'R' ? 1 : 0; // 处理最后一个位置R的情况
		for (int i = chs.length - 2; i >= 0; i--) { // 遍历处理从0-N-2每个位置往后R的情况
			right[i] = right[i + 1] + (chs[i] == 'R' ? 1 : 0);
		}
		int res = right[0]; // 一开始没有左边，填涂颜色数就是0-N-1中R需要填涂成G的个数
		int left = 0; // 从0位置开始往后，统计到arr[0..left]有多少个G
		for (int i = 0; i < chs.length - 1; i++) { //遍历数组 
			left += chs[i] == 'G' ? 1 : 0; // 统计G的个数
			res = Math.min(res, left + right[i + 1]);  
		}
		res = Math.min(res, left + (chs[chs.length - 1] == 'G' ? 1 : 0)); // 判断一下将arr[0-N-1]所有G填涂成R的情况
		return res; 
	}

	public static void main(String[] args) {
		String test = "GGGGGR";
		System.out.println(minPaint(test));
	}

---

题目四： 

	// 设置数组 right 和 down
	// right[i][j] 表示第i行第j列及其往后有多少个连续的1
	// down[i][j] 表示第j列第i行及其往后有多少个连续的1
	public static void setBorderMap(int[][] m, int[][] right, int[][] down) {
		int r = m.length; // 数组行数
		int c = m[0].length; // 数组列数
		if (m[r - 1][c - 1] == 1) { // 特判一下最后一个位置
			right[r - 1][c - 1] = 1; // right数组最后一个位置
			down[r - 1][c - 1] = 1;
		}
		// 处理最后一列的情况
		for (int i = r - 2; i != -1; i--) {
			if (m[i][c - 1] == 1) {
				right[i][c - 1] = 1; // right数组最后一列
				down[i][c - 1] = down[i + 1][c - 1] + 1; // down数组最后一列
			}
		}
		// 处理最后一行的情况
		for (int i = c - 2; i != -1; i--) {
			if (m[r - 1][i] == 1) {
				right[r - 1][i] = right[r - 1][i + 1] + 1; //right数组最后一行
				down[r - 1][i] = 1; // down数组最后一行
			}
		}
		// 处理一般位置的情况
		for (int i = r - 2; i != -1; i--) {
			for (int j = c - 2; j != -1; j--) {
				if (m[i][j] == 1) {
					right[i][j] = right[i][j + 1] + 1;
					down[i][j] = down[i + 1][j] + 1;
				}
			}
		}
	}

	// 返回最大正方形边长
	public static int getMaxSize(int[][] m) {
		int[][] right = new int[m.length][m[0].length];
		int[][] down = new int[m.length][m[0].length];
		setBorderMap(m, right, down);  // 预处理rigth和down辅助数组
		for (int size = Math.min(m.length, m[0].length); size != 0; size--) { // 枚举正方行边长
			// 如果存在这样大小的正方行，直接返回，因为是从大到小尝试，第一个满足条件的一定就是最大的边长
			if (hasSizeOfBorder(size, right, down)) { 
				return size;
			}
		}
		return 0;
	}

	public static boolean hasSizeOfBorder(int size, int[][] right, int[][] down) {
		// 遍历每个点作为正方形的左上方的点
		for (int i = 0; i != right.length - size + 1; i++) { 
			for (int j = 0; j != right[0].length - size + 1; j++) {
				// 如果正方形四条边都有size长度连续为1的部分，返回true，说明找到存在这样的正方形
				if (right[i][j] >= size && down[i][j] >= size
						&& right[i + size - 1][j] >= size
						&& down[i][j + size - 1] >= size) {
					return true;
				}
			}
		}
		return false;
	}

	// 随机生成矩阵
	public static int[][] generateRandom01Matrix(int rowSize, int colSize) {
		int[][] res = new int[rowSize][colSize]; 
		for (int i = 0; i != rowSize; i++) {
			for (int j = 0; j != colSize; j++) {
				res[i][j] = (int) (Math.random() * 2); //生成[0-1]的随机整数
			}
		}
		return res;
	}

	// 打印随机生成的矩阵
	public static void printMatrix(int[][] matrix) {
		for (int i = 0; i != matrix.length; i++) {
			for (int j = 0; j != matrix[0].length; j++) {
				System.out.print(matrix[i][j] + " ");
			}
			System.out.println();
		}
	}

	public static void main(String[] args) {
		int[][] matrix = generateRandom01Matrix(7, 8); // 生成7*8的矩阵
		printMatrix(matrix); // 打印矩阵
		System.out.println(getMaxSize(matrix)); // 打印最大正方行边长
	}

---

题目五： 

技巧：先加工成01等概率发生器。然后利用二进制位移位进行数字拼凑。

	// 等概率返回1-5的函数
	public static int f() {
		return (int)(Math.random()*5)+1;
	}
	
	// 等概率返回0和1的函数
	public static int r01(){
		int res=0;
		do{
			res=f();
		}while(res==3);
		return res<3?0:1;
	}
	
	// 等该率返回1-7的函数
	public static int g() {
		int res=0;
		do { // 等概率生成0-7
			res=(r01()<<2)+(r01()<<1)+r01();
		}while(res==7); // 如果是7就重新来
		return res+1; // (0-6)+1 => (1-7)
	}

对于第三种情况：两次为一组，如果是0 0 或 1 1，重新来。如果是0 1 则返回 0，如果是 1 0，则返回1。这样返回0和返回1的概率就都是p(1-p)，做到了等概率。