题意：要造一个圣诞树（可以想象成倒过来的树结构），有n个节点，m条边，并告诉你边的信息，两条边之间有个单位造价，

一条树枝的造价=它上面的节点的重量以及节点子树的重量 * 这条树枝的单位造价。

需求出造这个圣诞树的最小造价，也有可能造不出。

画画图可以看出，总造价 = 每一点的重量 * 它到节点的最短路径，所以这道题其实就是个最短路

题目比较坑，dist数组会越界，需用long long，并且INF不能以int的最大值来赋值。边也不是他给的5W条，我开到20W才AC

我用了dijkstra+heap的写法，之前也不会，越看越像spfa把队列改成了优先队列，实际上也是这样，但是经过这样处理每一次入队都会处理出对于这个节点来说的最优解，可以把spfa的k次入队减为1次入队，缩短了时间。

不过我还是比较喜欢用我自己的说法：dijkstra+heap打着堆优化的幌子穿着dijkstra的外衣干着spfa的事。

开玩笑，实际上速度能快很多。

#include<cstring>
#include<string>
#include<fstream>
#include<iostream>
#include<iomanip>
#include<cstdio>
#include<cctype>
#include<algorithm>
#include<queue>
#include<map>
#include<set>
#include<vector>
#include<stack>
#include<ctime>
#include<cstdlib>
#include<functional>
#include<cmath>
using namespace std;
#define PI acos(-1.0)
#define MAXN 50010
#define eps 1e-7
#define INF 0x7FFFFFFF
#define seed 131
#define ll long long
#define ull unsigned ll
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1

struct EDGE{
    int u,w,next;
}edge[MAXN*4];
struct NODE{
    int u,dis;
    bool operator < (const NODE &t) const{
        return t.dis < dis;
    }
};
int head[MAXN],vis[MAXN],w[MAXN];
long long dist[MAXN];
int n,m,cnt;
void add_edge(int a,int b,int c){
    edge[cnt].u = b;
    edge[cnt].w = c;
    edge[cnt].next = head[a];
    head[a] = cnt++;
}
void dijkstra_heap(){
    int i,j;
    NODE t1,t2;
    for(i=1;i<=n;i++)   dist[i] = 100000000000000LL;
    dist[1] = 0;
    priority_queue<NODE>q;
    t1.u = 1;
    t1.dis = 0;
    q.push(t1);
    while(!q.empty()){
        t1 = q.top();
        q.pop();
        if(vis[t1.u]==1)  continue;
        vis[t1.u] = 1;
        for(i=head[t1.u];i!=-1;i=edge[i].next){
            int x = edge[i].w;
            if(dist[t1.u]+x<dist[edge[i].u]){
                dist[edge[i].u] = dist[t1.u] + x;
                t2.dis = dist[edge[i].u];
                t2.u = edge[i].u;
                q.push(t2);
            }
        }
    }
}

int main(){
    //freopen("11.txt","r",stdin);
    //freopen("22.txt","w",stdout);
    int t,i,j,a,b,c;
    long long ans;
    scanf("%d",&t);
    while(t--){
        memset(head,-1,sizeof(head));
        memset(vis,0,sizeof(vis));
        cnt = 0;
        ans = 0;
        scanf("%d%d",&n,&m);
        for(i=1;i<=n;i++){
            scanf("%d",&w[i]);
        }
        for(i=0;i<m;i++){
            scanf("%d%d%d",&a,&b,&c);
            add_edge(a,b,c);
            add_edge(b,a,c);
        }
        dijkstra_heap();
        int flag = 1;
        for(i=2;i<=n;i++){
            if(dist[i]==100000000000000LL){
                flag = 0;
                break;
            }
            ans += dist[i] * w[i];
            //cout<<i<<" "<<dist[i]<<" "<<w[i]<<endl;
        }
        if(flag)    printf("%I64d\n",ans);
        else    puts("No Answer");
    }
    return 0;
}