Problem Description

During the world war, to avoid the upcoming Carpet-bombing from The Third Reich, people in Heaven Empire went to Great Tunnels for sheltering.

There are N cities in Heaven Empire, where people live, with 3 kinds of directed edges connected with each other. The 1st kind of edges is one of Great Tunnels( no more than 20 tunnels) where a certain number of people can hide here; people can also go through
one tunnel from one city to another. The 2nd kind of edges is the so-called Modern Road, which can only let people go through. The 3rd kind of edges is called Ancient Bridge and all the edges of this kind have different names from others, each of which is
named with one of the twelve constellations( such as Libra, Leo and so on); as they were build so long time ago, they can be easily damaged by one person's pass. Well, for each bridge, you can spend a certain deal of money to fix it. Once repaired, the 3rd
kind of edges can let people pass without any limitation, namely, you can use one bridge to transport countless people. As for the former two kinds of edges, people can initially go through them without any limitation.

We want to shelter the most people with the least money.

Now please tell me the largest number of people who can hide in the Tunnels and the least money we need to spend to realize our objective.

 

Input

Multiple Cases.

The first line, two integers: N (N<=100), m (m<=1000). They stands for the number of cities and edges.

The next line, N integers, which represent the number of people in the N cities.

Then m lines, four intergers each: u, v, w, p (1<=u, v<=N, 0<=w<=50). A directed edge u to v, with p indicating the type of the edge: if it is a Tunnel then p < 0 and w means the maximum number people who can hide in the the tunnel; if p == 0 then it is a Modern
Road with w means nothing; otherwise it is an Ancient Bridge with w representing the cost of fixing the bridge. We promise there are no more than one edge from u to v.

 

Output

If nobody can hide in the Tunnels, print “Poor Heaven Empire”, else print two integers: maximum number and minimum cost.

 

Sample Input

4 4

2 1 1 0

1 2 0 0

1 3 0 0

2 4 1 -1

3 4 3 -1

4 4

2 1 1 0

1 2 0 0

1 3 3 1

2 4 1 -1

3 4 3 -1

 

Sample Output

4 0

4 3

 

Author

BUPT

 

题意：n座城市，每一个城市有ni个人，m条边， 三种建筑，分别为隧道。古桥，现代桥，隧道能够容纳一定数量的人，能够通过无数次。现代桥能够通过无数次，古桥假设不修善仅仅能通过一次，修缮后能够通过无数次，修缮须要一定的费用，且古桥的最大数量为12，如今每一个城市的人须要到隧道避难，问最多能避难的人数，以及最多人数的最小花费（古桥的修缮）。

思路：最大流。构造超级源点和汇点，每一个城市与源点连边流量为人数，现代桥能够通过无数次。连边，流量为无限。隧道能够通过无数次，连边流量为无限，与汇点连边。流量为能够容纳的人数。然后枚举古桥2^12修与不修的情况，做这么多遍最大流就可以。

#include <iostream>

#include <cstdio>

#include <cstring>

#include <vector>

#include <string>

#include <algorithm>

#include <queue>

using namespace std;

const int maxn = 100+10;

const int maxm = 1000+10;

const int inf = 1<<25;

int n,m,nume;

struct edge{

    int v,f,nxt;

};

struct build{

    int u,v,w;

    build(int u,int v,int w):u(u),v(v),w(w){}

};

vector<build> vb[3];

edge e[maxm];

int head[maxn];

int city[maxn];

void addedge(int u,int v,int c){

    e[++nume].nxt = head[u];

    e[nume].v = v;

    e[nume].f = c;

    head[u] = nume;

    e[++nume].nxt = head[v];

    e[nume].v = u;

    e[nume].f = 0;

    head[v] = nume;

}

void init(){

    memset(head,0,sizeof head);

    nume = 1;

}

queue<int> que;

bool vis[maxn];

int dist[maxn];

int src,sink;

void bfs(){

    memset(dist,0,sizeof dist);

    while(!que.empty()) que.pop();

    vis[src] = true;

    que.push(src);

    while(!que.empty()){

        int u = que.front();

        que.pop();

        for(int i = head[u]; i ; i = e[i].nxt){

            if(e[i].f && !vis[e[i].v]){

                que.push(e[i].v);

                vis[e[i].v] = 1;

                dist[e[i].v] = dist[u]+1;

            }

        }

    }

}

int dfs(int u,int delta){

    if(u== sink) return delta;

    else{

        int ret = 0;

        for(int i = head[u]; delta&&i; i = e[i].nxt){

            if(e[i].f && dist[e[i].v] == dist[u]+1){

                int dd = dfs(e[i].v,min(e[i].f,delta));

                e[i].f -= dd;

                e[i^1].f += dd;

                delta -= dd;

                ret += dd;

            }

        }

        return ret;

    }

}

int maxflow(){

    int ret = 0;

    while(true){

        memset(vis,0,sizeof vis);

        bfs();

        if(!vis[sink]) return ret;

        ret += dfs(src,inf);

    }

}

int main(){

    while(~scanf("%d%d",&n,&m)){

        src = 0;

        sink = n+1;

        for(int i = 0; i < 3; i++) vb[i].clear();

        for(int i = 1; i <= n; i++) scanf("%d",&city[i]);

        bool flag = 0;

        while(m--){

            int a,b,c,d;

            scanf("%d%d%d%d",&a,&b,&c,&d);

            if(d==0){

                vb[1].push_back(build(a,b,c));//现代桥

            }

            else if(d<0){

                vb[0].push_back(build(a,b,c));//隧道

                flag = 1;

            }else{

                vb[2].push_back(build(a,b,c));//古代桥

            }

        }

        if(!flag){

            printf("Poor Heaven Empire\n");

            continue;

        }

        int d = vb[2].size();

        int maxf = -1,minc = inf;

        for(int i = 0; i < (1<<d); i++){

            init();

            int tc = 0;

            for(int j = 0; j < d; j++){

                if(i&(1<<j)){

                    addedge(vb[2][j].u,vb[2][j].v,inf);

                    tc += vb[2][j].w;

                }else{

                    addedge(vb[2][j].u,vb[2][j].v,1);

                }

            }

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

                addedge(0,i,city[i]);

            }

            for(int i = 0; i < vb[1].size(); i++){

                addedge(vb[1][i].u,vb[1][i].v,inf);

            }

            for(int i = 0; i < vb[0].size(); i++){

                addedge(vb[0][i].u,vb[0][i].v,inf);

                addedge(vb[0][i].u,n+1,vb[0][i].w);

            }

            int tm = maxflow();

            if(tm > maxf){

                maxf = tm;

                minc = tc;

            }

            if(tm==maxf && minc > tc){

                minc = tc;

            }

        }

        if(maxf==-1){

            printf("Poor Heaven Empire\n");

        }else{

            printf("%d %d\n",maxf,minc);

        }

    }

    return 0;

}