C 有趣的图

题意：

有n个城市，现在想让这n个城市的网络联通

有两种联通方式：

      1：直接联通两个单独的城市，花费为两个城市距离的平方.

       2：购买子网，购买后与子网中所有的网络联通，花费为子网的价格cost[].

让求联通这n个城市的最小的花费.

题解：

子网的数据范围是[0,8]，对于每个子网，我们能够选择买或者不买，那么总的方案数就是2^8=256种，直接二进制枚举所有能够购买子网的情况。

二进制枚举代码简洁，同样的思路用dfs来实现，后者代码冗长并且速度慢。

现在有两个物品，只需要枚举2^2=4次就可以了。

0—— 0 0

1—— 0 1

2—— 1 0

3—— 1 1

从0到3，把0和1当做选不选某一个物品，就比如3所对应的1，就代表选1和2.

 

&，与运算符：

相同为1，不同为0

1&1=1 0&0=1 1&0=0 0&1=0

 

<<，左移：

a<<b，代表把a转为二进制后左移b位。

左移一次，代表乘2.

通常认为a << 1比a * 2更快，因为前者是更底层一些的操作。因此程序中乘以2的操作请尽量用左移一位来代替。

 

对于每种选择方案，记录此时购买子网的花费，然后我们既然买了这些子网，首先是把它们使用并查集跟我们当前的网络连接，然后在上面的基础上求最小生成树，求得最小花费即可。

 

const int inf=0x3f3f3f3f;
const int maxn=1100;
const int maxm=1e6+100;
int n,m;//city and subnet
vector<int>G[maxn];
int number,cost[maxm],putss,father[maxn];

struct xiao{
    int x,y,w;
}a[maxn],num[maxm];

bool cmp(xiao a,xiao b){
    return a.w<b.w;
}

int find(int x){
    if(x==father[x]) return x;
    return father[x]=find(father[x]);
}

void update(int k){
    for(int i=0;i<G[k].size();++i){
        for(int j=i+1;j<G[k].size();++j){
            int fx=find(G[k][i]),fy=find(G[k][j]);
            if(fx!=fy) father[fx]=fy;
        }
    }
}

int Kruskal(int n)
{
    int ans=0;
    for(int i=0;i<n;++i){
        int fx=find(num[i].x),fy=find(num[i].y);
        if(fx!=fy){
            father[fx]=fy;
            ans+=num[i].w;
        }
    }
    return ans;
}

int main()
{
    int T;
    cin>>T;
    bool flag=false;
    while(T--){
        if(flag) cout<<endl;
        flag=true;
        putss=inf;
        scanf("%d%d",&n,&m);
        for(int i=0;i<m;++i){
            G[i].clear();
            scanf("%d%d",&number,&cost[i]);
            for(int j=0;j<number;++j){
                int x;
                scanf("%d",&x);
                G[i].push_back(x);
            }
        }
        for(int i=1;i<=n;++i){
            scanf("%d%d",&a[i].x,&a[i].y);
        }
        int cnt=0;
        for(int i=1;i<=n;++i){
            for(int j=i+1;j<=n;++j){
                num[cnt].x=i;
                num[cnt].y=j;
                num[cnt++].w=(a[i].x-a[j].x)*(a[i].x-a[j].x)+(a[i].y-a[j].y)*(a[i].y-a[j].y);
            }
        }
        sort(num,num+cnt,cmp);
        for(int i=0;i<(1<<m);++i){
            int ans=0;
            for(int j=0;j<=n;++j){
                father[j]=j;
            }
            for(int j=0;j<m;++j){
                if(i&(1<<j)){
                    update(j);
                    ans+=cost[j];
                }
            }
            ans+=Kruskal(cnt);
            putss=min(putss,ans);
        }
        cout<<putss<<endl;
    }
    return 0;
}