一串首尾相连的珠子(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