poj 3249 DAG上的最短路问题

最新推荐文章于 2021-08-17 02:41:54 发布

原创最新推荐文章于 2021-08-17 02:41:54 发布 · 1.1k 阅读

0 ·

CC 4.0 BY-SA版权

最短路算法及其一些应用专栏收录该内容

26 篇文章

订阅专栏

本文介绍了一种解决有向无环图中从起点到终点的最大收益路径问题的方法，通过求解拓扑排序序列并利用动态规划算法优化时间复杂度，实现了高效的路径选择。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题意：一个人去找工作，然后得到一个面试题：有一些城市和城市之间的道路，没到达一个城市会赚一些钱也有可能会损失一些，从源点（入度为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;
}