Java 找到一个模式，这样我就可以通过不重复计算来改进排列算法

这是我问题的一些背景（不是家庭作业）。我在一家杂货店有4种商品可供选择，我想知道每种商品中有多少百分比可以放在我的篮子里，但我设定了一个范围，任何一种商品都不能低于20%，也不能超过60%。程序当前以0开始并向上运行（在本例中，0是最小值20，高于它的任何值都等于它是最小值的百分之多少）。使用上述最小值为20的示例，[

20,0,0,0]

将等于40+20+20+20=100，并为所有项目生成排列

运行它之后，我意识到（使用上面的示例）第一项是

[20,0,0,0]

，最后一项是

[0,0,0,20]

。我通过将所有结果与它们的反向版本进行比较来测试，它们都存在，因此我认为我可以找到一种方法，通过只处理列表的一半，然后获取结果并翻转它们，将处理时间减半。我遇到了一个问题，当我开始检查反向匹配时，程序仍在生成结果，似乎没有一个点会翻转并开始复制（我希望正好在中途可以做到）。这里是，第一列是结果本身，第二列是它的反向版本的索引（-1表示找不到它）。它以all-1开始，然后开始寻找一些反向匹配，但仍然有许多-1，然后它最终过渡到所有重复的结果，但它似乎以一种可预测的清晰方式进行

我的最终目标是使用更大的列表，我正试图找到一种方法来生成尽可能多的数据，因此任何关于如何识别模式或其他速度改进的建议都将非常有用。我在想，在这种情况下，我要么需要一种方法，在模式完全开发（即不再有机会

-1

）后识别模式，要么调整算法，使其生成顺序完全切换，而不是缓慢的部分更改

如果有帮助，下面是我正在使用的代码（注意：项目和范围的数量是变量，因此我试图找到一个通用模式，而不是特定于任何硬数字）：

