多个序列组合，序列保持有序

最新推荐文章于 2024-07-09 22:08:28 发布

原创最新推荐文章于 2024-07-09 22:08:28 发布 · 676 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java

算法专栏收录该内容

11 篇文章

订阅专栏

本文详细阐述了如何根据特定顺序生成多个字符串集合的组合序列，确保每个元素仅出现一次，且保持原始集合中元素之间的相对顺序不变。

// 有一个二维Vector，每个元都是字符串（或者其他对象），
	// 如下面这个三行，每行元素不固定的二维Vector V
	// A、B、C、D
	// H、I、J、K、M
	// X、Y、Z
	// 求出满足以下条件的所有Vector D：
	// 1.此Vector D的元素包含V的所有元素，且每个元素仅出现一次
	// 2.此Vector
	// D中包含在V【1】中的元素之间的顺序不能发生改变，即A、B、C、D之间的顺序不发生改变，同理，V【2】、V【3】。。。。都不发生改变。
	// 对于本例，也就是说，在结果D中，A、B、C、D的先后顺序不变，H、I、J、K、M的先后顺序不变，X、Y、Z的先后顺序不变。

	// 结果D的几种可能的情况是：
	// 1：A、B、C、D、H、I、J、K、M、X、Y、Z
	// 2：H、I、A、B、C、X、D、J、K、Y、Z、M
	// 3：A、H、I、X、Y、Z、B、C、J、K、M、D
	// 等等
	// 一定要注意，是要求出所有可能的情况。
	//
	// 解题思路：
	// 1.如三个字符串为：AB，HI，XY(多了列举麻烦)
	// 2. 第一个字符序列：AB(为第一个Vector的所有字符组成的字符串)
	// 3.循环第二个Vector,从H开始,H在AB中不存在，则在三个位置都可以插入
	// 生成以下字符序列：HAB,AHB,ABH
	// 4.下面是I，I必须在H之后
	// 字符串HAB，H之后有AB，可以从三个位置插入I，生成IAB，AIB，ABI，最终生成HIAB，HAIB，HABI
	// 字符串AHB，H之后有B，可以从两个位置插入I，生成IB，BI，最终生成AHIB，AHBI
	// 字符串ABH，H之后什么也没有，只有I，最终生成ABHI
	// 最终生成序列：HIAB，HAIB，HABI，AHIB，AHBI，ABHI
	// 5.第二个Vector循环完了，开始循环第三个Vector,从X开始
	// X在HIAB，HAIB，HABI，AHIB，AHBI，ABHI所有字符串中都不存在，则每个字符串都有5个位置可以插入X
	// 最终生成：
	// HIAB：XHIAB，HXIAB，HIXAB，HIAXB，HIABX
	// HAIB：XHAIB，HXAIB，HAXIB，HAIXB，HAIBX
	// HABI：XHABI，HXABI，HAXBI，HABXI，HABIX
	// AHIB：XAHIB，AXHIB，AHXIB，AHIXB，AHIBX
	// AHBI：XAHBI，AXHBI，AHXBI，AHBXI，AHBIX
	// ABHI：XABHI，AXBHI，ABXHI，ABHXI，ABHIX
	// 6.下面是最后一个Y，Y必须在X之后，算法同上面一样
	//
	public static void print43() {
		Vector<String> v1 = new Vector<String>(4);
		v1.add("A");
		v1.add("B");
		// v1.add("C");
		// v1.add("D");
		Vector<String> v2 = new Vector<String>(5);
		v2.add("H");
		v2.add("I");
		v2.add("J");
		// v2.add("K");
		// v2.add("M");
		Vector<String> v3 = new Vector<String>(3);
		v3.add("X");
		v3.add("Y");
		// v3.add("Z");

		Vector<Vector<String>> vector = new Vector<Vector<String>>(3);
		vector.add(v1);
		vector.add(v2);
		vector.add(v3);

		List<String> list = new ArrayList<String>();
		list.add(vector.get(0).toString().replaceAll("\\[", "")
				.replaceAll("]", "").replaceAll(",", "").replaceAll(" ", ""));

		for (int m = 1; m < vector.size(); m++) {
			Vector<String> v = vector.get(m);
			String f = v.get(0);
			int n = v.size();
			for (int i = 0; i < n; i++) {
				String c = v.get(i);
				int len = list.size();
				List<String> newList = new ArrayList<String>();
				for (int j = 0; j < len; j++) {
					String ch = list.get(j);
					int index = ch.indexOf(f);
					String left = ch.substring(0, index + 1);
					String right = ch.substring(index + 1);
					for (int k = 0; k <= right.length(); k++) {
						StringBuffer sb = new StringBuffer(right);
						sb.insert(k, c);
						newList.add(left + sb.toString());
					}
				}
				list = newList;
				f = c;
			}
		}

		int len = list.size();
		for (int i = 0; i < len; i++) {
			System.out.println((i + 1) + ":" + list.get(i));
		}
	}

	public static void main(String[] args) {
		T2.print43();
	}

