ZOJ3794 Greedy Driver [BFS]

题目地址: http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=3794

题目描述:

N个城市，M条有向边。要从城市1开车到城市N，中途可以加油，也可以倒卖一次油，问最多能赚多少钱。

油箱容量是C。N个城市中有P个城市（p1, p2…）可以任意免费加油； 有Q个城市（q1,q2…），可以卖油（价格为pri1,pri2…），但全程只能在一座城市卖一次油；每条边都会消耗一定的油。在一开始，油箱是满的。如果能从城市1到达城市N，输出最多可以赚的钱，否则输出-1。

解题思路:

    一开始读错题还在考虑遍历城市的问题，后来发现不用遍历每座城市。。于是问题就很简单了。因为只能卖一次油，状态也很好保存。

    每个节点（城市）维护一下几个值：

        isReachable - 是否能从城市1走到

        isPassable – 在装满油箱时，能否从这个城市走到城市N

        leastUnit – 从这个城市走到城市N，一开始至少要装多少油

        pendingMaxUnit – 走过这座城市时，在还没有卖过油的状态下，油箱最多能剩多少油

        soldMaxEarn – 走过这座城市时，已经曾经卖过一次油，并且当前的剩余油量不低于leastUnit的条件下，赚到最多的钱

        isFuelStation – 是否可以加油

        canSellFuel – 是否可以卖油

        price – 如果可以卖油，每单位的油价

    首先从城市N反向跑一个BFS，标记isPassable并计算出leastUnit。

    再从城市1跑一个BFS，计算出isReachable，pendingMaxUnit，soldMaxEarn。

 

源代码：

//zoj3794_zzy_2014.07.15_AC_graph BFS_DP
#include <iostream>
#include <queue>

using namespace std;

class Edge
{
public:
    Edge(int v, int c, Edge *p): vid(v), cost(c), next(p) {}
    int vid, cost;
    Edge *next;
};

class Vertex
{
public:
    Vertex() {}
    bool isReachable; //can through the beginning to this vertex with capacity C.
    bool isPassable; //can through this vertex to the end with the capacity C.
    int leastUnit; //from this vertex to the end, need at least leastUnit unit fuel. leastUnit can be larger than maximum capacity C.
    int pendingMaxUnit; //when pass this vertex and never sold fuel, the maximum left unit of fuel. This can be less than leastUnit.
    int soldMaxEarn; //when pass this vertex and sold fuel and left fuel no less than leastUnit, the maximum money earned.
    bool isFuelStation;
    bool canSellFuel;
    int price;
    Edge *ep;
    Edge *bep;
};

class GreedyDriver
{
public:
    GreedyDriver(int n, int m, int c): N(n), M(m), C(c) {
        for(int idx = 1; idx <= N; ++idx) {
            graph[idx].isReachable = false;
            graph[idx].isPassable = false;
            graph[idx].leastUnit = -1;
            graph[idx].pendingMaxUnit = -1;
            graph[idx].soldMaxEarn = -1;
            graph[idx].isFuelStation = false;
            graph[idx].canSellFuel = false;
            graph[idx].price = 0;
            graph[idx].ep = NULL;
            graph[idx].bep = NULL;
        }
    }
    ~GreedyDriver() {
        for(int idx = 1; idx <= N; ++idx) {
            Edge *p = graph[idx].ep;
            while(p != NULL) {
                Edge *q = p;
                p = p -> next;
                delete q;
            }
        }
    }
    void construct();
    void solve();
    int ans();
private:
    int N,M,C;
    Vertex graph[1001];
    void iniLeastUnit();
    void BFS();
};

void GreedyDriver::construct()
{
    for(int idx = 1; idx <= M; ++idx) {
        int s, t, l;
        cin >> s >> t >> l;
        Edge *p = new Edge(t, l, graph[s].ep);
        graph[s].ep = p;
        Edge *q = new Edge(s, l, graph[t].bep);
        graph[t].bep = q;
    }
    int P;
    cin >> P;
    while(P--) {
        int vid;
        cin >> vid;
        graph[vid].isFuelStation = true;
    }
    int Q;
    cin >> Q;
    while(Q--) {
        int vid, pri;
        cin >> vid >> pri;
        graph[vid].canSellFuel = true;
        graph[vid].price = pri;
    }
}

