SRM 581 D2 L3：TreeUnionDiv2，Floyd算法

题目来源：http://community.topcoder.com//stat?c=problem_statement&pm=12587&rd=15501

这道题目开始以为是要在无向图中判断环，而且要找出环的大小，后来看了解析之后才发现原来使用一个Floyd算法就搞定了，因为题目中加了很多限制，并不真的需要在一个任意的无向图中求 指定大小的环的数量。生成所有的排列组合可以使用C++ STL提供的std::next_permutation 算法，非C++使用backtrack，具体实现可以参考解析。

代码如下：

#include <algorithm>

#include <iostream>
#include <sstream>
#include <string>
#include <vector>
#include <stack>
#include <deque>
#include <queue>
#include <set>
#include <map>

#include <cstdio>
#include <cstdlib>
#include <cctype>
#include <cmath>
#include <cstring>

using namespace std;

/*************** Program Begin **********************/

int disA[9][9], disB[9][9];
int P[9];
const int INF = 1000;
class TreeUnionDiv2 {
public:
int maximumCycles(vector <string> tree1, vector <string> tree2, int K) {
int res = 0;
int vex = tree1.size();
for (int i = 0; i < 9; i++) {
P[i] = i;
}
for (int i = 0; i < vex; i++) {
for (int j = 0; j < vex; j++) {
if ('X' == tree1[i][j]) {
disA[i][j] = 1;
} else {
disA[i][j] = INF;
}
if ('X' == tree2[i][j]) {
disB[i][j] = 1;
} else {
disB[i][j] = INF;
}
}
}

for (int k = 0; k < vex; k++) {
for (int i = 0; i < vex; i++) {
for (int j = 0; j < vex; j++){
if ( disA[i][j] > disA[i][k] + disA[k][j] ) {
disA[i][j] = disA[i][k] + disA[k][j];
}
if ( disB[i][j] > disB[i][k] + disB[k][j] ) {
disB[i][j] = disB[i][k] + disB[k][j];
}
}
}
}

do {
int c = 0;
for (int i = 0; i < vex; i++) {
for (int j = i+1; j < vex; j++) {
if (disA[i][j] + disB[ P[i] ][ P[j] ] + 2 == K) {
++c;
}
}
}
res = max(res, c);
} while (next_permutation(P, P + vex));

return res;
}
};

/************** Program End ************************/

下面为使用 backtrack 实现的全部排列组合：

// This recursive function's only duty is to generate all the possible
// permutations P[].
void backtrack(int i)
{
if (i == N-1) {
//found a permutation, remember the best number of cycles:
best = std::max(best, countCycles() );
} else {
for (int j=i; j<N; j++) {
// Place P[j] in position i, move P[i] to P[j]:
std::swap( P[i], P[j] );
// Continue the backtracking search:
backtrack(i+1);
// Restore the positions of P[i] and P[j]:
std::swap( P[j], P[i] );
}
}
}