BZOJ 2460 元素(线性基)

Posted 2020-10-10 抓不住Jerry的Tom

Description

  相传，在远古时期，位于西方大陆的 Magic Land 上，人们已经掌握了用魔
法矿石炼制法杖的技术。那时人们就认识到，一个法杖的法力取决于使用的矿石。
一般地，矿石越多则法力越强，但物极必反：有时，人们为了获取更强的法力而
使用了很多矿石，却在炼制过程中发现魔法矿石全部消失了，从而无法炼制
出法杖，这个现象被称为“魔法抵消” 。特别地，如果在炼制过程中使用超过
一块同一种矿石，那么一定会发生“魔法抵消”。 
  后来，随着人们认知水平的提高，这个现象得到了很好的解释。经过了大量
的实验后，著名法师 Dmitri 发现：如果给现在发现的每一种矿石进行合理的编
号（编号为正整数，称为该矿石的元素序号），那么，一个矿石组合会产生“魔
法抵消”当且仅当存在一个非空子集，那些矿石的元素序号按位异或起来
为零。 （如果你不清楚什么是异或，请参见下一页的名词解释。 ）例如，使用两
个同样的矿石必将发生“魔法抵消”，因为这两种矿石的元素序号相同，异或起
来为零。 
  并且人们有了测定魔力的有效途径，已经知道了：合成出来的法杖的魔力
等于每一种矿石的法力之和。人们已经测定了现今发现的所有矿石的法力值，
并且通过实验推算出每一种矿石的元素序号。 
   现在，给定你以上的矿石信息，请你来计算一下当时可以炼制出的法杖最多
有多大的魔力。 
 

Input

第一行包含一个正整数N，表示矿石的种类数。 
  接下来 N行，每行两个正整数Numberi 和 Magici，表示这种矿石的元素序号
和魔力值。

 

Output

仅包一行，一个整数：最大的魔力值

 

Sample Input

3
1 10
2 20
3 30

Sample Output

50

 

 

我们将宝石按照权值排序,然后从小到大加入到线性基里面,如果某个宝石能加入到线性基那么就加上它的贡献

 1 #include <bits/stdc++.h>
 2 
 3 using namespace std;
 4 typedef long long ll;
 5 const int maxn = 1100;
 6 struct node
 7 {
 8     ll x,y;
 9 }p[maxn];
10 ll g[63];//线性基从63开始 有的61
11 bool cmp (node q1,node q2)
12 {
13     return q1.y>q2.y;
14 }
15 int n;
16 int main()
17 {
18     //freopen("de.txt","r",stdin);
19     while (~scanf("%d",&n)){
20         memset(g,0,sizeof g);
21         for (int i=0;i<n;++i){
22             scanf("%lld%lld",&p[i].x,&p[i].y);
23         }
24         ll ans = 0;
25         sort(p,p+n,cmp);
26         for (int i=0;i<n;++i){
27             for (int j=63;j>=0;--j){
28                 if ((p[i].x>>j)&1){
29                     if (g[j]){
30                         p[i].x^=g[j];
31 
32                     }
33                     else {
34                         g[j] = p[i].x;
35                         break;
36                     }
37                 }
38             }
39             if (p[i].x) ans+=p[i].y;
40         }
41         /*for (int i=0;i<=5;++i)
42             printf("%lld ",g[i]);
43         printf("\n");*/
44         printf("%lld\n",ans);
45     }
46     return 0;
47 }

附上线性基模板

 1 struct L_B{
 2     long long d[61],p[61];
 3     int cnt;
 4     L_B()
 5     {
 6         memset(d,0,sizeof(d));
 7         memset(p,0,sizeof(p));
 8         cnt=0;
 9     }
10     bool insert(long long val)//插入元素
11     {
12         for (int i=60;i>=0;i--)
13             if (val&(1LL<<i))
14             {
15                 if (!d[i])
16                 {
17                     d[i]=val;
18                     break;
19                 }
20                 val^=d[i];
21             }
22         return val>0;
23     }
24     long long query_max()//查询异或最大值
25     {
26         long long ret=0;
27         for (int i=60;i>=0;i--)
28             if ((ret^d[i])>ret)
29                 ret^=d[i];
30         return ret;
31     }
32     long long query_min()//查询异或最小值
33     {
34         for (int i=0;i<=60;i++)
35             if (d[i])
36                 return d[i];
37         return 0;
38     }
39     
40 
41     我们要将线性基改造成每一位相互独立。 
42     具体操作就是如果i<j，aj的第i位是1，就将aj异或上ai。 
43     经过一系列操作之后，对于二进制的某一位i。只有ai的这一位是1，其他都是0。 
44     所以查询的时候将k二进制拆分，对于1的位，就异或上对应的线性基。 
45     最终得出的答案就是k小值。
46     void rebuild()
47     {
48         for (int i=60;i>=0;i--)
49             for (int j=i-1;j>=0;j--)
50                 if (d[i]&(1LL<<j))
51                     d[i]^=d[j];
52         for (int i=0;i<=60;i++)
53             if (d[i])
54                 p[cnt++]=d[i];
55     }
56     long long kthquery(long long k)
57     {
58         int ret=0;
59         if (k>=(1LL<<cnt))
60             return -1;
61         for (int i=60;i>=0;i--)
62             if (k&(1LL<<i))
63                 ret^=p[i];
64         return ret;
65     }
66 }
67 L_B merge(const L_B &n1,const L_B &n2)//归并两个线性基
68 {
69     L_B ret=n1;
70     for (int i=60;i>=0;i--)
71         if (n2.d[i])
72             ret.insert(n1.d[i]);
73     return ret;
74 }