POJ 1482 HASH+BFS

It's not a Bug, It's a Feature!

Time Limit: 5000MS		Memory Limit: 30000K
Total Submissions: 1141		Accepted: 438

Description

It is a curious fact that consumers buying a new software product generally do not expect the software to be bug-free. Can you imagine buying a car whose steering wheel only turns to the right? Or a CD-player that plays only CDs with country music on them? Probably not. But for software systems it seems to be acceptable if they do not perform as they should do. In fact, many software companies have adopted the habit of sending out patches to fix bugs every few weeks after a new product is released (and even charging money for the patches). Tinyware Inc. is one of those companies. After releasing a new word processing software this summer, they have been producing patches ever since. Only this weekend they have realized a big problem with the patches they released. While all patches fix some bugs, they often rely on other bugs to be present to be installed. This happens because to fix one bug, the patches exploit the special behavior of the program due to another bug. 
 More formally, the situation looks like this. Tinyware has found a total  of n bugs B = {b1, b2, ..., bn} in their software. And they have released m  patches p1, p2, ..., pm. To apply patch pi to the software, the bugs  Bi+ in B have to be present in the software, and the bugs  Bi- in B must be absent (of course Bi+ ∩ Bi- =  Φ). The patch then fixes the bugs Fi- in B (if they have been  present) and introduces the new bugs Fi+ in B (where, again,  Fi+ ∩ Fi- = Φ). 
Tinyware's problem is a simple  one. Given the original version of their software, which contains all the bugs  in B, it is possible to apply a sequence of patches to the software which  results in a bug- free version of the software? And if so, assuming that every  patch takes a certain time to apply, how long does the fastest sequence take? 

Input

The input contains several product descriptions. Each description starts with a line containing two integers n and m, the number of bugs and patches, respectively. These values satisfy 1 <= n <= 20 and 1 <= m <= 100. This is followed by m lines describing the m patches in order. Each line contains an integer, the time in seconds it takes to apply the patch, and two strings of n characters each. 
The first of these strings  describes the bugs that have to be present or absent before the patch can be  applied. The i-th position of that string is a ``+'' if bug bi has to be  present, a ``-'' if bug bi has to be absent, and a `` 0'' if it doesn't matter  whether the bug is present or not. 
The second string describes which  bugs are fixed and introduced by the patch. The i-th position of that string is  a ``+'' if bug bi is introduced by the patch, a ``-'' if bug bi is removed by  the patch (if it was present), and a ``0'' if bug bi is not affected by the  patch (if it was present before, it still is, if it wasn't, is still isn't). 
 The input is terminated by a description starting with n = m = 0. This  test case should not be processed. 

Output

For each product description first output the number of the product. Then output whether there is a sequence of patches that removes all bugs from a product that has all n bugs. Note that in such a sequence a patch may be used multiple times. If there is such a sequence, output the time taken by the fastest sequence in the format shown in the sample output. If there is no such sequence, output ``Bugs cannot be fixed.''. 
Print a blank  line after each test case. 

Sample Input

3 3
1 000 00-
1 00- 0-+
2 0-- -++
4 1
7 0-0+ ----
0 0

Sample Output

Product 1
Fastest sequence takes 8 seconds.

Product 2
Bugs cannot be fixed.

Source

Southwestern European Regional Contest 1998

  1 #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
#include <queue>
using namespace std;

class Patch
{
public:
    int t;
    int bug_1;    // 0变0
    int bug_2;    // 0变1
    int result_1; // 0变0
    int result_2; // 0变1
    void set(const int & num,const string & s1,const string & s2)
    {
        t=num;
        bug_1=bug_2=0;
        result_1=result_2=0;
        setBug_1(s1);
        setBug_2(s1);
        setResult_1(s2);
        setResult_2(s2);
    }
    void setBug_1(const string & str)
    {
        for(unsigned int j=0;j<str.size();j++)
        {
            bug_1*=2;
            if(str[j]=='+')
            {
                bug_1+=1;
            }
        }
    }
    void setBug_2(const string & str)
    {
        for(unsigned int j=0;j<str.size();j++)
        {
            bug_2*=2;
            if(str[j]!='-')
            {
                bug_2+=1;
            }
        }
    }
    int getResult(const int & cur) const
    {
        return (cur&result_2)|result_1;
    }
    void setResult_1(const string & str)
    {

        for(unsigned int j=0;j<str.size();j++)
        {
            result_1*=2;
            if(str[j]=='+')
            {
                result_1+=1;
            }
        }
    }
    void setResult_2(const string & str)
    {
        for(unsigned int j=0;j<str.size();j++)
        {
            result_2*=2;
            if(str[j]!='-')
            {
                result_2+=1;
            }
        }
    }
    bool isMatch(const int & n,const int & cur)
    {
        if(((((1<<n)-1)-(bug_2-bug_1))&cur)==bug_1)
        {
            return true;
        }
        return false;
    }
    bool operator()(const Patch & x,const Patch & y) const
    {
        return x.t<y.t?1:0;
    }
};

int main()
{
    int n,m,Case=0;
    unsigned int i;
    while(cin>>n>>m)
    {
        if(!n&&!m) break;
        int k,x,cur=(1<<n)-1;
        string s1,s2;
        vector<Patch> v(m);
        vector<int> mark(1<<n,0);
        vector<int> result(1<<n,0);
        mark[cur]=1;
        for(k=0;k<m;k++)
        {
            cin>>x>>s1>>s2;
            v[k].set(x,s1,s2);
        }
        sort(v.begin(),v.end(),Patch());
        queue<int> q;
        q.push(cur);
        bool flag=false;
        int minResult=-1;
        while(!q.empty())
        {
            int xv=q.front();
            q.pop();
            for(i=0;i<v.size();i++)
            {
                if(v[i].isMatch(n,xv))
                {
                    int xk=v[i].getResult(xv);
                    if(xk==0)
                    {
                        if(minResult==-1) minResult=result[xv]+v[i].t;
                        else minResult=min(minResult,result[xv]+v[i].t);
                        flag=true;
                        continue;
                    }
                    if(mark[xk]!=0&&result[xk]<=result[xv]+v[i].t) continue;
                    mark[xk]=1;
                    result[xk]=result[xv]+v[i].t;
                    q.push(xk);
                }
            }
        }
        cout<<"Product "<<++Case<<endl;
        if(flag)
        {
            cout<<"Fastest sequence takes "<<minResult<<" seconds."<<endl;
        }
        else
        {
            cout<<"Bugs cannot be fixed."<<endl;
        }
        cout<<endl;
    }
    return 0;
}