// 有一个二维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;
}
}
}
}
相关推荐
已知两个已经排好序（非减序）的序列X和Y 其中X的长度为m Y长度为n 现在请你用分治算法 找出X和Y的第k小的数 算法时间复杂度为O max{...此题请勿采用将序列X和Y合并找第k小的O m+n 的一般方法 要充分利用X和Y [更多]
在实际应用中，数据往往不是单一的无序序列，而是由多个已经部分排序的子序列组成。这样的结构可能源自不同的数据源或处理阶段。传统的排序算法，如快速排序、归并排序等，可能并不适用于这种情况，因为它们通常假设...
通过这个类，我们可以创建一个序列化辅助类，如示例中的`JsonHelper`，它包含两个泛型方法：`JsonSerializer`用于序列化，`JsonDeserialize`用于反序列化。 为了使用`DataContractJsonSerializer`类，你需要引入...
Halton序列的构造依赖于素数，通常选择两个或更多个不同的质数作为基底，如2、3、5、7等。每个维度的索引使用一个不同的质数，然后将这些质数下的逆元位置转换为小数部分，得到的数值就构成了序列的一部分。 具体来...
本篇文章讨论的问题是：给定两个递增的整数序列A和B，利用链表来表示这两个序列，并实现一个算法，将这两个序列合并成一个新的递增有序序列C。在合并过程中，要求新的序列C不能包含重复的元素，并且整个算法的空间...
- **对象**：由大括号`{}`包围，内部是零个或多个“名值对”。每个名值对由一个键和一个值组成，键必须是字符串类型，后面跟着一个冒号`:`，键和值之间用逗号`,`分隔。例如： ```json { "name": "张三", "gender...
2. **组合序列**：组合序列是将多个独立或相关的信号序列组合起来，以增强信号的特性或降低噪声的影响。在MATLAB中，可以通过矩阵运算或者自定义函数实现序列的组合。这有助于提取信号的潜在信息，尤其在处理非平稳...
LSTM网络在时间序列预测中的应用是通过学习输入序列的模式来预测下一个或多个时间步的输出。在MATLAB中，我们可以利用深度学习工具箱来构建和训练LSTM模型。在提供的源码“LSTMTIMEN.m”中，我们可能会看到以下关键...
在实际应用中，这样的功能可能用于查找数据库中的共同元素，或者在多个排序列表中找交集。 1. 项目要求： 1.3.1 功能要求：程序应具备接收两个链表的输入，然后计算并输出这两个链表的交集。交集定义为同时存在于两...
这种方法包括了趋势分析、季节性分析、周期性分析以及异常值检测等多个方面。在实际应用中，例如金融市场预测、销售预测、气候变化研究等领域，时间序列分析都发挥着重要作用。 混沌理论与时间序列分析的结合，使得...
总结来说，将AVI视频转换成图片序列涉及了视频编码理解、选择合适的转换工具、控制输出图片序列的数量和质量、以及后续的图片处理和管理等多个步骤。这个过程在数字媒体处理、计算机视觉和科学研究等领域都有广泛...
在编程领域，这个问题通常涉及到如何有效地将多个已排序的链表（或数组）合并成一个单一的有序序列。这个问题在处理大规模数据时非常有用，比如在数据库查询优化、并行计算以及大数据处理中。 在Python等高级编程...
时间序列建模预测在多个领域都有应用，如金融市场的股票价格预测、气象学中的天气预报、电力系统的负荷预测等。通过MATLAB，用户可以方便地实现从数据预处理、模型构建到预测结果可视化的一整套流程。 综上所述，...
序列模式是指在一系列的序列数据中按照时间顺序排列的一组元素，其中每个元素可以包含一个或多个项目。序列模式挖掘在众多领域中有着广泛的应用，比如客户购买行为模式预测、Web访问模式预测、疾病诊断、自然灾害...
序列模式的表示通常会进行符号化，例如，一个序列可以表示为一系列有序的项目集。子序列是序列的一部分，如果一个序列包含另一个序列的所有项目，那么后者就是前者的子序列。支持度是衡量序列模式频繁程度的指标，它...
此外，对于多变量时间序列预测，LSTM可以接收多个输入特征，通过联合分析多个因素来提升预测效果。 总结起来，TensorFlow中的LSTM网络是处理时间序列预测的强大工具，结合有效的数据预处理和模型调优，能够实现准确...
3. **合并阶段（Combine）**：将已排序的子数组合并回一个有序数组。这一步是合并排序的核心，它涉及两个已排序的序列的合并。从两个子数组的头部开始，比较两个头部元素，选择较小的放入结果数组，并移动相应的指针...
时间序列分析广泛应用于金融、经济、气象、工程、市场营销等多个领域，例如股票价格预测、销售趋势分析、电力需求预测等。 通过深入学习MIT的时间序列分析讲义，你将掌握这些关键概念和技术，能够有效地分析和预测...