poj 3249 DAG上的最短路问题

题意：一个人去找工作 ， 然后得到一个面试题：有一些城市和城市之间的道路 ， 没到达一个城市会赚一些钱也有可能会损失一些 ， 从源点（入度为0的点）到终点（出度为0的点） ， 收益得越多 ， 就越有可能得到这份工作 ， 问最多能得到多少？
并且题目给出，每条路都是有方向的 ， 并且不会有一条路会回到前的城市 ， 显而易见 ， 这是一个有向无环图（DAG） ， 而由于本体数据太大，用普通的做短路算法肯定会超时 ， 所以我们要充分利用图是DAG这个条件：

我们先求出图的topo序列 ， 由于是DAG图 ， 那么后面的点和前面的点肯定是不能到达的 ， 所以我们在求的时候 ， 只要根据topo序列来求进可以 ， 时间复杂度为O(m)

代码：
#include
#include
#include
#include
#include
using namespace std;

#define INF 0xffffff
#define maxn 100010

struct node
{
      int to;
      int next;
}edge[1000010];
int head[maxn] , rudu[maxn] , chudu[maxn];
int topo[maxn] , pre[maxn] , dist[maxn];
int n , m , cost[maxn] , qidian[maxn];

void init()
{
      memset(head , -1 , sizeof(head));
      memset(rudu , 0 , sizeof(rudu));
      memset(chudu , 0 , sizeof(chudu));
}


void DAG_dist(int s)
{
      int i;
      for(i = 1; i <= n; i++)
            dist[i] = -INF;
      for(i = 0; i < s; i++)
      //      if(topo[i] == u)  break;
            dist[qidian[i]] = cost[qidian[i]];

      for(i = 0 ; i < n; i++)
      {//cout<<i<<endl;
            for(int k = head[topo[i]] ; k != -1 ; k = edge[k].next)
                  if(dist[edge[k].to] < dist[topo[i]]+cost[edge[k].to])
                        dist[edge[k].to] = dist[topo[i]] + cost[edge[k].to];
      }
}

int main()
{
      while(scanf("%d %d" , &n , &m) != EOF)
      {
            init();
            int i , j , x , y , z , k = 0;
            for(i = 1; i <= n; i++)
                  scanf("%d" , &cost[i]);

            for(i = 1; i <= m; i++)
            {
                  scanf("%d %d" , &x , &y );
                  edge[k].to = y;
                  edge[k++].next = head[x];
                  head[x] = k-1;
                  rudu[y] += 1;
                  chudu[x] += 1;
            }

            int s = 0 ; k = 0 , x = 0;
            for(i = 1; i <= n; i++)
            {
                  if(rudu[i] == 0)  qidian[s++] = i , topo[x++] = i , rudu[i] = -1;
                  if(chudu[i] == 0)  chudu[k++] = i;
            }
            y = 0;
            while(x < n)
            {
                  z = topo[y++];
                  for(j = head[z] ; j != -1; j = edge[j].next)
                        if(--rudu[edge[j].to] == 0)  topo[x++] = edge[j].to , rudu[edge[j].to] = -1;
            }

            int maxsum = -INF;

      //      for(i = 0; i < s; i++)
      //      {
                  DAG_dist(s);
                  for(j = 0; j < k; j++)
                        if( dist[chudu[j]] > maxsum)  maxsum = dist[chudu[j]];
      //      }

            cout<<maxsum<<endl;
           
      }
      return 0;
}