求拓扑排序的数量，例题 topcoder srm 654 div2 500

周赛时遇到的一道比较有意思的题目:

 

Problem Statement

There are N rooms in Maki's new house. The rooms are numbered from 0 to N-1. Some pairs of rooms are connected by bidirectional passages. The passages have the topology of a tree. That is, there are exactly N-1 of them and it is possible to go from any room to any other room by following some sequence of passages.

You are given two vector <int>s a and b that describe the passages. For each valid i, there is a passage that connects the rooms a[i] and b[i]. You are also given an int s. The house has exactly one entrance from the outside, and the entrance leads to the room s.

Niko is helping Maki move into the new house. Maki has exactly N pieces of furniture. The pieces are numbered from 0 to N-1. Niko will carry them into the house in this order. Each piece of furniture must be placed into a different room. Maki does not care which piece goes where, each of the N! permutations is allowed.

However, not all of those N! permutations are actually possible. This is because the furniture is large. As soon as a room contains a piece of furniture, it is impossible to move other pieces through this room. Thus, Niko must place the furniture carefully. Formally, she can place a new piece of furniture into the room x if and only if all rooms on the (unique) path between s and x, including s and x, are still empty. Niko is smart and she will always place the furniture in such a way that she never gets stuck. Thus, at the end each of Maki's rooms will contain exactly one piece of furniture.

Calculate and return the number of ways how the furniture can be arranged in Maki's house at the end.

Definition

Class:	OneEntrance
Method:	count
Parameters:	vector <int>, vector <int>, int
Returns:	int
Method signature:	int count(vector <int> a, vector <int> b, int s)
(be sure your method is public)

Limits

Time limit (s):	2.000
Memory limit (MB):	256
Stack limit (MB):	256

Constraints

-

N will be between 1 and 9, inclusive.

-

a and b will contain exactly N-1 elements each.

-

Each element of a and b will be between 0 and N-1, inclusive.

-

The graph described by a and b will be a tree.

-

s will be between 0 and N-1, inclusive.

Examples

0)

{0, 1, 2}

{1, 2, 3}

0

Returns: 1

There is only one solution: Niko must fill the rooms in the order {3,2,1,0}. Thus, piece number 0 will end in room 3, piece number 1 in room 2, and so on.

1)

{0, 1, 2}

{1, 2, 3}

2

Returns: 3

In this case Niko can choose one of three orders: {3,0,1,2}, {0,3,1,2}, or {0,1,3,2}. Note that the room with the entrance (in this case, room 2) always gets the last piece of furniture.

2)

{0, 0, 0, 0}

{1, 2, 3, 4}

0

Returns: 24

3)

{7, 4, 1, 0, 1, 1, 6, 0}

{6, 6, 2, 5, 0, 3, 8, 4}

4

Returns: 896

4)

{}

{}

0

Returns: 1

Maki's new house has only one room.

This problem statement is the exclusive and proprietary property of TopCoder, Inc. Any unauthorized use or reproduction of this information without the prior written consent of TopCoder, Inc. is strictly prohibited. (c)2003, TopCoder, Inc. All rights reserved.    

 

这道题目也等同于：

假设一个Tree含有N个结点，现在有N个数字 1-N，将这个Tree的N个结点用这N个数字编号，要求父结点一定要大于子结点的编号，一共有多少种编号方式。

 

这种题目都可以抽象为一个问题：求一个Tree 所有结点的拓扑序列的个数。

求解方式可以用DFS来做：

另int Func() 表示当前Tree 的拓扑排序数量，Func() 可以这么计算：找到当前Tree中所有入度为0的结点，假设有K个这样的结点，对于每个这样的结点，从Tree去掉从该结点出发的边，然后算出去掉边后的Tree 对应的Func()。子Func()的结果的总和，就是 父Func()的结果。

当所有结点都遍历过时，Func() 返回 1

题目中的图表示是用两个vector 表示，所以要先根据这两个vector 构建出单向邻接矩阵 conn[][]

#include<iostream>
#include<vector>
#include<string.h>
using namespace std;

class OneEntrance{
public:
    int count(vector <int> a, vector <int> b, int s){
        N = a.size() + 1;
        if(N <= 1) return N;
        memset(conn, 0, sizeof(conn));
        memset(visit, 0, sizeof(visit));
        dfsconn(a, b, s, -1);    //use a, b to create adjacency matrix(mono-directed)
        return dfscount(conn);    //based on matrix, get the total amount of topological sequence.
    }
private:
    bool conn[9][9];
    bool visit[9];
    int N = 0;
    void dfsconn(vector<int> &a, vector<int> &b, int cur, int pre){
        for(int i = 0; i < a.size(); ++i){
            if(a[i] == cur && b[i] != pre){
                conn[a[i]][b[i]] = true;
                dfsconn(a, b, b[i], cur);
            }
            if(b[i] == cur && a[i] != pre){
                conn[b[i]][a[i]] = true;
                dfsconn(a, b, a[i], cur);
            }
        }
    }
    int dfscount(bool conn[][9]){
        int i, j, zdgrcnt, cnt = 0;
        for(i = 0; i < N; ++i) cnt += (!visit[i] ? 1 : 0);
        if(cnt == 0) return 1;
        cnt = 0;
        for(i = 0; i < N; ++i){
            if(visit[i]) continue;
            zdgrcnt = 0;
            for(j = 0; j < N; ++j){
                zdgrcnt += (conn[j][i] ? 1 : 0);
            }
            if(zdgrcnt == 0){    //found one node whose in-order degree is zero
                visit[i] = true;
                vector<bool> tmp(N, false);
                for(j = 0; j < N; ++j){
                    if(conn[i][j]){
                        tmp[j] = true;
                        conn[i][j] = false;    //remove its out-order edge.
                    }
                }
                cnt += dfscount(conn);
                for(j = 0; j < N; ++j){
                    if(tmp[j]) conn[i][j] = true;
                }
                visit[i] = false;
            }
        }
        return cnt;
    }
};

 

dfs 中包含了很多重复计算，毕竟是递归。

动态规划的解法可以参考对 HDU 4661 这一题的解答

传送门： http://www.cnblogs.com/GBRgbr/p/3312866.html