int GreedyDriver::ans()
{
    if(graph[N].isReachable == false)
        return -1;
    int maxEarn = 0;
    for(int idx = 1; idx <= N; ++idx) {
        if(graph[idx].isReachable && graph[idx].isPassable && graph[idx].soldMaxEarn > maxEarn)
            maxEarn = graph[idx].soldMaxEarn;
    }
    return maxEarn;
}

void GreedyDriver::iniLeastUnit()
{
    bool inQueue[1001];
    for(int idx = 1; idx <= N; ++idx)
        inQueue[idx] = false;
    graph[N].leastUnit = 0;
    queue<int> Q;
    while(!Q.empty()) Q.pop();
    Q.push(N);
    inQueue[N] = true;
    while(!Q.empty()) {
        int fid = Q.front();
        Q.pop();
        inQueue[fid] = false;
        int fLeastUnit = graph[fid].isFuelStation ? 0 : graph[fid].leastUnit;
        Edge *p = graph[fid].bep;
        while(p != NULL) {
            int sid = p -> vid;
            int sLeastUnit = fLeastUnit + p -> cost;
            if(graph[sid].leastUnit == -1 || graph[sid].leastUnit > sLeastUnit) {
                graph[sid].leastUnit = sLeastUnit;
                if(graph[sid].leastUnit <= C)
                    graph[sid].isPassable = true;
                if(graph[sid].isPassable && inQueue[sid] == false) {
                    Q.push(sid);
                    inQueue[sid] = true;
                }
            }
            p = p-> next;
        }
    }
}

void GreedyDriver::BFS()
{
    bool inQueue[1001];
    for(int idx = 1; idx <= N; ++idx)
        inQueue[idx] = false;
    if(graph[1].isPassable == false)
        return;
    graph[1].isReachable = true;
    graph[1].pendingMaxUnit = C;
    if(graph[1].canSellFuel) {
        if(graph[1].isFuelStation)
            graph[1].soldMaxEarn = C * graph[1].price;
        else if(graph[1].pendingMaxUnit > graph[1].leastUnit)
            graph[1].soldMaxEarn = (graph[1].pendingMaxUnit - graph[1].leastUnit) * graph[1].price;
    }
    queue<int> Q;
    while(!Q.empty()) Q.pop();
    Q.push(1);
    inQueue[1] = true;
    while(!Q.empty()) {
        int fid = Q.front();
        Q.pop();
        inQueue[fid] = false;
        Edge *p = graph[fid].ep;
        while(p != NULL) {
            int sid = p -> vid;
            if(graph[sid].isPassable) {
                if(graph[fid].pendingMaxUnit - (p -> cost) >= (graph[sid].isFuelStation ? 0 : graph[sid].leastUnit)) {
                    if(graph[sid].isReachable == false) {
                        Q.push(sid);
                        inQueue[sid] = true;
                    }
                    graph[sid].isReachable = true;
                    if(graph[sid].isFuelStation)
                        graph[sid].pendingMaxUnit = C;
                    else {
                        if(graph[fid].pendingMaxUnit - (p -> cost) > graph[sid].pendingMaxUnit) {
                            graph[sid].pendingMaxUnit = graph[fid].pendingMaxUnit - (p -> cost);
                            if(inQueue[sid] == false)
                                Q.push(sid);
                            inQueue[sid] = true;
                        }
                    }
                    if(graph[sid].canSellFuel) {
                        if(graph[sid].isFuelStation)
                            graph[sid].soldMaxEarn = C * graph[sid].price;
                        else if(graph[sid].pendingMaxUnit > graph[sid].leastUnit &&
                                (graph[sid].pendingMaxUnit - graph[sid].leastUnit) * graph[sid].price > graph[sid].soldMaxEarn)
                            graph[sid].soldMaxEarn = (graph[sid].pendingMaxUnit - graph[sid].leastUnit) * graph[sid].price;
                    }
                }
            }
            p = p-> next;
        }
    }
}

void GreedyDriver::solve()
{
    graph[1].isReachable = true;
    graph[N].isPassable = true;
    iniLeastUnit();
    BFS();
}

int main()
{
    int n,m,c;
    while(cin >> n >> m >> c) {
        GreedyDriver *gd = new GreedyDriver(n, m, c);
        gd -> construct();
        gd -> solve();
        cout << gd -> ans() << endl;
        delete gd;
    }
    return 0;
}