poj-3013堆优化+邻接链表（无限wrong，把inf设为-1，就避免了数据溢出的问题）

借鉴了一位大佬的博客：http://blog.csdn.net/zhang20072844/article/details/7770392

题目链接：http://poj.org/problem?id=3013

题目描述：
KCm要准备一颗圣诞树，这棵树有一些节点和边组成。节点从1到n，根总是1.每个节点都有自己的总量，而边的价格是由边的单价乘以子孙节点的重量。

求出这么一颗有n个节点的树，使花费最小。

很像最小生成树，仔细研究，没法这样做。因为每条边在找到这颗树之前很难计算它的价值。

因为本来你算好的边的价值，但是在去掉某些边时，会导致边的价值发生变化，那怎么办。。。。

这道题目开始我也是不知道怎么计算，看到discuss说是最短路。试想最后已经得到一个树，而每条边的价值就是子孙节点重量和乘以单价，可以转换为，此节点重量乘以从根到本节点的最短路，这么一转化，问题瞬间变得简单了。

那么所有点的最短路径一定是一棵树吗？ 这个是显然的 ，因为如果形成环了，到达某个点就出现了多个路径，就要删去长的那条，使其没有环

样例中的计算方法
4*40+3*50+2*60+3*(20+40+50+60)+2*30+1*(10+20+30+40+50+60)
=10*1+20*(1+3)+30*(2+1)+40*(4+1+3)+50*(3+1+3)+60*(1+2+3)
=10+80+90+320+350+360
=1210

题目要注意几个地方

1、n=0或者1， 答案是0，而不是no answer

2、数据范围大，要用long long

3、n=0或者1的时候也要将数据读入，不能直接输出0就不管输入了，否则会re

4、注意是无向图，建邻接表的时候要双向

5、数据量大，邻接矩阵不行，必须邻接表

6、最好把inf设为-1，就避免了数据溢出，而导致wrong的问题

代码如下：

#include <iostream>
#include <stdio.h>
#include <queue>
#include <string.h>

using namespace std;

const int maxn = 50000+5;
const int  inf = -1;

int done[maxn];  //标记数组
long long len[maxn]; //记录所有点到起点的最短距离

int T,v,e,a,b,c;
int weight[maxn];   //记录每个节点的权值

struct HeapNode
{
    int d,u;//分别表示离起点的距离和该点是哪个点
    bool operator < (const HeapNode& rhs) const
    {
        return d >rhs.d;
    }
}; //优先队列

struct Edge
{
    int to,val,next;
} edge[maxn*2];

int head[maxn];
int pos = 0;

void init()
{
    memset(head,-1,sizeof(head));
    memset(done,0,sizeof(done));
    memset(len,inf,sizeof(len));
}

void add_edge(int from,int to,int val)
{
    edge[pos].to = to;
    edge[pos].val = val;
    edge[pos].next = head[from];
    head[from] = pos;
    pos++;
    edge[pos].to = from;
    edge[pos].val = val;
    edge[pos].next = head[to];
    head[to] = pos;
    pos++;
}//邻接链表

void dijkstra()
{
    priority_queue<HeapNode> Q;//优先队列
    len[1]=0;
    Q.push((HeapNode)
    {
        0,1
    });
    while(!Q.empty())
    {
        HeapNode x= Q.top();
        Q.pop();
        int u= x.u;
        if(done[u])
            continue ;
        done[u]= 1;

        for(int i=head[u]; i!=-1; i=edge[i].next)
        {
            if(done[edge[i].to]==0&&((len[u]+edge[i].val<len[edge[i].to])||len[edge[i].to]==inf))
            {
                len[edge[i].to]=len[u]+edge[i].val;
                Q.push((HeapNode)
                {
                    len[edge[i].to],edge[i].to
                });
            }
        }

    }
    long long ans=0;

    for(int i=1; i<=v; i++)
    {
        if(len[i]==inf)
        {
            printf("No Answer\n");
            break;
        }
        else
        {
            ans+=len[i]*weight[i];
          // printf("%lld\n",len[i]);
        }
        if(i==v)
            printf("%lld\n",ans);
    }
}

int main()
{
    scanf("%d",&T);
    while(T--)
    {
        init();
        pos=0;

        scanf("%d%d",&v,&e);

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

        for(int i=1; i<=e; i++)
        {
            scanf("%d%d%d",&a,&b,&c);
            add_edge(a,b,c);
        }
        if(v==0||v==1)
        {
            printf("0\n");
            continue;
        }
        dijkstra();
    }
    return 0;
}