算法-解决依赖释放问题

 

 

 

#include <iostream>

#include <list>

using namespace std;

int main()

{

    // 对象总数

    int numObj = 0;

    // 依赖关系数

    int numDep = 0;

    cin >> numObj >> numDep;

    // 储存依赖关系的邻接表

    list<int> relationship[numObj];

    // 保存无依赖关系的对象的链表

    list<int> saveNoDepend;

    // 保存每一个对象直接依赖数量的数组

    int objDepNumArr[numObj];

    for (int i = 0; i < numObj; ++i)

    {

        objDepNumArr[i] = 0;

    }

    int depend = 0;

    int beDepended = 0;

    for (int i = 0; i < numDep; ++i)

    {

        // 接收依赖者和被依赖者，例如接收到输入[1 0]，1要释放，直接依赖于0先释放，则1是依赖者，0是被依赖者

        cin >> depend >> beDepended;

        // 邻接表中记录谁直接依赖于自己，以便后续自己释放后，可以通知到依赖者

        relationship[beDepended].push_back(depend);

        // 依赖者依赖的对象数量+1

        objDepNumArr[depend]++;

    }

    for (int i = 0; i < numObj; ++i)

    {

        if (0 == objDepNumArr[i])

        {

            // 该对象不直接依赖于任何对象，则保存到saveNoDepend链表中

            saveNoDepend.push_back(i);

        }

    }

    if (0 == saveNoDepend.size())

    {

        // 不存在任何一个0依赖者则代表DeadLock

        cout << "DeadLock" << endl;

        return 0;

    }

    while (0 != saveNoDepend.size())

    {

        int objBeDep = saveNoDepend.front();

        saveNoDepend.pop_front();

        cout << objBeDep << " ";

        // 被依赖者依次通知直接依赖于自己的依赖者，自己已经释放

        while (0 != relationship[objBeDep].size())

        {

            int objDep = relationship[objBeDep].front();

            relationship[objBeDep].pop_front();

            // 被通知到的人将自己所依赖的直接依赖数量-1

            objDepNumArr[objDep]--;

            if (0 == objDepNumArr[objDep])

            {

                // 如果此时由于被依赖者的释放，导致自己已经没有了任何直接依赖，那么将该对象也加入到saveNoDepend链表中

                saveNoDepend.push_back(objDep);

            }

        }

    }

    cout << endl;

    return 0;

}