Uva 11825 Hackers' Crackdown 状态压缩

Problem H

Hackers’ Crackdown 
Input: Standard Input

Output: Standard Output

 

Miracle Corporations has a number of system services running in a distributed computer system which is a prime target for hackers. The system is basically a set of N computer nodes with each of them running a set of N services. Note that, the set of services running on every node is same everywhere in the network. A hacker can destroy a service by running a specialized exploit for that service in all the nodes.

One day, a smart hacker collects necessary exploits for all these N services and launches an attack on the system. He finds a security hole that gives him just enough time to run a single exploit in each computer. These exploits have the characteristic that, its successfully infects the computer where it was originally run and all the neighbor computers of that node.

Given a network description, find the maximum number of services that the hacker can damage.

Input

There will be multiple test cases in the input file. A test case begins with an integer N (1<=N<=16), the number of nodes in the network. The nodes are denoted by 0 to N - 1. Each of the following N lines describes the neighbors of a node. Line i (0<=i<N) represents the description of node i. The description for node i starts with an integer m (Number of neighbors for node i), followed by m integers in the range of 0 to N - 1, each denoting a neighboring node of node i.

The end of input will be denoted by a case with N = 0. This case should not be processed.

Output

For each test case, print a line in the format, “Case X: Y”, where X is the case number & Y is the maximum possible number of services that can be damaged.

                                                 

Sample Input	Output for Sample Input
3 2 1 2 2 0 2 2 0 1 4 1 1 1 0 1 3 1 2 0	Case 1: 3 Case 2: 2

---

Problemsetter: Mohammad Mahmudur Rahman

Special Thanks  Manzurur Rahman Khan

----------

把n个集合p1,p2...,pn分成尽量多组，使得每组中所有集合的并集等于全集。

p[i]表示i与其相邻计算机的集合

cover[s]表示若干p[i]集合的并集

f[s]表示子集s最多可以分成多少组

f[s]=max{ f[s0]|s0是s的子集,cover[s0]等于全集 }+1;

----------

#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;

const int maxn=18;
const int maxs=1<<18;

int f[maxs];
int p[maxn];
int cover[maxs];
int n;

int main()
{
    int cas=0;
    while (~scanf("%d",&n))
    {
        if (n==0) break;
        for (int i=0;i<n;i++)
        {
            int m,x;
            scanf("%d",&m);
            p[i]=1<<i;
            while (m--)
            {
                scanf("%d",&x);
                p[i]|=(1<<x);
            }
        }
        for (int s=0;s<(1<<n);s++)
        {
            cover[s]=0;
            for (int i=0;i<n;i++)
            {
                if (s&(1<<i))
                {
                    cover[s]|=p[i];
                }
            }
        }
        f[0]=0;
        int ALL=(1<<n)-1;
        for (int s=1;s<(1<<n);s++)
        {
            f[s]=0;
            for (int s0=s;s0;s0=(s0-1)&s)
            {
                if (cover[s0]==ALL)
                {
                    f[s]=max(f[s],f[s^s0]+1);
                }
            }
        }
        printf("Case %d: %d\n",++cas,f[ALL]);
    }
    return 0;
}