hdu2452---记忆化搜索

//一颗树，边是单向的，每个节点有一定的权值，要你从根节点走到叶子节点，走到第偶数节点时，使后面的权值和最小；走到第奇数节点时，使后面的权值和最大
//边链表存储，并查集查找根节点
//用val[i][0]表示第i个节点是偶数节点的值和val[i][1]表示第i个节点是奇数节点的值
//递归的计算，因为节点很多，所以要记忆化搜索
#include <iostream>
#include<stdio.h>
#include<string.h>
using namespace std;
#define inf 1234567890
#define N 10005
#define M 500000
int n,m,t,sumf,tot;
int ans[N],next[N],f[N],val[N][2];
struct TNode
{
    int u,v,tot;
} node[M];
void addedge(int u,int v)
{
    node[tot].u=u,node[tot].v=v,node[tot].tot=next[u];
    next[u]=tot++;
}
int find(int x)
{
    int r,tmp;
    for(r=x;r!=f[r];r=f[r]);
    while(r!=x)
    {
        tmp=f[x];
        f[x]=r;
        x=tmp;
    }
    return r;
}
void merge(int u,int v)
{
    int l=find(u),r=find(v);
    if(l==r) return ;
    f[r]=l;
}
void init()
{
    int i,u,v;
    memset(next,-1,sizeof(next));
    for(i=0; i<=n; i++)
    {
        f[i]=i;
        val[i][0]=0;
        val[i][1]=inf;
    }
    for(i=1; i<=n; i++) scanf("%d",&ans[i]);
    for(i=tot=0; i<m; i++)
    {
        scanf("%d%d",&u,&v);
        addedge(u,v);
        merge(u,v);
    }
}
void dfs(int id,int u)
{
    int i,k,v;
    if(next[u]==-1)
    {
        val[u][0]=val[u][1]=ans[u];return ;
    }
    k=id^1;
    if(val[u][0]&&val[u][1]!=inf) return ;
    for(i=next[u];i>=0;i=node[i].tot)
    {
        v=node[i].v;
        dfs(k,v);
        if(id==1)
        {
            if(val[u][id]>val[v][k]+ans[u]) val[u][id]=val[v][k]+ans[u];
        }
        else
        {
            if(val[u][id]<val[v][k]+ans[u]) val[u][id]=val[v][k]+ans[u];
        }
    }
}
int main()
{
    int i,j,k,u,v;
    while(scanf("%d%d%d",&n,&m,&sumf)!=EOF)
    {
        init();
        u=find(1);
        dfs(0,u);
        v=val[u][0];
        if(v>=sumf) puts("Victory");
        else puts("Glory");
    }
    return 0;
}