SCU-4527 NightMare2(Dijkstra+BFS) ！！！错误题解！！！

错解警告！！！

描述

可怜的RunningPhoton又做噩梦了。。但是这次跟上次不大一样，虽然他又被困在迷宫里，又被装上了一个定时炸弹，但是值得高兴的是，他发现他身边有数不清的财宝，所以他如果能带着这些财宝并活着逃出去的话，他就发财啦。不过，这次的迷宫不再是一个矩形方格了，而是由点和边组成的图，每条边都有通过该边的时间，以及由于神奇阵法而产生的对财宝数量的限制（即通过这条边只能带上不超过一定数量的财宝，否则炸弹将笋干爆炸！）。现在，RuningPhoton又开始疑惑了，在保证能活着逃出去的情况下，他最多能拿多少价值的财宝？

 

输入

第一行一个整数T(1≤T≤10)，代表样例数。 
每个样例的第一行有3个整数n(1≤n≤10,000),m(1≤m≤50,000),K(1≤K≤500,000),分别代表迷宫的点数，边数以及炸弹离爆炸的剩余时间。刚开始RuningPhoton在1，出口在n。 
接下来m行，每行4个整数u,v(1≤u,v≤n),cap(1≤cap≤2∗109),dis(1≤dis≤50,000)分别代表每条边的两端点，该边的财宝数量限制以及通过这条边的时间。 
（P.S. 这次在计时到0的时候到达n点也算逃出迷宫）

 

输出

每组数据输出一行，代表在保证或者逃出去的情况下能得到的最多财宝价值，被炸死输出"Poor RunningPhoton!"(不含引号)。

 

样例输入

2 
2 1 10 
1 2 13 10 
4 4 20 
1 2 1000 15 
2 4 999 6 
1 3 100 15 
3 4 99 4

 

样例输出

13 
99

思路：

正向Dijkstra，反向bfs，反向bfs的过程中,将起始点的dis设为k，cap设为inf，然后，如果与之相连的顶点的最短路的值，小于当前顶点的dis值减去边权，那么就将其放入队列，并将dis值设为顶点的dis值减去边权，cap值为当前节点的cap值与边的cap值的最小值。

 

错误原因：

推测：BFS的队列占用内存太大

MLE代码：

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<queue>
#include<vector>
using namespace std;
int n,m,k;
const int maxn = 10005;
const int inf = 2100000000;
vector<int>u[maxn];
vector<int>w[maxn];
vector<int>c[maxn];
int dis[10005];
struct node
{
    int x,dis,cap;
    bool operator<(const node t)const
    {
        return t.dis<dis;
    }
};

void init()
{
    scanf("%d%d%d",&n,&m,&k);
    for(int i=0;i<maxn;i++){
        u[i].clear();
        w[i].clear();
        c[i].clear();
    }
    int x,y,z,r;
    for(int i=1;i<=m;i++){
        scanf("%d%d%d%d",&x,&y,&z,&r);
        u[x].push_back(y);
        w[x].push_back(r);
        c[x].push_back(z);
        u[y].push_back(x);
        w[y].push_back(r);
        c[y].push_back(z);
    }
}

void Dijkstra()
{
    for(int i=1;i<=n;i++){
        dis[i]=inf;
    }
    priority_queue<node>q;
    dis[1]=0;
    q.push(node{1,0,0});
    node exa;
    while(!q.empty()){
        exa=q.top();
        q.pop();
        int t=exa.x;
        int siz=u[t].size();
        for(int i=0;i<siz;i++){
            if(dis[u[t][i]]>w[t][i]+dis[t]){
                dis[u[t][i]]=w[t][i]+dis[t];
                q.push(node{u[t][i],dis[u[t][i]],0});
            }
        }
    }
}

int BFS()
{
    queue<node>q;
    q.push(node{n,k,inf});
    node exa;
    int ans=-1;
    while(!q.empty()){
        exa=q.front();q.pop();
        int t=exa.x;
        if(t==1){ans=max(ans,exa.cap);continue;}
        int siz=u[t].size();
        for(int i=0;i<siz;i++){
            if(exa.dis-w[t][i]>=dis[u[t][i]]){
                q.push(node{u[t][i],exa.dis-w[t][i],min(c[t][i],exa.cap)});
            }
        }
    }
    return ans;
}

int solve()
{
    Dijkstra();
    return BFS();
}

int main()
{
//    freopen("in.txt","r",stdin);
    int T;
    scanf("%d",&T);
    while(T--){
        init();
        int t=solve();
        if(t==-1){printf("Poor RunningPhoton!
");}
        else printf("%d
",t);
    }
}

提示

删掉输出，可以将结果化为WA哦！