输出：

1:XYHIJAB
2:XHYIJAB
3:XHIYJAB
4:XHIJYAB
5:XHIJAYB
6:XHIJABY
7:HXYIJAB
8:HXIYJAB
9:HXIJYAB
10:HXIJAYB
11:HXIJABY
12:HIXYJAB
13:HIXJYAB
14:HIXJAYB
15:HIXJABY
16:HIJXYAB
17:HIJXAYB
18:HIJXABY
19:HIJAXYB
20:HIJAXBY
21:HIJABXY
22:XYHIAJB
23:XHYIAJB
24:XHIYAJB
25:XHIAYJB
26:XHIAJYB
27:XHIAJBY
28:HXYIAJB
29:HXIYAJB
30:HXIAYJB
31:HXIAJYB
32:HXIAJBY
33:HIXYAJB
34:HIXAYJB
35:HIXAJYB
36:HIXAJBY
37:HIAXYJB
38:HIAXJYB
39:HIAXJBY
40:HIAJXYB
41:HIAJXBY
42:HIAJBXY
43:XYHIABJ
44:XHYIABJ
45:XHIYABJ
46:XHIAYBJ
47:XHIABYJ
48:XHIABJY
49:HXYIABJ
50:HXIYABJ
51:HXIAYBJ
52:HXIABYJ
53:HXIABJY
54:HIXYABJ
55:HIXAYBJ
56:HIXABYJ
57:HIXABJY
58:HIAXYBJ
59:HIAXBYJ
60:HIAXBJY
61:HIABXYJ
62:HIABXJY
63:HIABJXY
64:XYHAIJB
65:XHYAIJB
66:XHAYIJB
67:XHAIYJB
68:XHAIJYB
69:XHAIJBY
70:HXYAIJB
71:HXAYIJB
72:HXAIYJB
73:HXAIJYB
74:HXAIJBY
75:HAXYIJB
76:HAXIYJB
77:HAXIJYB
78:HAXIJBY
79:HAIXYJB
80:HAIXJYB
81:HAIXJBY
82:HAIJXYB
83:HAIJXBY
84:HAIJBXY
85:XYHAIBJ
86:XHYAIBJ
87:XHAYIBJ
88:XHAIYBJ
89:XHAIBYJ
90:XHAIBJY
91:HXYAIBJ
92:HXAYIBJ
93:HXAIYBJ
94:HXAIBYJ
95:HXAIBJY
96:HAXYIBJ
97:HAXIYBJ
98:HAXIBYJ
99:HAXIBJY
100:HAIXYBJ
101:HAIXBYJ
102:HAIXBJY
103:HAIBXYJ
104:HAIBXJY
105:HAIBJXY
106:XYHABIJ
107:XHYABIJ
108:XHAYBIJ
109:XHABYIJ
110:XHABIYJ
111:XHABIJY
112:HXYABIJ
113:HXAYBIJ
114:HXABYIJ
115:HXABIYJ
116:HXABIJY
117:HAXYBIJ
118:HAXBYIJ
119:HAXBIYJ
120:HAXBIJY
121:HABXYIJ
122:HABXIYJ
123:HABXIJY
124:HABIXYJ
125:HABIXJY
126:HABIJXY
127:XYAHIJB
128:XAYHIJB
129:XAHYIJB
130:XAHIYJB
131:XAHIJYB
132:XAHIJBY
133:AXYHIJB
134:AXHYIJB
135:AXHIYJB
136:AXHIJYB
137:AXHIJBY
138:AHXYIJB
139:AHXIYJB
140:AHXIJYB
141:AHXIJBY
142:AHIXYJB
143:AHIXJYB
144:AHIXJBY
145:AHIJXYB
146:AHIJXBY
147:AHIJBXY
148:XYAHIBJ
149:XAYHIBJ
150:XAHYIBJ
151:XAHIYBJ
152:XAHIBYJ
153:XAHIBJY
154:AXYHIBJ
155:AXHYIBJ
156:AXHIYBJ
157:AXHIBYJ
158:AXHIBJY
159:AHXYIBJ
160:AHXIYBJ
161:AHXIBYJ
162:AHXIBJY
163:AHIXYBJ
164:AHIXBYJ
165:AHIXBJY
166:AHIBXYJ
167:AHIBXJY
168:AHIBJXY
169:XYAHBIJ
170:XAYHBIJ
171:XAHYBIJ
172:XAHBYIJ
173:XAHBIYJ
174:XAHBIJY
175:AXYHBIJ
176:AXHYBIJ
177:AXHBYIJ
178:AXHBIYJ
179:AXHBIJY
180:AHXYBIJ
181:AHXBYIJ
182:AHXBIYJ
183:AHXBIJY
184:AHBXYIJ
185:AHBXIYJ
186:AHBXIJY
187:AHBIXYJ
188:AHBIXJY
189:AHBIJXY
190:XYABHIJ
191:XAYBHIJ
192:XABYHIJ
193:XABHYIJ
194:XABHIYJ
195:XABHIJY
196:AXYBHIJ
197:AXBYHIJ
198:AXBHYIJ
199:AXBHIYJ
200:AXBHIJY
201:ABXYHIJ
202:ABXHYIJ
203:ABXHIYJ
204:ABXHIJY
205:ABHXYIJ
206:ABHXIYJ
207:ABHXIJY
208:ABHIXYJ
209:ABHIXJY
210:ABHIJXY

