UVA506-System Dependencies(拓扑序)

Problem UVA506-System Dependencies

Accept：285  Submit：2824

Time Limit: 3000 mSec

Problem Description

Components of computer systems often have dependencies—other components that must be installed before they will function properly. These dependencies are frequently shared by multiple components. For example, both the TELNET client program and the FTP client program require that the TCP/IP networking software be installed before they can operate. If you install TCP/IP and the TELNET client program, and later decide to add the FTP client program, you do not need to reinstall TCP/IP.
For some components it would not be a problem if the components on which they depended were reinstalled; it would just waste some resources. But for others, like TCP/IP, some component configuration may be destroyed if the component was reinstalled.
It is useful to be able to remove components that are no longer needed. When this is done, components that only support the removed component may also be removed, freeing up disk space, memory, and other resources. But a supporting component, not explicitly installed, may be removed only if all components which depend on it are also removed. For example, removing the FTP client program and TCP/IP would mean the TELNET client program, which was not removed, would no longer operate. Likewise, removing TCP/IP by itself would cause the failure of both the TELNET and the FTP client programs. Also if we installed TCP/IP to support our own development, then installed the TELNET client (which depends on TCP/IP) and then still later removed the TELNET client, we would not want TCP/IP to be removed.
We want a program to automate the process of adding and removing components. To do this we will maintain a record of installed components and component dependencies. A component can be installed explicitly in response to a command (unless it is already installed), or implicitly if it is needed for some other component being installed. Likewise, a component, not explicitly installed, can be explicitly removed in response to a command (if it is not needed to support other components) or implicitly removed if it is no longer needed to support another component. Installing an already implicitly-installed component won’t make that component become explicity installed.

 Input

The input file contains several test cases, each of them as described below. The input will contain a sequence of commands (as described below), each on a separate line containing no more than eighty characters. Item names are case sensitive, and each is no longer than ten characters. The command names (DEPEND, INSTALL, REMOVE and LIST) always appear in uppercase starting in column one, and item names are separated from the command name and each other by one or more spaces. All appropriate DEPEND commands will appear before the occurrence of any INSTALL command that uses them. There will be

 Output

For each test case, the output must follow the description below. Echo each line of input. Follow each echoed INSTALL or REMOVE line with the actions taken in response, making certain that the actions are given in the proper order. Also identify exceptional conditions (see Sample Output, below, for examples of all cases). For the LIST command, display the names of the currently installed components in the installation order. No output, except the echo, is produced for a DEPEND command or the line containing END. There will be at most one dependency list per item.

 Sample Input

DEPEND TELNET TCPIP NETCARD
DEPEND TCPIP NETCARD
DEPEND DNS TCPIP NETCARD
DEPEND BROWSER TCPIP HTML
INSTALL NETCARD
INSTALL TELNET
INSTALL foo
REMOVE NETCARD
INSTALL BROWSER
INSTALL DNS
LIST
REMOVE TELNET
REMOVE NETCARD
REMOVE DNS
REMOVE NETCARD
INSTALL NETCARD
REMOVE TCPIP
REMOVE BROWSER
REMOVE TCPIP
END
 

 

 Sample Ouput

DEPEND TELNET TCPIP NETCARD
DEPEND TCPIP NETCARD
DEPEND DNS TCPIP NETCARD
DEPEND BROWSER TCPIP HTML
INSTALL NETCARD
   Installing NETCARD
INSTALL TELNET
   Installing TCPIP
   Installing TELNET
INSTALL foo
   Installing foo
REMOVE NETCARD
   NETCARD is still needed.
INSTALL BROWSER
   Installing HTML
   Installing BROWSER
INSTALL DNS
   Installing DNS
LIST
   NETCARD
   TCPIP
   TELNET
   foo
   HTML
   BROWSER
   DNS
REMOVE TELNET
   Removing TELNET
REMOVE NETCARD
   NETCARD is still needed.
REMOVE DNS
   Removing DNS
REMOVE NETCARD
   NETCARD is still needed.
INSTALL NETCARD
   NETCARD is already installed.
REMOVE TCPIP
   TCPIP is still needed.
REMOVE BROWSER
   Removing BROWSER
   Removing TCPIP
   Removing HTML
REMOVE TCPIP
   TCPIP is not installed.
END

题解：一个比较麻烦的模拟，对于一个软件来说，有依赖和被依赖两种参数，因此用了depend，depend2两个vector将整个图用类似双链表的方式串了起来，这一步操作十分关键，有了双链表就可以方便地找到要删除的元素和要添加的元素。这个题还有一个比较麻烦的地方就是安装有显式和隐式两种，而显式安装的只能够被显式删除，隐式安装的都可以，为了区分这个，引入status数组，0表示未安装，1表示显式，2表示隐式，模拟的时候加一个判断就好，然后还要注意的是安装和删除均为递归操作，那么输出的语句应该放在哪里。其实这个问题很简单，安装时一定要先安装拓扑序中最靠前的软件，因此要递归到底再输出，删除就是翻着来，可以类比树的后序、先序遍历。

#include <bits/stdc++.h>
using namespace std;

const int maxn = 10000+10;
vector<int> depend[maxn],depend2[maxn];
vector<int> installed;
map<string,int> ID;
string name[maxn];
int cnt;
int status[maxn];

int find_ID(string &item){
    if(!ID.count(item)){
        ID[item] = cnt;
        name[cnt++] = item;
    }
    return ID[item];
}

bool needed(int id){
    for(int i = 0;i < depend2[id].size();i++){
        if(status[depend2[id][i]]) return true;
    }
    return false;
}

void List(){
    for(int i = 0;i < installed.size();i++){
        cout << "   " << name[installed[i]] << endl;
    }
}

void install(int id,bool toplevel){
    if(!status[id]){
        for(int i = 0;i < depend[id].size();i++){
            install(depend[id][i],false);
        }
        status[id] = toplevel ? 1 : 2;
        cout << "   Installing " << name[id] << endl;
        installed.push_back(id);
    }
}

void Remove(int id,bool toplevel){
    if((toplevel || status[id]==2) && !needed(id)){
        installed.erase(remove(installed.begin(),installed.end(),id),installed.end());
        cout << "   Removing " << name[id] << endl;
        status[id] = 0;
        for(int i = 0;i < depend[id].size();i++){
            Remove(depend[id][i],false);
        }
    }
}

int main()
{
    //freopen("input.txt","r",stdin);
    cnt = 0;
    string ope;
    memset(status,0,sizeof(status));
    while(getline(cin,ope)){
        cout << ope << endl;
        stringstream ss(ope);
        ss >> ope;
        if(ope[0] == 'E') break;
        string item1,item2;
        if(ope[0] == 'L') List();
        else{
            ss >> item1;
            int id = find_ID(item1);
            if(ope[0] == 'D'){
                while(ss >> item2){
                    int id2 = find_ID(item2);
                    depend[id].push_back(id2);
                    depend2[id2].push_back(id);
                }
            }
            else if(ope[0] == 'I'){
                if(status[id]) cout << "   " << item1 << " is already installed." << endl;
                else install(id,true);
            }
            else{
                if(!status[id]) cout << "   " << item1 << " is not installed." << endl;
                else if(needed(id)) cout << "   " << item1 << " is still needed." << endl;
                else Remove(id,true);
            }
        }
    }
    return 0;
}