BSOJ：3064 最小奖励--图上DP

3064 -- 【模拟试题】最小奖励

Description

　　　Jzabc更是一个狂热的旅游爱好者。这次他想去一个诡异的地方。这个地方有n个村庄，编号为1到n。此刻他在1号村庄，他想去n号村庄。这n个村庄之间有m条单向道路。通过某些道路时，可能会花费一些钱作为“买路钱”，可是通过一些道路时，不仅不需要交“买路钱”，而且会得到一些奖励（这就是诡异的地方？）。当然两个村庄之间可能有多条直接相连的道路。但是每一条路只能通过一次。

　　　这些村庄有这样的特性，从任何一个村庄出发，沿着任一条路径走都不会回到出发点。找到一条路径从1号村庄到n号村庄后，他需要计算一共得到多少奖励，一共交了多少“买路钱”。如果得到的总奖励钱数大于交的“买路钱”数，那么称这走一条路径可以得到奖励；相反，如果前者小于后者，那么称走这一条路径需要花费。如果两者相等，那么Jzabc不会选这一条路（我也不知道他为什么不选这一条路径）。不会出现所有的路径两者都相等。他又需要你的帮助，让你找一条路径，使他得到的奖励最小（为什么不是最大的奖励？），并输出最小奖励。如果找不到一条路径能使他得到奖励，那么就找一条路径是他得到的花费最大（为什么就不是最小的花费？），并输出最大花费。

Input

第一行为两个正整数n，m，中间用空格隔开，n是村庄总数，m是道路总数；

以下m行，每行三个正整数x，y，w，描述一条道路的信息，中间用空格隔开，x是此条道路的起点，y是终点：

若w为正，则是通过此条道路得到的奖励钱数；

若w为负，则是通过此条道路交的“买路钱”数；

w不为0，并且|w|<=10；

Output

输出仅一个整数。若有最小奖励，则输出。否则输出最大花费。

Sample Input

3 4

1 2 2

2 3 -1

2 3 3

1 3 -1

Sample Output

1

【数据规模】

对于20%的数据，n<=20，m<=200；

对于50%的数据，n<=50，m<=2000；

对于100%的数据，n<=100，m<=20000；

这是一道显然的图上DP，但是这道问题远不止于看出他的算法。

观察问题，要求有正的奖励，一定输出奖励，没有奖励时，才输出最大花费。

这个问题同样是好解决的，只需DP两个：最小奖励、最大花费。

最大花费问题太简单了，不多赘述。

问题复杂在最小奖励上--最小，且>0.

怎么限制>0条件呢？minn[x]+edge_val[i]>0?

答案是否定的，思考下我们发现如果用上述方法进行判定，能且只能保证下一个节点minn>0，考虑这样的情况：现在的奖励暂时<0，而后面的路径又使奖励>0，那么这个判定方法无法正确通过数据。

怎么修改？

答案同样是简单的，这里我们判定的是存在性问题，意思是说，只要连着to的路径有一条能使最终结果>0，to的状态就能够用x更新。

那么求出每个点到终点n的最长路即可。

具体是这样的：

if(f1[x]+w[i].val+maxx[to]>0)f1[to]=min(f1[to],f1[x]+w[i].val);

最长路用SPFA处理即可。

#include<iostream>

#include<cstdio>

#include<cstring>

#include<algorithm>

#include<cstdlib>

//#include<cmath>

using namespace std;

inline int read()

{

    int bj=1;

    char ch=getchar();

    while(ch<'0'||ch>'9')

    {

        if(ch=='-')bj=-1;

        ch=getchar();

    }

    int ret=0;

    while(ch>='0'&&ch<='9')ret=ret*10+ch-'0',ch=getchar();

    return ret*bj;

}

struct node

{

    int to,next,val;

}w[500005];

int n,m,stk[100005]={0},top=0,h[50005]={0},cnt=0,into[100005]={0},a[100005]={0};

int dis[105],q[10005]={0},iq[10005]={0},maxx[105]={0},f1[105]={0},f2[105]={0};

void Addarc(int x,int y,int val)

{

    cnt++;w[cnt].to=y;w[cnt].next=h[x];h[x]=cnt;w[cnt].val=val;

}

void init()

{

    n=read();m=read();

    for(int i=1;i<=m;i++)

    {

        int x=read(),y=read(),z=read();

        Addarc(x,y,z);

        into[y]++;

    }

}

void Topsort()

{

    for(int i=1;i<=n;i++)if(!into[i])stk[++top]=i;

    while(top)

    {

        int x=stk[top--];

        a[++a[0]]=x;

        for(int i=h[x];i;i=w[i].next)

        {

            int to=w[i].to;

            into[to]--;

            if(!into[to])stk[++top]=to;

        }

    }

}

void SPFA(int st)

{

    memset(iq,0,sizeof(iq));

    memset(q,0,sizeof(q));

    memset(dis,128,sizeof(dis));

    dis[st]=0;

    q[1]=st;iq[st]=1;

    int head=1,tail=1;

    while(head<=tail)

    {

        int temp=q[head];

        iq[temp]=0;

        for(int i=h[temp];i;i=w[i].next)

        {

            int to=w[i].to;

            if(dis[to]<dis[temp]+w[i].val)

            {

                dis[to]=dis[temp]+w[i].val;

                if(!iq[to])

                {

                    iq[to]=1;

                    q[++tail]=to;

                }

            }

        }

        head++;

    }

    maxx[st]=dis[n];

}

int Abs(int x)

{

    return max(x,-x);

}

void DP()

{

    memset(f1,127,sizeof(f1));

    memset(f2,127,sizeof(f2));

    f1[1]=0;f2[1]=0;

    for(int i=1;i<=a[0];i++)

    {

        int x=a[i];

        for(int i=h[x];i;i=w[i].next)

        {

            int to=w[i].to;

            if(f1[x]+w[i].val+maxx[to]>0)f1[to]=min(f1[to],f1[x]+w[i].val);

            f2[to]=min(f2[to],f2[x]+w[i].val);

        }

    }

    if(f1[n]<0||f1[n]>2000000000)printf("%d\n",Abs(f2[n]));

    else printf("%d\n",f1[n]);

}

int main()

{

    init();

    for(int i=1;i<=n;i++)SPFA(i);

    Topsort();

    DP();

return 0;

}