网上的另一种递归解法，没有细看

import java.util.ArrayList;

public class Test {
	private static int sum = 1;
	private static final int SIZE = 12;

	public static void main(String[] args) {
		String[][] arrThree = { { "A", "B", "C", "D" },
				{ "H", "I", "J", "K", "M" }, { "X", "Y", "Z" } };
		ArrayList str = new ArrayList();
		int count = 0;
		int one = 0;
		int two = 0;
		int three = 0;
		fn1(arrThree, str, count, one, two, three);
	}

	public static void fn1(String[][] arr, ArrayList str, int count, int one,
			int two, int three) {
		for (int i = 0; i < 3; i++) {
			if (one < 4 && i == 0) {
				str.add(arr[i][one++]);
				count++;
				if (count != SIZE) {
					fn1(arr, (ArrayList) str.clone(), count--, one, two, three);
					str.remove(count);
					one--;
				}
			} else if (two < 5 && i == 1) {
				str.add(arr[i][two++]);
				count++;
				if (count != SIZE) {
					fn1(arr, (ArrayList) str.clone(), count--, one, two, three);
					str.remove(count);
					two--;
				}
			} else if (three < 3 && i == 2) {
				str.add(arr[i][three++]);
				count++;
				if (count != SIZE) {
					fn1(arr, (ArrayList) str.clone(), count--, one, two, three);
					str.remove(count);
					three--;
				}
			} else {
				continue;
			}

			if (count == SIZE) {
				System.out.println("第" + sum++ + "种:");
				for (int j = 0; j < SIZE; j++) {
					System.out.print(str.get(j) + ",");
				}
				// count=0;
				System.out.println();
				return;
			}
		}
	}
}