Hdu

上题目

Reward

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 2522    Accepted Submission(s): 745

Problem Description

Dandelion's uncle is a boss of a factory. As the spring festival is coming , he wants to distribute rewards to his workers. Now he has a trouble about how to distribute the rewards.
The workers will compare their rewards ,and some one may have demands of the distributing of rewards ,just like a's reward should more than b's.Dandelion's unclue wants to fulfill all the demands, of course ,he wants to use the least money.Every work's reward will be at least 888 , because it's a lucky number.

 

Input

One line with two integers n and m ,stands for the number of works and the number of demands .(n<=10000,m<=20000)
then m lines ,each line contains two integers a and b ,stands for a's reward should be more than b's.

 

Output

For every case ,print the least money dandelion 's uncle needs to distribute .If it's impossible to fulfill all the works' demands ,print -1.

 

Sample Input

2 1 1 2 2 2 1 2 2 1

 

Sample Output

1777 -1

 

 

 　 这一题我终于AC了，这么多天终于A题了，感动啊T_T，这一题之前没有过超时了，这一次重新做了一遍，终于A了。

  　题意就是拓扑排序，然后求给不同的员工发的工资最少是多少。由于不同的员工之间有可能会有比较，如果A>B，就要A的工资要比B的多。之前第一次的做法是在得到拓扑排序以后从顶向叶子遍历，记录层数，结果超时了。

　　这一次的做法是在拓扑排序的同时进行记录层数，如果在当前的结点已经有一个层数的话，那么就要判断是当前新的层数大还是原来的层数大，记录更大的那个层数，这样才可以符合题意。最后只要将所有结点的层数加起来(最下层的结点层数为0)，就可以得到需要多增加加金额。

　　用这种方法时，邻接表是用来记录当前点i比哪些点的工资要少，同时开一个数组保存某一点i比多少个点要大(即保存数目)，也就是说这里有点像开了一个邻接表和一个逆邻接表，只是我各取了这两个表的一部分。

   这一题不知道会不会出现重边，我用map来记录已经记录了边。

   还有这一题要注意的地方是要留意我需要的是i还是node[i].to(前者是当前结点在静态链表里面的指针值，后者是 当前结点的编号(名称))。

 

 

先把超时的代码贴上

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <queue>
#define MAX 10000+2
using namespace std;

typedef struct node
{
    int x0;
    struct node *next;
}node;

node s[MAX];

int d[MAX],e[MAX];

queue<int> p;

bool deal(int n)
{
    int i,count;
    node *f,*r;
    while(!p.empty()) p.pop();
    count=0;
    for(i=1;i<=n;i++) if(!e[i]) {p.push(i);}
    while(!p.empty())
    {
        i=p.front();
        count++;
        p.pop();
        f=s[i].next;
        while(f)
        {
            e[f->x0]--;
            if(!e[f->x0])
            {
                p.push(f->x0);
                d[f->x0]=d[f->x0]<(d[i]+1) ? (d[i]+1) : d[f->x0];
            }
            r=f;
            f=f->next;
            free(r);
        }
    }
    if(n==count) return 1;
    return 0;
}

void jadge(int n)
{
    int i,ans;
    ans=0;
    for(i=1;i<=n;i++) ans+=d[i];
    printf("%d
",ans+888*n);
}

void insert(int x,int y)
{
    node *f;
    f=&s[x];
    while(f->next)
    {
        if(f->x0==y) return ;
    }
    f->next=(node*)malloc(sizeof(node));
    f->next->next=NULL;
    f->next->x0=y;
    e[y]++;
}

int main()
{
    int n,m,i,x,y;
    //freopen("data.txt","r",stdin);
    while(scanf("%d %d",&n,&m)!=EOF)
    {
        for(i=1;i<=n;i++) {s[i].x0=i;s[i].next=NULL;}
        memset(d,0,sizeof(d));
        memset(e,0,sizeof(e));
        for(i=0;i<m;i++)
        {
            scanf("%d %d",&y,&x);
            insert(x,y);
        }
        if(!deal(n)) printf("-1
");
        else jadge(n);
    }
    return 0;
}

上代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <queue>
#include <map>
#include <vector>
#include <algorithm>
#define MAX (10000+2)
using namespace std;

int head[MAX],tot,co[MAX],f[MAX];

typedef struct
{
    int to;
    int next;
}Node;

Node node[MAX<<1];

map<pair<int,int>,int> M;
queue<int> q;

int topo(int n)
{
    int i,u,count;
    while(!q.empty()) q.pop();
    memset(f,0,sizeof(f));
    count=0;
    for(i=1;i<=n;i++)
    {
        if(!co[i])
        {
            f[i]=0;
            q.push(i);
        }
    }
    while(!q.empty())
    {
        u=q.front();
        q.pop();
        count++;
        for(i=head[u];i!=-1;i=node[i].next)
        {
            co[node[i].to ]--;
            if(co[node[i].to]==0)
            {
               q.push(node[i].to);
               f[node[i].to]=f[u]+1 > f[node[i].to] ? f[u]+1 : f[node[i].to];
            }
        }
    }
    if(count<n) return 0;
    return 1;
}

int main()
{
    int n,m,i,sum;
    pair<int,int> e;
    //freopen("data.txt","r",stdin);
    while(scanf("%d %d",&n,&m)!=EOF)
    {
        memset(head,-1,sizeof(head));
        memset(co,0,sizeof(co));
        memset(node,0,sizeof(node));
        M.clear();
        tot=0;
        for(i=0;i<m;i++)
        {
            scanf("%d %d",&e.second,&e.first);    //first ==>right   second ==>left
            if(M.count(e)<=0)
            {
                M.insert(pair<pair<int,int>,int>(e,1));
                node[tot].to=e.second;
                node[tot].next=head[e.first];
                head[e.first]=tot++;
                co[e.second]++;
            }
        }
        if(!topo(n)) printf("-1
");
        else
        {
            sum=0;
            for(i=1;i<=n;i++) sum+=f[i];
            sum+=n*888;
            printf("%d
",sum);
        }
    }
    return 0;
}