8、暴力递归

前缀树

一个字符串类型的数组arr1，另一个字符串类型的数组arr2。arr2中有哪些字符，是arr1中出现的？请打印。arr2中有哪些字符，是作为arr1中某个字符串前缀出现的？请打印。arr2中有哪些字符，是作为arr1中某个字符串前缀出现的？请打印 arr2中出现次数最大的前缀

public static class TrieNode {
   
		public int pass;//在加前缀树的时候这个结点通过了多少次
		public int end;//结点是否是一个字符串的结尾结点，如果是，它是多少个字符串的结尾结点
		public TrieNode[] nexts;//HashMap nexts;也可以有序表TreeMap nexts;

		public TrieNode() {
   
			pass = 0;
			end = 0;
			//nexts[0] == null 没有走向a的路
			//nexts[0] != null 有走向a的路
			//... 
			//nexts[25] != null 有走向z的路
			nexts = new TrieNode[26];
		}
	}

public static class Trie {
   
		private TrieNode root;//头节点

		public Trie() {
   
			root = new TrieNode();
		}

		//加入字符串
		public void insert(String word) {
   
			if (word == null) {
   
				return;
			}
			char[] chs = word.toCharArray();
			TrieNode node = root;
			node.pass++;
			int index = 0;
			for (int i = 0; i < chs.length; i++) {
   
				index = chs[i] - 'a';
				if (node.nexts[index] == null) {
   
					node.nexts[index] = new TrieNode();
				}
				node = node.nexts[index];
				node.pass++;
			}
			node.end++;
		}

		//沿途pass--，最后end--，如果pass为0了，就要释放掉它
		public void delete(String word) {
   
			if (search(word) != 0) {
   
				char[] chs = word.toCharArray();
				TrieNode node = root;
				int index = 0;
				for (int i = 0; i < chs.length; i++) {
   
					index = chs[i] - 'a';
					if (--node.nexts[index].path == 0) {
   
						node.nexts[index] = null;
						return;
					}
					node = node.nexts[index];
				}
				node.end--;
			}
		}

		//word这个词之前加入过几次
		public int search(String word) {
   
			if (word == null) {
   
				return 0;
			}
			char[] chs = word.toCharArray();
			TrieNode node = root;
			int index = 0;
			for (int i = 0; i < chs.length; i++) {
   
				index = chs[i] - 'a';
				if (node.nexts[index] == null) {
   
					return 0;
				}
				node = node.nexts[index];
			}
			return node.end;
		}

		//所有加入的字符串中，有几个是以pre这个字符串作为前缀的
		public int prefixNumber(String pre) {
   
			if (pre == null) {
   
				return 0;
			}
			char[] chs = pre.toCharArray();
			TrieNode node = root;
			int index = 0;
			for (int i = 0; i < chs.length; i++) {
   
				index = chs[i] - 'a';
				if (node.nexts[index] == null) {
   
					return 0;
				}
				node = node.nexts[index];
			}
			return node.pass;
		}
	}

贪心算法

在某一个标准下，优先考虑最满足标准的样本，最后考虑最不满足标准的样本，最终得到一个答案的算法，叫作贪心算法。也就是说，不从整体最优上加以考虑，所做出的是在某种意义上的局部最优解。
局部最优->整体最优

一些项目要占用一个会议室宣讲，会议室不能同时容纳两个项目的宣讲。给你每一个项目开始的时间和结束的时间(给你一个数组，里面是一个个具体的项目)，你来安排宣讲的日程，要求会议室进行的宣讲的场次最多，返回这个最多的宣讲场次。

先安排结束时间早的会议，然后把不能安排的去掉

package class07;

import java.util.Arrays;
import java.util.Comparator;

public class Code04_BestArrange {
   

	public static class Program {
   //会议
		public int start;//开始时间
		public int end;//结束时间

		public Program(int start, int end) {
   
			this.start = start;
			this.end = end;
		}
	}

	public static class ProgramComparator implements Comparator<Program> {
   //比较器

		@Override
		public int compare(Program o1, Program o2) {
   
			return o1.end - o2.end;
		}

	}

	public static int bestArrange(Program[] programs, int start) {
   //start:当前时间点
		Arrays.