import java.util.*；
公共类分发服务器{
//正确的输出是1771
private ArrayList result=new ArrayList（）；
/*
*/
公共分发服务器（最终字符串[]名称，整数[]低，整数[]高）
{
最终整数剩余=100；
int最小值=0；
用于（整数l:低）
最小+=l；
int[]size=新的int[names.length]；
分布（0、低、高、最小休息、大小）；
System.out.println（“结果的总大小为”+result.size（））；
}
公共静态void main（字符串[]args）{
System.out.println（“start..Hold！！”；
最终字符串[]名称=新字符串[]{“a”、“b”、“c”、“d”}；//项目名称
int[]低=新的int[names.length]；
int[]高=新的int[names.length]；
Arrays.fill（低，20）；//使用最小/最大范围自动填充项目范围
数组。填充（高，60）；
新分销商（名称、低、高）；
}
/*
将其余的值按大小分布在元素上，从索引i开始。
*/
无效分布（int i，int[]低，int[]高，最终int rest，int[]大小）{
如果（i==size.length-1）{//此区域处理最后一项并将其添加到解决方案队列中
如果（剩余<高[i]）{
尺寸[i]=剩余尺寸；
checkResultsDuringRuntime（Arrays.copyOf（size，size.length），result）；
result.add（Arrays.copyOf（size，size.length））；
}
}
否则{
int-startoop=0；
//此区域检查是否可以使用剩余项目的最大值达到剩余值
//如果不可能，则必须增加回路的当前最小范围
如果（剩余>（低长度-（i+1））*高[i]）{
System.out.println（“剩余高于高”）；
StartOOP=（静止-（低长度-（i+1））*高[i]）；
}
//此区域为每个系数运行一个循环，然后将其发送回此函数进行进一步处理
for（int c=startOOP；
c=0；x--，y++）{
反向列表[y]=默认列表[x]；
}       
int MatchLocation=-1；
对于（int[]项：result2）{
if（Arrays.toString（item）.equals（Arrays.toString（ReversedList）））
{   
//System.out.println（“有匹配项”）；
MatchLocation=result2.indexOf（项目）；
}
}
System.out.println（Arrays.toString（defaultlist）+“=”+匹配位置）；
}
}

输出：

编辑：该程序没有生成重复项。它生成的前提似乎最终会反转。我想尝试捕获反转排列将与现有结果匹配的点，这样我就可以反转现有结果，而不是进一步处理数据。查看上面的输出，了解我的描述ing.

我建议使用 确保不可能出现假阴性：

可能出现误报，但不会出现误报；即，查询返回“集合内（可能错误）”或“绝对不在集合内”

A

当然，现在的问题是比较数组是否相等，我建议执行以下操作：

Arrays.sort(arrayToCompare);  
Arrays.equals(initialArray,arrayToCompare);

---

您承担了排序的开销，但它会告诉您两个数组是否相等，因此以前的bloom筛选器就足够了。

我不完全理解这个问题，但有一个技巧可以解决类似的问题。例如，假设您希望生成3个从1到6的数字[1，4，2]，但您希望忽略DUP；tha

Arrays.sort(arrayToCompare);  
Arrays.equals(initialArray,arrayToCompare);

for(int i=1; i <= 6; i++) {
    for(int j=i+1; j <= 6; j++) {
        for(int k=j+1; k <= 6; k++) {
            System.out.println(i+","+j+","+k);
            }
        }
    }

1,2,3
1,2,4
1,2,5
1,2,6
1,3,4
1,3,5
1,3,6
1,4,5
1,4,6
1,5,6
2,3,4
2,3,5
2,3,6
2,4,5
2,4,6
2,5,6
3,4,5
3,4,6
3,5,6
4,5,6

1 : [20,20,20,40]
2 : [20,20,21,39]
3 : [20,20,22,38]
4 : [20,20,23,37]
5 : [20,20,24,36]
6 : [20,20,25,35]
7 : [20,20,26,34]
8 : [20,20,27,33]
9 : [20,20,28,32]
10 : [20,20,29,31]
11 : [20,20,30,30]
12 : [20,21,21,38]
13 : [20,21,22,37]
14 : [20,21,23,36]
15 : [20,21,24,35]
16 : [20,21,25,34]
17 : [20,21,26,33]
18 : [20,21,27,32]
19 : [20,21,28,31]
20 : [20,21,29,30]
21 : [20,22,22,36]
22 : [20,22,23,35]
23 : [20,22,24,34]
24 : [20,22,25,33]
25 : [20,22,26,32]
26 : [20,22,27,31]
27 : [20,22,28,30]
28 : [20,22,29,29]
29 : [20,23,23,34]
30 : [20,23,24,33]
31 : [20,23,25,32]
32 : [20,23,26,31]
33 : [20,23,27,30]
34 : [20,23,28,29]
35 : [20,24,24,32]
36 : [20,24,25,31]
37 : [20,24,26,30]
38 : [20,24,27,29]
39 : [20,24,28,28]
40 : [20,25,25,30]
41 : [20,25,26,29]
42 : [20,25,27,28]
43 : [20,26,26,28]
44 : [20,26,27,27]
45 : [21,21,21,37]
46 : [21,21,22,36]
47 : [21,21,23,35]
48 : [21,21,24,34]
49 : [21,21,25,33]
50 : [21,21,26,32]
51 : [21,21,27,31]
52 : [21,21,28,30]
53 : [21,21,29,29]
54 : [21,22,22,35]
55 : [21,22,23,34]
56 : [21,22,24,33]
57 : [21,22,25,32]
58 : [21,22,26,31]
59 : [21,22,27,30]
60 : [21,22,28,29]
61 : [21,23,23,33]
62 : [21,23,24,32]
63 : [21,23,25,31]
64 : [21,23,26,30]
65 : [21,23,27,29]
66 : [21,23,28,28]
67 : [21,24,24,31]
68 : [21,24,25,30]
69 : [21,24,26,29]
70 : [21,24,27,28]
71 : [21,25,25,29]
72 : [21,25,26,28]
73 : [21,25,27,27]
74 : [21,26,26,27]
75 : [22,22,22,34]
76 : [22,22,23,33]
77 : [22,22,24,32]
78 : [22,22,25,31]
79 : [22,22,26,30]
80 : [22,22,27,29]
81 : [22,22,28,28]
82 : [22,23,23,32]
83 : [22,23,24,31]
84 : [22,23,25,30]
85 : [22,23,26,29]
86 : [22,23,27,28]
87 : [22,24,24,30]
88 : [22,24,25,29]
89 : [22,24,26,28]
90 : [22,24,27,27]
91 : [22,25,25,28]
92 : [22,25,26,27]
93 : [22,26,26,26]
94 : [23,23,23,31]
95 : [23,23,24,30]
96 : [23,23,25,29]
97 : [23,23,26,28]
98 : [23,23,27,27]
99 : [23,24,24,29]
100 : [23,24,25,28]
101 : [23,24,26,27]
102 : [23,25,25,27]
103 : [23,25,26,26]
104 : [24,24,24,28]
105 : [24,24,25,27]
106 : [24,24,26,26]
107 : [24,25,25,26]
108 : [25,25,25,25]