图论 --- spfa + 链式向前星 ： 判断是否存在正权回路 poj 1860 : Currency Exchange

Currency Exchange

Time Limit: 1000MS		Memory Limit: 30000K
Total Submissions: 19881		Accepted: 7114

Description

Several currency exchange points are working in our city. Let us suppose that each point specializes in two particular currencies and performs exchange operations only with these currencies. There can be several points specializing in the same pair of currencies. Each point has its own exchange rates, exchange rate of A to B is the quantity of B you get for 1A. Also each exchange point has some commission, the sum you have to pay for your exchange operation. Commission is always collected in source currency. 
For example, if you want to exchange 100 US Dollars into Russian Rubles at the exchange point, where the exchange rate is 29.75, and the commission is 0.39 you will get (100 - 0.39) * 29.75 = 2963.3975RUR. 
You surely know that there are N different currencies you can deal with in our city. Let us assign unique integer number from 1 to N to each currency. Then each exchange point can be described with 6 numbers: integer A and B - numbers of currencies it exchanges, and real R_AB, C_AB, R_BA and C_BA - exchange rates and commissions when exchanging A to B and B to A respectively. 
Nick has some money in currency S and wonders if he can somehow, after some exchange operations, increase his capital. Of course, he wants to have his money in currency S in the end. Help him to answer this difficult question. Nick must always have non-negative sum of money while making his operations. 

Input

The first line of the input contains four numbers: N - the number of currencies, M - the number of exchange points, S - the number of currency Nick has and V - the quantity of currency units he has. The following M lines contain 6 numbers each - the description of the corresponding exchange point - in specified above order. Numbers are separated by one or more spaces. 1<=S<=N<=100, 1<=M<=100, V is real number, 0<=V<=10³. 
For each point exchange rates and commissions are real, given with at most two digits after the decimal point, 10^-2<=rate<=10², 0<=commission<=10². 
Let us call some sequence of the exchange operations simple if no exchange point is used more than once in this sequence. You may assume that ratio of the numeric values of the sums at the end and at the beginning of any simple sequence of the exchange operations will be less than 10⁴. 

Output

If Nick can increase his wealth, output YES, in other case output NO to the output file.

Sample Input

3 2 1 20.0

1 2 1.00 1.00 1.00 1.00

2 3 1.10 1.00 1.10 1.00

Sample Output

YES

Source

Northeastern Europe 2001, Northern Subregion

---

Mean:

你有一些古币，现在你要用这些古币去兑换成其他钱币。这个城市里有N个兑换点，每个兑换点包括：
A----钱币A
B----钱币B
Rab--A兑换为B的比例
Cab--A兑换为B的手续费
Rba--B兑换为A的比例
Cba--B兑换为A的手续费
现在你有编号为S的这种古币，你将用这些古币去进行一系列的兑换，最终还是要兑换回古币。你想知道能不能通过一系列兑换来增加自身的古币。
N--钱币的种类总数(结点数)
M--兑换点的数量(边的条数)
S--你的货币种类标识(起点&终点)
V--你现在身上货币的数目

analyse:

判断图中是否存在正权回路。

使用spfa来不断迭代求最大路径，如果这个过程中某个点的迭代次数超过了n次，那么一定存在正权回路。

其实一般情况下每个点的迭代次数不会超过2，所以这题把n改为3也能过，当然如果存在正权回路的话一定会超过n，所以在不卡时间的情况下，就用n来判断保险一点。

Time complexity：O(m*k),k为每个点平均迭代次数

Source code：

//Memory   Time
//  164K     0MS
// by : Snarl_jsb
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<vector>
#include<queue>
#include<stack>
#include<iomanip>
#include<string>
#include<climits>
#include<cmath>
#define MAXV 110
#define MAXE 110<<1
#define LL long long
using namespace std;
int n,m,sta;
float num;
int vis[MAXV];
float dis[MAXV];
int cnt[MAXV];
namespace Adj
{
    struct Edge
    {
        int to,next;
        float rate,cost;
    };
    Edge edge[MAXE];
    int top;
    int head[MAXV];
    void init()
    {
        top=1;
        memset(head,0,sizeof(head));
    }
    void addEdge(int u,int v,float rate,float cost)
    {
        edge[top].to=v;
        edge[top].rate=rate;
        edge[top].cost=cost;
        edge[top].next=head[u];
        head[u]=top++;
    }
}
using namespace Adj;
 
bool spfa()
{
    for(int i=1;i<=n;i++)
        cnt[i]=vis[i]=0,dis[i]=0.0;
    queue<int>Q;
    Q.push(sta);
    vis[sta]=1;
    dis[sta]=num;
    while(!Q.empty())
    {
        int now=Q.front();
        Q.pop();
        vis[now]=0;
        for(int i=head[now];i;i=edge[i].next)
        {
            int son=edge[i].to;
            float tmp=(dis[now]-edge[i].cost)*edge[i].rate*1.0;
            if(dis[son]<tmp)
            {
                dis[son]=tmp;
                if(!vis[son])
                {
                    Q.push(son);
                    vis[son]=1;
                }
                cnt[son]++;
                if(cnt[son]>3)  //   某个结点迭代次数超过了n次，存在正权回路
                    return false;
            }
        }
    }
    return true;
}
 
int main()
{
//    freopen("cin.txt","r",stdin);
//    freopen("cout.txt","w",stdout);
    scanf("%d %d %d %f",&n,&m,&sta,&num);
    Adj:: init();
    int a,b;
    float r1,c1,r2,c2;
    while(m--)
    {
        scanf("%d %d %f %f %f %f",&a,&b,&r1,&c1,&r2,&c2);
        Adj:: addEdge(a,b,r1,c1);
        Adj:: addEdge(b,a,r2,c2);
    }
    if(!spfa())
        puts("YES");
    else
        puts("NO");
    return 0;
}