在朋友QQ空间看到一道题，如下：
当时顺手画了条数轴，在数轴上标出了各个算式的解的特点：和为7的算式的解关于4对称,和为9的解关于5对称等等。草草算了下，发现很难同时满足5个条件。而细算又太麻烦，算了，反正是程序员，写程序求解吧。
因为是4个算式，很自然的就想到穷举法。将每个算式可能的结果放在一起算笛卡尔积，如果有解的话，则必然存在一个笛卡尔积里面存在1到8这8个不同的元素。
计算笛卡尔积的代码如下：
/// <summary>/// 计算元素集列表的笛卡尔积/// </summary>/// <typeparam name="T">元素具体类型</typeparam>/// <param name="sets">元素集列表</param>/// <returns>笛卡尔积列表</returns>public static T[][] CalculateCartesianPRoduct<T>(this IList<IList<T>> sets){ // 笛卡尔积总数 int total = 1; // 元素集个数 int setCount = 0; foreach (var set in sets) { total *= set.Count; setCount++; } // 笛卡尔积列表 var products = new T[total][]; // 除数列表，用于计算每个笛卡尔积的情况 var dividers = new int[setCount]; int divider = 1; // 倒序循环，因为后面的多种情况对应前面的一种情况 for (int counter = setCount - 1; counter >= 0; counter--) { dividers[counter] = divider; divider *= sets[counter].Count; } // 计算笛卡尔积,共有permutationNumber个笛卡尔积, // 从0到permutationNumber中,每个数字对应一种笛卡尔积情况 for (int counter = 0; counter < total; counter++) { // 一个笛卡尔积的情况 var permutation = new T[setCount]; int index = 0; foreach (var set in sets) { // 将数字映射到元素集中的位置 var pos = (counter / dividers[index]) % set.Count; permutation[index] = set[pos]; index++; } products[counter] = permutation; } return products;}
原理是将笛卡尔积解的总个数里的每个数字映射到一个解。
比如前面几个笛卡尔积如下：
[2, 1] [3, 1] [1, 6] [1, 8]
[2, 1] [3, 1] [1, 6] [2, 7]
[2, 1] [3, 1] [1, 6] [3, 6]
[2, 1] [3, 1] [1, 6] [4, 5]
[2, 1] [3, 1] [2, 5] [1, 8]
[2, 1] [3, 1] [2, 5] [2, 7]
[2, 1] [3, 1] [2, 5] [3, 6]
[2, 1] [3, 1] [2, 5] [4, 5]
后面我又想到，实际上计算全排列也可以解决此题。将1到8取全排列，如果此题有解的话，则必然存在一个全排列，使得每两个元素为一对，依次满足4个算式。
代码如下：
/// <summary>/// 计算指定元素集的全排列/// </summary>/// <typeparam name="T">元素的具体类型</typeparam>/// <param name="collection">元素集</param>/// <returns>全排列</returns>public static IEnumerable<T[]> CalculatePermutationCrude<T>(ICollection<T> collection){ // 元素个数 int elementCount = collection.Count(); // 全排列列表 var permutations = new List<T[]>(); // 一个全排列 var permutation = new List<T>(); CalculatePermutationCrude(permutations, permutation, collection, elementCount); return permutations;}/// <summary>/// 计算指定元素集的全排列/// </summary>/// <typeparam name="T">元素的具体类型</typeparam>/// <param name="permutations">全排列列表</param>/// <param name="permutation">一个全排列</param>/// <param name="collection">元素集</param>/// <param name="setLength">集合长度</param>private static void CalculatePermutationCrude<T>( List<T[]> permutations, List<T> permutation, ICollection<T> collection, int setLength){ if (permutation.Count < setLength) { foreach (var item in collection) { // 不是可重排列,不能包含 if (!permutation.Contains(item)) { var temp = permutation.ToList(); temp.Add(item); if (temp.Count == setLength) { // 达到最大计算深度,表示完成一个全排列,添加 permutations.Add(temp.ToArray()); } else { CalculatePermutationCrude(permutations, temp, collection, setLength); } } } }}
原理是有多少个元素，就循环多少次，将包含重复元素的排列剔除掉，自然就是集合的全排列了。
代码如下：
/// <summary> /// 计算指定元素集的全排列 /// </summary> /// <typeparam name="T">元素的具体类型</typeparam> /// <param name="set">元素集</param> /// <returns>全排列</returns> public static IEnumerable<T[]> CalculatePermutationDFS<T>(IEnumerable<T> set) { var permutations = new List<T[]>(); var path = new List<T>(); bool[] visited = new bool[set.Count()]; CalculatePermutationDFS(set, permutations, path, visited); return permutations; } /// <summary> /// 计算指定元素集的全排列 /// </summary> /// <typeparam name="T">元素的具体类型</typeparam> /// <param name="set">元素集</param> /// <param name="permutations">全排列</param> /// <param name="path">排列的元素列表</param> /// <param name="visited">元素访问与否的数组</param> private static void CalculatePermutationDFS<T>( IEnumerable<T> set, List<T[]> permutations, List<T> path, bool[] visited) { if (path.Count == set.Count()) { permutations.Add(path.ToArray()); } for (int i = 0; i < set.Count(); i++) { if (!visited[i]) { path.Add(set.ElementAt(i)); visited[i] = true; CalculatePermutationDFS(set, permutations, path, visited); path.RemoveAt(path.Count - 1); visited[i] = false; } } }
在代码中使用了一个辅助列表保存遍历过的元素，一个辅助数组保存元素的访问情况，在深度遍历前设置相关信息，遍历完成后重置相关信息。
上面的两种解法使用了递归，众所周知，全排列的个数为待排列个数的阶乘。而在数据量较大时，阶乘比指数爆炸更可怕。如果不使用自建堆栈，将递归化为迭代，有没有其他办法计算全排列，就像前面计算笛卡尔积一样，将每个数字映射到一个解。经过多次试错，总算被我想到了一个办法。
将每一个全排列对应一个数，以1234为例，如下图：
将每个序号（从0开始）对应到一个数。对应数的有如下规律：
终于可以上代码了：
/// <summary> /// 计算指定元素集的全排列 /// </summary> /// <typeparam name="T">元素的具体类型</typeparam> /// <param name="collection">元素集</param> /// <returns>全排列</returns> public static IEnumerable<T[]> CalculatePermutation<T>(IList<T> collection) { // 全排列总数 int total = 1; // 元素个数 int elementCount = collection.Count; // 除数列表，用于计算每个全排列的情况 var dividers = new int[elementCount - 1]; for (int i = 2; i <= elementCount; i++) { dividers[i - 2] = total; total *= i; } // 全排列列表 var permutations = new T[total][]; // 计算全排列,共有permutationNumber个全排列, // 从0到permutationNumber中,每个数字对应一种全排列情况 for (int counter = 0; counter < total; counter++) { // 一个全排列的情况 var permutation = new T[elementCount]; // 指示数组，指示全排列对应元素集中的位置 var indicates = new int[elementCount - 1]; // 使用数组，指示元素集中对应的元素是否已使用 var usedFlags = new bool[elementCount]; for (int j = 0; j < elementCount - 1; j++) { // 从右向左计算 indicates[elementCount - 2 - j] = (counter / dividers[j]) % (j + 2); } // 全排列的索引 int index = 0; foreach (var indicate in indicates) { int pos = 0; // 统计未使用的元素 int unusedCount = -1; for (; pos < elementCount; pos++) { if (!usedFlags[pos]) { unusedCount++; } // 找到了要放入的元素位置 if (unusedCount >= indicate) { break; } } permutation[index] = collection[pos]; usedFlags[pos] = true; index++; } // 将最后剩余的元素放入全排列 for (int j = 0; j < elementCount; j++) { if (!usedFlags[j]) { permutation[elementCount - 1] = collection[j]; break; } } permutations[counter] = permutation; } return permutations; }
经过一番劳累，结局是悲伤的，答案就是没有答案。可能有的朋友会说特殊运算，由于题目的限制，幂跟对数是不可能了，唯一能够使用的特殊运算就只有平方，在这种情况下，依然没有答案。当然，如果你硬要说立方也是特殊运算，那么还是有解的。
此刻我的内心是崩溃的
新闻热点
疑难解答
