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] );

        }

    }

}