#2991. kiki君的护盾 (shield)

kiki君在镇妖塔中爆出了攻击力+8的护盾, 护盾是一个圆盘，圆盘上镶嵌着N颗宝石，编号为0~N-1。第i颗宝石的能量是Ai。如果Ai>0，表示这颗宝石能量过高，需要把Ai的能量传给其它宝石；如果Ai<0，表示这颗宝石的能量过低，需要从其它宝石处获取-Ai的能量。保证∑Ai =0。只有当所有宝石的能量均相同时，护盾才会被激活，并且会持续一段时间的不受伤害和攻击力提升至原来的5倍。

不过，只有M对宝石之间可以互相传递能量，其中第i对宝石之间无论传递多少能量，都要花费Ti的代价。kiki君想知道，最少需要花费多少代价才能使所有宝石的能量都相同?

输入格式

输入文件名为(shield.in)。

第一行两个整数N、M。

第二行N个整数Ai。

接下来M行每行三个整数pi,qi,Ti，表示在编号为pi和qi的宝石之间传递能量需要花费Ti的代价。数据保证每对pi、qi最多出现一次。

输出格式

输出文件名为(shield.out)。

输出一个整数表示答案。无解输出Impossible

样例
样例输入

3 3
50 -20 -30
0 1 10
1 2 20
0 2 100

样例输出

30

数据范围与提示

对于50%的数据，2<=N<=8。

对于100%的数据，2<=N<=16，0<=M<=N*(N-1)/2，0<=pi,qi<N，-1000<=Ai<=1000，0<=Ti<=1000，∑Ai=0。

状态压缩+动态规划+最小生成树
注意:枚举集合中的子集应为原始集合&（当前子集-1）

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
#include <cmath>
using namespace std;
const int N = 17, S = (1 << 16) - 1, Max = 1061109567;
int n, m, cost[S + 1], f[S + 1], fa[N], a[N], to[N][N], sum[S + 1];
bool flag[S + 1];
struct node {
    int x, y, val;
} b[400];
inline int lowbit(int x) { return x & (-x); }
bool cmp(node a, node b) { return a.val < b.val; }
inline int getfa(int x) {
    if (fa[x] == x)
        return x;
    return fa[x] = getfa(fa[x]);
}
inline bool kruscal(int x) {
    int tot = 0, ans = 0;
    for (int i = x; i; i -= lowbit(i)) {
        for (int j = 0; j < n; j++) {
            for (int k = j + 1; k < n; k++) {
                if (((i >> j) & 1) && ((i >> k) & 1)) {
                    fa[j + 1] = j + 1;
                    fa[k + 1] = k + 1;

                    if (to[j + 1][k + 1]) {
                        b[++tot].x = j + 1;
                        b[tot].y = k + 1;
                        b[tot].val = to[j + 1][k + 1];
                    }
                }
            }
        }
    }
    sort(b + 1, b + 1 + tot, cmp);
    int faa;
    for (int i = 1; i <= tot; i++) {
        int x = getfa(b[i].x), y = getfa(b[i].y);
        if (x == y)
            continue;
        ans += b[i].val;
        fa[x] = y;
        faa = y;
    }
    bool pd = true;
    for (int i = 0; i < n; i++) {
        if (((x >> i) & 1) && getfa(i + 1) != faa)
            pd = false;
    }
    if (pd)
        cost[x] = ans;
    return pd;
}
inline int get(int x) {
    int ans = 0;
    for (int i = 0; i < n; i++)
        if (((x >> i) & 1))
            ans += a[i + 1];
    return ans;
}
int main() {
    cin >> n >> m;
    memset(f, 0x3f3f3f, sizeof(f));
    memset(flag, true, sizeof(flag));
    for (int i = 1; i <= n; i++) {
        cin >> a[i];
    }
    for (int i = 1; i <= m; i++) {
        int x, y, z;
        cin >> x >> y >> z;
        x += 1, y += 1;
        to[x][y] = z;
        to[y][x] = z;
    }
    for (int i = 1; i <= (1 << n) - 1; i++) {
        sum[i] = get(i);
        if (sum[i] != 0)
            flag[i] = false;
        if (!kruscal(i))
            flag[i] = false;
        if (flag[i])
            f[i] = cost[i];
    }
    for (int i = 1; i <= (1 << n) - 1; i++) {
        if (!flag[i])
            continue;
        for (int j = (1 << n) - 1 - i; j; j = ((1 << n) - 1 - i) & (j - 1)) {
            if (flag[i] && flag[j])
                f[i | j] = min(f[i | j], f[i] + cost[j]);
        }
    }
    if (f[(1 << n) - 1] == Max)
        cout << "Impossible" << endl;
    else
        cout << f[(1 << n) - 1] << endl;
    return 0;
}