零件组装“盛大游戏杯”第15届上海大学程序设计联赛夏季赛

零件组装

 

描述

现有n个零件，小Y花费了很多时间来收集它们，现在他想把零件拼在一起，拼完就可以召唤神龙了。已知零件之间存在相邻的关系，拥有相邻关系的零件在最终的组装结果中就是相邻的，并且组装过程中每次只能通过相邻关系来组合零件。小Y每次可以选择两个零件（也可以是两个零件块，或一个零件与一个零件块）拼起来，成为一个零件块，但要求拼接时必须在两个零件块（或零件）之间存在相邻的零件。除此之外这些零件两两之间有类似于磁力的排斥关系，当将两个零件或者零件块拼接在一起的时候，会受到两边的零件间的排斥力，排斥力的大小=两边零件的相互排斥对数*单侧零件个数的最大值（拼接完成的零件组合体中的零件之间排斥不计）。现在已知零件间的相邻关系和排斥关系，小Y自然想知道如何拼接不费力，因此需要求出将这些零件组装起来的最优方案，使得所有步骤的排斥力之和最小。

输入

第一行有一个整数T表示数据组数。（T<=20）
接着有T组数据，每组数据第一行是整数n表示零件个数。
接着依此有两个n∗n的矩阵，都只由0和1构成。(2<=n<=14)
其中第一个矩阵表示零件两两之间的相邻关系，第i行第j列为1表示第i个零件与第j个零件相邻，
第二个矩阵表示零件两两之间的排斥关系，第i行第j列为1表示第i个零件与第j个零件排斥。
数据保证矩阵根据对角线对称，并保证通过零件的相邻关系可以最终拼接完成。

输出

每组输入一个整数表示拼接过程的最小排斥力之和。

样例输入1

1
4
0 0 1 1
0 0 1 0
1 1 0 0
1 0 0 0
0 1 0 1
1 0 1 1
0 1 0 0
1 1 0 0

样例输出1

6

题解：

dp[i] 表示该状态下，最小排斥力

枚举任意两个子集组合？， 2^28TLE

枚举一个集合，枚举它的子集，3^14

转移14*14  会TLE

神奇预处理后，O(1)

ji[i]  表示 零件组合i下， 含有的零件个数

G[i] 表示 零件组合i下，内部含有 相邻关系的对数

F[i] 表示 零件组合i下，内部含有 排斥关系的对数

对于两个状态i,j想要组合情况下，我们利用F,G数组容斥一下是不是就可以O(1)转移了

#include<bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:102400000,102400000")
#define ls i<<1
#define rs ls | 1
#define mid ((ll+rr)>>1)
#define pii pair<int,int>
#define MP make_pair
typedef long long LL;
const long long INF = 1e18+1LL;
const double pi = acos(-1.0);
const int N = 50+10, M = 1e3+20,inf = 2e9;


int T,a[N][N],b[N][N],n;
LL dp[1<<15];
LL G[1<<15];
LL F[1<<15];
int ji[1<<15];
int main() {
    scanf("%d",&T);
    while(T--) {
        scanf("%d",&n);
        for(int i = 0; i < n; ++i)
            for(int j = 0; j < n; ++j) scanf("%d",&a[i][j]);
        for(int i = 0; i < n; ++i)
            for(int j = 0; j < n; ++j) scanf("%d",&b[i][j]);
         int U = (1<<n) - 1;
         for(int i = 0; i <= U; ++i) {
            ji[i] = 0;F[i] = 0;
            G[i] = 0;
         }
        for(int i = 0; i <= U; ++i) {
            for(int j = 0; j < n; ++j) {
                if(((1<<j)&i)) ji[i]++;
               for(int k = j+1; k < n; ++k) {
                if(((i&(1<<j)) && (i&(1<<k))) && a[j][k]) G[i]++;
               }
            }
         }
        for(int i = 0; i <= U; ++i) {
            for(int j = 0; j < n; ++j) {
               for(int k = j+1; k < n; ++k) {
                if(((i&(1<<j)) && (i&(1<<k))) && b[j][k]) F[i]++;
               }
            }
         }
         //cout<<F[15]<<" "<<F[6]<<" "<<F[9]<<endl;
        for(int i = 0; i <= U; ++i) dp[i] = INF;
        dp[0] = 0;
        for(int i = 0; i < n; ++i) dp[1<<i] = 0;

        for(int ii = 0; ii <= U; ++ii) {
             for(int jj = ii; jj; jj = (jj-1)&ii)
            {
                int i = jj, j = ii^jj;
                if(G[i|j] - G[i] - G[j]) {
                    dp[i|j] = min(dp[i|j],dp[i]+dp[j]+1LL*(F[i|j] - F[i] - F[j])*max(ji[i],ji[j]));
                }
            }
        }
        printf("%lld\n",dp[U]);
    }
    return 0;
}

 

“盛大游戏杯”第15届上海大学程序设计联赛夏季赛暨上海高校金马五校赛 L 零件组装 状态压缩+预处理优化+枚举子集