鉴于两个系统由一组数字组成，我想知道它们是否在置换下是同构的。
例如 {{1,2,3,4,5}，{2,4,5,6,7}，{2,3,4,6,7}}是由3组5个数组成的系统。 {{1,2,3,4,6}，{2,3,5,6,7}，{2,3,4,8,9}}是3组5个数字的另一个系统。我想检查这些系统是否是同构的。
没有。第一个系统使用数字{1,2,3,4,5,6,7}，第二个系统使用数字{1,2,3,4,5,6,7,8,9}。
这是另一个例子。 {{1,2,3}，{1,2,4}，{3,4,5}}和{{1,2,4}，{1,3,5}，{2,3,5} }。 3组3个数的这两个系统是同构的。
如果我使用置换（5 3 1 2 4），其中1变为5,2则变为3等。第一组变为{5,3,1}。第二个变为{5,3,2}。第三个变为{1,2,4}。因此，通过这种排列的变换系统是{{5,3,1}，{5,3,2}，{1,2,4}}，它被等效地重写为{{1,2,4}，{1， 3,5}，{2,3,5}}因为我对秩序不感兴趣。这是第二个系统，所以答案是肯定的。
目前，在第一个例子中，我全部申请了9个！ {1,2,3，...，9}的排列 到第一个系统并检查我是否可以获得第二个系统。它给了我答案，但速度很慢。
是否有一个聪明的算法？
（我只想要答案，是或否。我对获得将第一个系统转换为第二个系统的排列不感兴趣。）
答案 0 :(得分：4)
正如评论中所指出的，这可能对应于图形理论问题，这些问题仍在研究复杂性和可用于解决这些问题的算法。
但是，复杂性总是指某些输入大小。在这里，目前尚不清楚您的输入大小是多少。举个例子：我认为最合适的算法可能取决于你是否要扩大规模......
使用您当前的方法，缩放数字的数量是不可行的，因为由于指数运行时间，您无法计算远大于9的数字的所有排列。但是如果你的目的是检查包含1000组的集合的同构，那么在集合数量上是多项式的算法（如果这样的算法存在的话）在实践中可能仍然会更慢。
在这里，我想描绘一下我尝试过的方法。我做了不执行详细的复杂性分析（如果根本没有多项式时间解决方案可能毫无意义 - 并证明或反驳这不能成为答案的主题）。
基本思路如下：
最初，您为每个输入数字计算有效的“域”。根据排列，这些是可以映射到每个数字的可能值。如果给定的数字是1,2和3，那么最初的域可能
1 -> { 1, 2, 3 }
2 -> { 1, 2, 3 }
3 -> { 1, 2, 3 }
但是对于给定的集合，人们已经可以获得一些允许减少域的信息。例如：第一个集中出现n次的任何数字都必须映射到第二个集中出现n次的数字。
想象一下给定的集合是
{{1,2},{1,3}}
{{3,1},{3,2}}
那么域名只会是
1 -> { 3 }
2 -> { 1, 2 }
3 -> { 1, 2 }
因为1在第一组中出现两次，而在第二组中出现两次的唯一值是3。
在计算初始域之后，可以执行数字的可能分配（置换）的回溯。回溯可以粗略地完成
for (each number n that has no permutation value assigned) {
assign a permutation value (from the current domain of n) to n
update the domains of all other numbers
if the domains are no longer valid, then backtrack
if the solution was found, then return it
}
（这个想法在某种程度上受到了Arc Consistency 3 Algorithm的“启发”，虽然从技术上来说，这些问题没有直接关联）
在回溯期间，可以采用不同的修剪标准。也就是说，人们可以想到各种技巧，以便快速检查某个任务（部分排列）和该受让人隐含的域是否“有效”。
分配有效的明显（必要）标准是域的 none 可能为空。更一般地说：每个域的显示频率可能不会超过它包含的元素数。当您发现域名
时1 -> { 4 }
2 -> { 2,3 }
3 -> { 2,3 }
4 -> { 2,3 }
然后不再有有效的解决方案，算法可能会追溯。
当然，bactracking往往在输入大小上具有指数复杂性。但可能只是存在这个问题没有有效的算法。对于这种情况，与蛮力排气搜索相比，在回溯期间可以采用的修剪可以至少有助于减少某些情况（或者对于一般的小输入尺寸）的运行时间。
以下是我在Java中实验的实现。这不是特别优雅，但表明它基本上可以工作：如果存在一个解决方案，它会快速找到解决方案，并且（对于给定的输入大小）不需要很长时间来检测何时有 no 解决方案。
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
public class SetSetIsomorphisms
{
public static void main(String[] args)
{
Map<Integer, Integer> p = new LinkedHashMap<Integer, Integer>();
p.put(0, 3);
p.put(1, 4);
p.put(2, 8);
p.put(3, 2);
p.put(4, 1);
p.put(5, 5);
p.put(6, 0);
p.put(7, 9);
p.put(8, 7);
p.put(9, 6);
Set<Set<Integer>> sets0 = new LinkedHashSet<Set<Integer>>();
sets0.add(new LinkedHashSet<Integer>(Arrays.asList(1,2,3,4,5)));
sets0.add(new LinkedHashSet<Integer>(Arrays.asList(2,4,5,6,7)));
sets0.add(new LinkedHashSet<Integer>(Arrays.asList(0,8,3,9,7)));
Set<Set<Integer>> sets1 = new LinkedHashSet<Set<Integer>>();
for (Set<Integer> set0 : sets0)
{
sets1.add(applyMapping(set0, p));
}
// Uncomment these lines for a case where NO permutation is found
//sets1.remove(sets1.iterator().next());
//sets1.add(new LinkedHashSet<Integer>(Arrays.asList(4,8,2,3,5)));
System.out.println("Initially valid? "+
areIsomorphic(sets0, sets1, p));
boolean areIsomorphic = areIsomorphic(sets0, sets1);
System.out.println("Result: "+areIsomorphic);
}
private static <T> boolean areIsomorphic(
Set<Set<T>> sets0, Set<Set<T>> sets1)
{
System.out.println("sets0:");
for (Set<T> set0 : sets0)
{
System.out.println(" "+set0);
}
System.out.println("sets1:");
for (Set<T> set1 : sets1)
{
System.out.println(" "+set1);
}
Set<T> all0 = flatten(sets0);
Set<T> all1 = flatten(sets1);
System.out.println("All elements");
System.out.println(" "+all0);
System.out.println(" "+all1);
if (all0.size() != all1.size())
{
System.out.println("Different number of elements");
return false;
}
Map<T, Set<T>> domains = computeInitialDomains(sets0, sets1);
System.out.println("Domains initially:");
print(domains, "");
Map<T, T> assignment = new LinkedHashMap<T, T>();
return compute(assignment, domains, sets0, sets1, "");
}
private static <T> Map<T, Set<T>> computeInitialDomains(
Set<Set<T>> sets0, Set<Set<T>> sets1)
{
Set<T> all0 = flatten(sets0);
Set<T> all1 = flatten(sets1);
Map<T, Set<T>> domains = new LinkedHashMap<T, Set<T>>();
for (T e0 : all0)
{
Set<T> domain0 = new LinkedHashSet<T>();
for (T e1 : all1)
{
if (isFeasible(e0, sets0, e1, sets1))
{
domain0.add(e1);
}
}
domains.put(e0, domain0);
}
return domains;
}
private static <T> boolean isFeasible(
T e0, Set<Set<T>> sets0,
T e1, Set<Set<T>> sets1)
{
int c0 = countContaining(sets0, e0);
int c1 = countContaining(sets1, e1);
return c0 == c1;
}
private static <T> int countContaining(Set<Set<T>> sets, T value)
{
int count = 0;
for (Set<T> set : sets)
{
if (set.contains(value))
{
count++;
}
}
return count;
}
private static <T> boolean compute(
Map<T, T> assignment, Map<T, Set<T>> domains,
Set<Set<T>> sets0, Set<Set<T>> sets1, String indent)
{
if (!validCounts(domains.values()))
{
System.out.println(indent+"There are too many domains "
+ "with too few elements");
print(domains, indent);
return false;
}
if (assignment.keySet().equals(domains.keySet()))
{
System.out.println(indent+"Found assignment: "+assignment);
return true;
}
List<Entry<T, Set<T>>> entryList =
new ArrayList<Map.Entry<T,Set<T>>>(domains.entrySet());
Collections.sort(entryList, new Comparator<Map.Entry<T,Set<T>>>()
{
@Override
public int compare(Entry<T, Set<T>> e0, Entry<T, Set<T>> e1)
{
return Integer.compare(
e0.getValue().size(),
e1.getValue().size());
}
});
for (Entry<T, Set<T>> entry : entryList)
{
T key = entry.getKey();
if (assignment.containsKey(key))
{
continue;
}
Set<T> domain = entry.getValue();
for (T value : domain)
{
Map<T, Set<T>> newDomains = copy(domains);
removeFromOthers(newDomains, key, value);
assignment.put(key, value);
newDomains.get(key).clear();
newDomains.get(key).add(value);
System.out.println(indent+"Using "+assignment);
Set<Set<T>> setsContainingKey =
computeSetsContainingValue(sets0, key);
Set<Set<T>> setsContainingValue =
computeSetsContainingValue(sets1, value);
Set<T> keyElements = flatten(setsContainingKey);
Set<T> valueElements = flatten(setsContainingValue);
for (T otherKey : keyElements)
{
Set<T> otherValues = newDomains.get(otherKey);
otherValues.retainAll(valueElements);
}
System.out.println(indent+"Domains when "+assignment);
print(newDomains, indent);
boolean done = compute(assignment, newDomains,
sets0, sets1, indent+" ");
if (done)
{
return true;
}
assignment.remove(key);
}
}
return false;
}
private static boolean validCounts(
Collection<? extends Collection<?>> collections)
{
Map<Collection<?>, Integer> counts =
new LinkedHashMap<Collection<?>, Integer>();
for (Collection<?> c : collections)
{
Integer count = counts.get(c);
if (count == null)
{
count = 0;
}
counts.put(c, count+1);
}
for (Entry<Collection<?>, Integer> entry : counts.entrySet())
{
Collection<?> c = entry.getKey();
Integer count = entry.getValue();
if (count > c.size())
{
return false;
}
}
return true;
}
private static <K, V> Map<K, Set<V>> copy(Map<K, Set<V>> map)
{
Map<K, Set<V>> copy = new LinkedHashMap<K, Set<V>>();
for (Entry<K, Set<V>> entry : map.entrySet())
{
K k = entry.getKey();
Set<V> values = entry.getValue();
copy.put(k, new LinkedHashSet<V>(values));
}
return copy;
}
private static <T> Set<Set<T>> computeSetsContainingValue(
Iterable<? extends Set<T>> sets, T value)
{
Set<Set<T>> containing = new LinkedHashSet<Set<T>>();
for (Set<T> set : sets)
{
if (set.contains(value))
{
containing.add(set);
}
}
return containing;
}
private static <T> void removeFromOthers(
Map<T, Set<T>> map, T key, T value)
{
for (Entry<T, Set<T>> entry : map.entrySet())
{
if (!entry.getKey().equals(key))
{
Set<T> values = entry.getValue();
values.remove(value);
}
}
}
private static <T> Set<T> flatten(
Iterable<? extends Collection<? extends T>> collections)
{
Set<T> set = new LinkedHashSet<T>();
for (Collection<? extends T> c : collections)
{
set.addAll(c);
}
return set;
}
private static <T> Set<T> applyMapping(
Set<T> set, Map<T, T> map)
{
Set<T> result = new LinkedHashSet<T>();
for (T e : set)
{
result.add(map.get(e));
}
return result;
}
private static <T> boolean areIsomorphic(
Set<Set<T>> sets0, Set<Set<T>> sets1, Map<T, T> p)
{
for (Set<T> set0 : sets0)
{
Set<T> set1 = applyMapping(set0, p);
if (!sets1.contains(set1))
{
return false;
}
}
return true;
}
private static void print(Map<?, ?> map, String indent)
{
for (Entry<?, ?> entry : map.entrySet())
{
System.out.println(indent+entry.getKey()+": "+entry.getValue());
}
}
}
答案 1 :(得分：1)
我相信你的问题等同于图形同构问题（GI）。您的集合可以建模为（二分）图形，其中节点表示集合的基本值（例如，1,2,3，... 7），而右侧的节点表示集合（例如，{1 ，2,3,4,6}或{2,3,5,6,7}）。如果数字是集合的元素，则画一条边连接左边的节点和右边的节点;在我的例子中，1仅连接到{1,2,3,4,6}，而2连接到{1,2,3,4,6}和{2,3,5,6,7} 。 1包连接到包含它的所有组; {1,2,3,4,6}连接到其中包含的所有数字。
任何二分图都可以这种方式实现。相反，GI可以简化为在二分图上求解GI。 （任何图形都可以通过用两个新边和一个新顶点替换每个边来形成二分图。得到的二分图中的同构等价于原始图中的同构。）
GI是在NP中，但不知道NP是否完整。在实践中，GI可以快速解决数百个顶点，例如NAUTY。