[TC SRM 685 div1 lev1] MultiplicationTable2

转载： https://www.linkedin.com/pulse/topcoder-685-multiplicationtable2-yingwu-zhu

Note: 生成封闭集合方式。

Problem
Fox Ciel is creating a new binary operation.
The operation will be denoted $ and it will be defined on the finite set S = {0, 1, 2, ..., n-1}. I.e., for each ordered pair (i, j) of elements of S the operation (i $ j) will return some element of S.
For example, we can have S = {0, 1}, and we can define that (0 $ 0) = 0, (0 $ 1) = 1, (1 $ 0) = 0, and (1 $ 1) = 0.
Note that Ciel's operation is not necessarily symmetric. In other words, it is possible that for some i and j the operations (i $ j) and (j $ i) return two different values.
A nice concise description of the operation $ is its "multiplication table": a square table where in row i and column j we have the value (i $ j). You are given this "multiplication table" encoded as a int[] table with n^2 elements. For each valid i and j the operation (i $ j) returns the value table[i*n+j].
A subset T of S is called good if it has the following property: for any two elements i and j in T, (i $ j) is also in T.
Find and return the minimal size of a good subset of S. Note that the answer is always defined, as there always are some good subsets. For example, the entire set S is always good.
Constraints:
-- n will be between 1 and 50, inclusive
-- table will contain exactly n*n elements
-- Each element in table will be between 0 and n-1, inclusive

My Solution:
Picture the final solution
Suppose we have found the final solution S. What property does S have? 
Yes. All elements in S must be unique in [0, n-1]. More importantly, we can have some element as the smallest element!
So, we can brute force all possible solutions with each element in [0, n-1] as the smallest element in their final solutions. Then take the minimum of all.

Solve a sub-problem
Let a solution S with i as the smallest element.
(1) if i $ i = i, then we are done
otherwise
(2) if i $ i = j, then
(2.1) if j < i, no solution.
Otherwise
(2.2) Then we can use the new element j to find other elements in S.
In implementation, we can use set<int> to maintain the newly found elements, a vector<int> to maintain S. The complexity is O(n^2).

Putting all together
We iterate all i in [0, n-1] and solve each subproblems as described above. We keep the minimum set size. The time complexity = O(n^3).

Example Code:

using namespace std;
#define REP(i,a,b)  for (int i = int(a); i < int(b); i++)
int sol2() {
    int n = (int)sqrt(sizeof(tab) / sizeof(int));
    int ret = n;
    bool flag[n];
    REP(i, 0, n) {
        memset(flag, false, sizeof(flag));
        set<int> S;
        S.insert(i);
        vector<int> A;
        bool ok = true;
        while (!S.empty() && ok && A.size() < ret) {
            int x = *S.begin();
            flag[x] = true;
            A.push_back(x);
            S.erase(S.begin());
            REP(j, 0, A.size()) {
                int y = tab[A[j] * n + x];
                if (y < i) {
                    ok = false;     break;
                }
                if (!flag[y])
                    S.insert(y);
                y = tab[x*n + A[j]];
                if (y < i) {
                    ok = false;     break;
                }
                if (!flag[y])
                    S.insert(y);
            }
        }
        if (ok)
            ret = min(ret, (int)A.size());
    }
    return ret;
}