一串首尾相连的珠子(m 个)，有N 种颜色(N<=10)，设计一个算法，取出其中一段，要求包含所有N 中颜色，并使长度最短。

转换：将颜色用数字表示出来，比如五种颜色可以用0到4表示，题目就演化为由N个数字
   毫无顺序的连成一串，数字串长度为m，在这长度为m的数字串中，取出一段，包含

   所有N个数字，且使之长度最短。

分析：可以定义一长度为N的数组，color[0]...color[N-1],分别表示N种颜色，
   从头开始遍历数字串m，将读到数字的位置按照“颜色”存入color数组的下标中，且下标
  只保存最新位置，直到集齐N种color，则临时最短长度shortestLength=color最大
   下标-color最小下标+1，继续遍历数字串，当再一次读到最小下标颜色时，更新最小长度，
   直到得出最短长度。

代码如下：

package T40;

public class getShortestFullColor {

	/**
	 * @PLA 一串首尾相连的珠子(m 个)，有N 种颜色(N<=10)， 设计一个算法，取出其中一段，要求包含所有N 中颜色，并使长度最短。
	 *      并分析时间复杂度与空间复杂度。
	 */
	/**
	 * 将颜色用数字表示出来，比如五种颜色可以用0到4表示，题目就演化为由N个数字
	 * 毫无顺序的连成一串，数字串长度为m，在这长度为m的数字串中，取出一段，包含 所有N个数字，且使之长度最短。
	 */
	/*
	 * 分析： 可以定义一长度为N的数组，color[0]...color[N-1],分别表示N种颜色，
	 * 从头开始遍历数字串m，将读到数字的位置按照“颜色”存入color数组的下标中，且下标
	 * 只保存最新位置，直到集齐N种color，则临时最短长度shortestLength=color最大
	 * 下标-color最小下标+1，继续遍历数字串，当再一次读到最小下标颜色时，更新最小长度， 直到得出最短长度。
	 */
	private static int[] color = new int[6];// color[0]不用
	private static int[] Pearl = new int[] { 1, 3, 4, 4, 5, 3, 2, 1 };
	static int begin;
	static int over;
	private int shortestLength = 0;

	// 获取color数组最小位置
	public int getMin(int[] color) {
		if (color == null) {
			return -1;
		}
		int temp = color[1];// 由于color[0]空置不用
		for (int i = 1; i < color.length; i++) {
			// System.out.println("getMin"+color[i]);
			if (color[i] < temp) {
				temp = color[i];
			}
		}
		return temp;
	}

	// 获取color数组最大位置
	int getMax(int[] color) {
		if (color == null) {
			return -1;
		}
		int temp = color[1];
		for (int i = 1; i < color.length; i++) {
			if (color[i] > temp) {
				temp = color[i];
			}
		}
		return temp;
	}

	int getShortestLength(int[] color, int[] pearl) {
		int index = 0;
		if (pearl.length < color.length - 1) {
			return -1;
		}
		int minPosition = 0, maxPosition = 0, tempLength = 0;
		for (; index < pearl.length; index++) {
			// System.out.println(color[pearl[index]]);
			if (color[pearl[index]] == 0) {
				tempLength++;
			}
			color[pearl[index]] = index;
			if (tempLength == color.length - 1) {
				minPosition = getMin(color);
				maxPosition = getMax(color);
				shortestLength = maxPosition - minPosition + 1;
				// System.out.println("MAX"+maxPosition);
				// System.out.println("MIN"+minPosition);
				break;
			}
		}
		for (++index; index < pearl.length; ++index) {
			// System.out.println("NO"+index);
			if (color[pearl[index]] == minPosition) {
				// System.out.println("INNER"+color[pearl[index]]);
				color[pearl[index]] = index;
				int newMinPositino, newMaxPosition;
				/*
				 * for(int i:color){ System.out.println("color:"+i); }
				 */
				newMinPositino = getMin(color);
				newMaxPosition = getMax(color);
				// System.out.println("newMax"+newMaxPosition);
				// System.out.println("newMin"+newMinPositino);
				if (newMaxPosition - newMinPositino + 1 < shortestLength) {
					shortestLength = newMaxPosition - newMinPositino + 1;
					maxPosition = newMaxPosition;
					minPosition = newMinPositino;
				}
				continue;
			}
			color[pearl[index]] = index;
		}
		begin = minPosition;
		over = maxPosition;
		return shortestLength;
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		getShortestFullColor g = new getShortestFullColor();
		System.out.println("最短长度：" + g.getShortestLength(color, Pearl));
		System.out.println("数字集为：");
		for (; begin <= over; begin++) {
			System.out.println(Pearl[begin]);
		}
	}

}

运行结果如下：

最短长度：5
数字集为：
4
5
3
2
1