HDU ACM 2647 Reward (topology----拓扑排序)

http://acm.hdu.edu.cn/showproblem.php?pid=2647

 

题意:老板想要用最少的钱给所有人发奖金,每个人最少888元,但由于有人的奖金有比别人多,要求求出最少的奖金.

输入:第一行两个数字n,m m表示人数 m表示接下有m行输入.

　　输入m组 a b 表示a的奖金要比b的多.

输出:输出最少的奖金数.

　　如果不可能求出,输出-1

 

用的书拓扑排序.

由于要用最少的钱的完成.所以不能直接用拓扑排序一找到入度为0的点,必须进行一些变形.

否则会出现错误.

在遍历每个点时,先找到1,1的奖金为888.正确

接下来遍历时,遍历到2,无法判断2应该发多少钱.

 

用了两种方法做.两种方法都是topper排序的变形,且用vector存储数据.

方法一：做第每趟搜索时,找到入度为0的点时不直接删除与该点,而是先找出所有入度为0的点,用队列记录

　　　　最后再出队,删除该点.

#include <iostream>
#include <vector>
#include <algorithm>
#include <queue>
using namespace std;
const int MAX = 10000 + 10;
int in_degree[MAX];
bool used[MAX];
int sum;
int used_num;
queue <int> q;
void find_zero(int n,int now)
{
    int i;
    for(i=1;i<=n;i++)
    {
        if(!used[i] && in_degree[i] == 0)
        {
            used[i] = 1;
            q.push(i);
            sum = sum + now + 888;
            used_num++;
        }    
    }
    return ;
}
int main()
{
    int n,m;
    while(cin>>n>>m)
    {
        int i,j;
        vector <int> v[MAX];
        while(!q.empty())
        {
            q.pop ();
        }
        sum = 0;
        used_num=0;
        memset(used,0,sizeof(used));
        memset(in_degree,0,sizeof(in_degree));
        int max1 = -1;
        for(i=1;i<=m;i++)
        {
            int a,b;
            cin>>a>>b;
            v[b].push_back(a);
            in_degree[a]++;
        }
        int y_n = 1;
        i=0;
        while(used_num < n)
        {    
            i++;
            find_zero(n,i-1);
            if(q.empty() && used_num < n)
            {
                y_n = 0;
                break;
            }
            else
            {
                while(!q.empty())
                {
                    int mark = q.front ();
                    q.pop();
                    for(j=0;j<v[mark].size();j++)
                    {
                        in_degree[v[mark][j]]--;
                    }
                }
            }
        }
        if(y_n == 0)
        {
            cout<<"-1"<<endl;
        }
        else
        {
            cout<<sum<<endl;
        }
    }
    return 0;
}

 

方法二:声明一个数组.记录每个点的优先级.

同样是这个图,若遍历顺序为3 1 2 4 5

3的优先级为1 ,他的下一个点4的优先级则改为3的优先级+1.即4的优先级为2

同样可求2的优先级为2,当2找打4时,把4的优先级更新为3.

priority[当前点的next] = max( priority[当前点]+1 , priority[当前点的next] );

 

 

 

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
const int MAX = 10000 + 10;
int in_degree[MAX] = {0};
bool used[MAX] = {0};
int priority[MAX];
int sum;
int find_zero(int n)
{
    int i;
    for(i=1;i<=n;i++)
    {
        if(!used[i] && in_degree[i] == 0)
        {
            used[i] = 1;
            sum = sum + 888 + priority[i];
            return i;
        }    
    }
    return -1;
}
int main()
{
    int n,m;
    while(cin>>n>>m)
    {
        int i,j;
        vector <int> v[MAX];
        sum = 0;
        memset(priority,0,sizeof(priority));
        memset(used,0,sizeof(used));
        memset(in_degree,0,sizeof(in_degree));
        for(i=1;i<=m;i++)
        {
            int a,b;
            cin>>a>>b;
            v[b].push_back(a);
            in_degree[a]++;
        }
        int y_n = 1;
        for(i=1;i<=n;i++)
        {
            int mark = find_zero(n);
            if(mark == -1)
            {
                y_n = 0;
                break;
            }
            else
            {
                for(j=0;j<v[mark].size();j++)
                {
                    in_degree[v[mark][j]]--;
                    priority[v[mark][j]] = max(priority[mark]+1,priority[v[mark][j]]);
                }
            }
        }
        if(y_n == 0)
        {
            cout<<"-1"<<endl;

        }
        else
        {
            cout<<sum<<endl;
        }
    }
    return 0;
}