ACM学习历程—ZOJ3777 Problem Arrangement（递推 && 状压）

Description

The 11th Zhejiang Provincial Collegiate Programming Contest is coming! As a problem setter, Edward is going to arrange the order of the problems. As we know, the arrangement will have a great effect on the result of the contest. For example, it will take more time to finish the first problem if the easiest problem hides in the middle of the problem list.

There are N problems in the contest. Certainly, it's not interesting if the problems are sorted in the order of increasing difficulty. Edward decides to arrange the problems in a different way. After a careful study, he found out that the i-th problem placed in the j-th position will add P_ij points of "interesting value" to the contest.

Edward wrote a program which can generate a random permutation of the problems. If the total interesting value of a permutation is larger than or equal to M points, the permutation is acceptable. Edward wants to know the expected times of generation needed to obtain the first acceptable permutation.

Input

There are multiple test cases. The first line of input contains an integer T indicating the number of test cases. For each test case:

The first line contains two integers N (1 <= N <= 12) and M (1 <= M <= 500).

The next N lines, each line contains N integers. The j-th integer in the i-th line is P_ij (0 <= P_ij <= 100).

Output

For each test case, output the expected times in the form of irreducible fraction. An irreducible fraction is a fraction in which the numerator and denominator are positive integers and have no other common divisors than 1. If it is impossible to get an acceptable permutation, output "No solution" instead.

Sample Input

2
3 10
2 4 1
3 2 2
4 5 3
2 6
1 3
2 4

Sample Output

3/1
No solution

题目大意是求每行每列取一个数，然后求和，求其和大于等于m的概率。

首先一行一行取下去，取法满足乘法运算，一共有n!种，n取12的话，12！=479001600，这么大取几遍肯定T了。

而且n!个状态是互不相异的状态，状态个数是减不下了的。

于是只能考虑如何合并一些状态。

按行取的话，我第一行取第一个，第二行取第三个，或者第一行取第三个，第二行取第一个，

这两种取法虽然不同，但是达到了一个效果，就是往后的行不能再取第一列和第三列。

于是我考虑把取过相同列的状态合并为一个状态。

于是考虑这样一个状态p[state][w]表示取到state状态，能取到和为w的取法数。

那么state为1的位表示取了那一列的数，为0表示没取。

且设当前取到了cnt行，cnt是state里面1的个数。

于是p[state|(1<<i)][w+a[cnt+1][i]] += p[state][w]，表示由state状态更新state|(1<<i)状态，前提是state的第i位为0。

这样的话，本来后一个状态需要遍历前一个状态来求和，现在由前一个状态来更新后一个状态，每个状态便只需要遍历一次了。

这个状态的遍历此处采用了bfs。

bfs每个状态进队一次，然后遍历每一位需要O(n)，遍历每个w需要O(m)，

总复杂度是O(n*m(2^n))，最高是12*500*2^12=24576000，复杂度减了一个数量级。

代码：

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <set>
#include <map>
#include <queue>
#include <string>
#include <algorithm>
#define LL long long

using namespace std;

typedef pair<int, int> pii;
int n, m, a[][];
int p[(<<)+][], to, all;
bool vis[(<<)+];

void input()
{
    scanf("%d%d", &n, &m);
    for (int i = ; i <= n; ++i)
        for (int j = ; j <= n; ++j)
            scanf("%d", &a[i][j]);
    memset(p, , sizeof(p));
    memset(vis, false, sizeof(vis));
    p[][] = ;
    to = ;
    all = ;
    for (int i = ; i <= n; ++i)
    {
        to |= (<<i);
        all *= i;
    }
}

//GCD
//求最大公约数
//O(logn)
int gcd(int a, int b)
{
    if (b == )
    return a;
    else
    return gcd(b, a%b);
}

void bfs()
{
    queue<pii> q;
    q.push(pii(, ));
    vis[] = true;
    pii now;
    int k, cnt;
    while (!q.empty())
    {
        now = q.front();
        q.pop();
        k = now.first;
        cnt = now.second;
        vis[k] = false;
        for (int i = ; i <= n; ++i)
        {
            if (k&(<<i))
                continue;
            for (int v = ; v <= m; ++v)
            {
                if (p[k][v] == )
                    continue;
                p[k|(<<i)][v+a[cnt+][i]] += p[k][v];
                if (!vis[k|(<<i)] && cnt+ != n)
                {
                    q.push(pii(k|(<<i), cnt+));
                    vis[k|(<<i)] = true;
                }
            }
        }
    }
}

void work()
{
    bfs();
    int ans = , d;
    for (int i = ; i < m; ++i)
        ans += p[to][i];
    ans = all-ans;
    d = gcd(all, ans);
    if (ans == )
        printf("No solution\n");
    else
        printf("%d/%d\n", all/d, ans/d);
}

int main()
{
    //freopen("test.in", "r", stdin);
    int T;
    scanf("%d", &T);
    for (int times = ; times < T; ++times)
    {
        input();
        work();
    }
    return ;
}