合成小丹（dp+二进制按位或+结论）

problem

给定 $n$ 个在 $[0,2^{\omega }-1]$ 内的整数。执行下面操作两种操作共 $n-1$ 次：

1. 选择两个整数 $x,y$ 从数列中删去，并加入 $\lfloor \frac{x|y}{2}\rfloor$，这里的 | 表示按位或。
2. 选择一个整数 $x$ 从序列中删去。

不难发现每次操作后拥有的整数数量恰好少一，在 $n-1$ 次操作后你将得到恰好一个整数。

最小化这个整数并输出你的结果。

多组数据，$1\le T\le 10$。

测试点编号	n	w	特殊性质
$1 ∼ 2 $	$\le 6$	$\le 60$	无
$3 ∼ 5 $	$\le 8$	$\le 60$	无
$6\sim 8$	$\le 300$	$\le 12$	无
$9\sim 12$	$\le 5000$	$\le 18$	无
$13\sim 15$	$\le 5000$	$\le 40$	无
$16\sim 17$	$\le 10^5$	$\le 60$	A
$18\sim 20$	$\le 10^5$	$\le 60$	无

特殊限制 A：保证所有 $a_i$ 都可以表示成 $2$ 的整数次幂减一的形式。

solution

$\lfloor \frac{x|y}{2}\rfloor$ 的 $/2$ 可以看作二进制右移一位，$\lfloor \frac{x|y}{2}\rfloor \iff (x|y)>>1\iff (x>>1)|(y>>1)\iff \lfloor \frac{x}{2}\rfloor |\lfloor \frac{y}{2}\rfloor$。

可以看到按位或操作后再右移等价于各个元素分别右移后再按位或。

设 $c_i:a_i$ 参与合并操作的次数 / 右移的位数。

则 $ans=\lfloor \frac{a_1}{2^{c_1}}\rfloor |\lfloor \frac{a_2}{2^{c_2}}\rfloor |...|\lfloor \frac{a_n}{2^{c_n}}\rfloor$。

有个显然是对的但又没想到的结论：在仅考虑合并操作的情况下，一组 { c i } \{c_i\} {ci​} 合法当且仅当 ${\sum }_{i=1}^n\frac{1}{2^{c_i}}=1$。

加上考虑删除操作的情况，可知一组 { c i } \{c_i\} {ci​} 合法当且仅当 ${\sum }_{i=1}^n\frac{1}{2^{c_i}}\ge 1$。

因为如果满足和 $\ge 1$，那么一定存在子集 S ⊂ { 1 , 2 , . . . , n } S\subset\{1,2,...,n\} S⊂{1,2,...,n} 满足 ${\sum }_{i\in S}\frac{1}{2^{c_i}}=1$，那么不在 $S$ 内的就是被删除元素。

换言之，${\sum }_{i=1}^n\frac{1}{2^{c_i}}$ 越大越有可能进入备选答案集合。

• case 6~8

基于此结论，我们可以设计一个非常暴力的状态转移方程。

设 $f_{i,j}:$ 考虑 $a[1\sim i]$ 这些数经过合并和删除一系列操作后的按位或为 $j$ 的 ${\sum }_{k=1}^i\frac{1}{2^{c_k}}$ 的最大值。

直接暴力转移，枚举 $a_i$ 右移的位数 $c_i$。
$$f_{i,j|(a_i>>c_i)}{\leftarrow }^{\max }{f}_{i-1,j}$$
状态数 $O(n{2}^{\omega })$，转移 $O(\omega )$，时间复杂度 $O(Tn{2}^{\omega }\omega )$。

for( int i = 0;i <= n;i ++ )
    for( int j = 0;j < (1 << w);j ++ )
        dp[i][j] = -1;
dp[0][0] = 0;
for( int i = 1;i <= n;i ++ ) 
    for( int j = 0;j <= (1 << w);j ++ ) {
        dp[i][j] = max( dp[i][j], dp[i - 1][j] );
        if( dp[i - 1][j] != -1 )
            for( int k = 0;k <= w;k ++ )
                dp[i][j | (a[i] >> k)] = max( dp[i][j | (a[i] >> k)], dp[i - 1][j] + 1.0 / (1 << k) );
    }
for( int i = 0;i < (1 << w);i ++ )
    if( dp[n][i] >= 1 ) { printf( "%lld\n", i ); break; }

• case 9~12

考虑对 $dp$ 进行优化。

考虑答案的上下界。显然答案不会超过 $2^{\omega -\lfloor {\log }_{2}n\rfloor }$（最大值与其余的数都进行合并操作）。

状态数 $O(n{2}^{\omega -\lfloor {\log }_{2}n\rfloor })=O(2^{\omega })$，转移 $O(\omega -\lfloor {\log }_{2}n\rfloor )$，时间复杂度 $O(T\omega 2^{\omega })$。

int m = 1 << (int)( w - log2( n ) + 1 );
for( int i = 0;i <= m;i ++ ) dp[0][i] = 0;
for( int i = 1;i <= n;i ++ ) {
    int d = i & 1;
    for( int j = 0;j <= m;j ++ ) dp[d][j] = dp[d ^ 1][j];
    for( int j = 0;j <= m;j ++ ) {
        for( int k = 0;k <= w;k ++ )
            if( ( j | (a[i] >> k) ) <= m )
                dp[d][j | (a[i] >> k)] = max( dp[d][j | (a[i] >> k)], dp[d ^ 1][j] + (1 << w - k) );
    }
}
for( int i = 0;i <= m;i ++ )
    if( dp[n & 1][i] >= (1 << w) ) { printf( "%lld\n", i ); break; }

• case 13~15

通过最原始的暴力 $dp$ 可知，我们能在 $O(n\omega )$ 的时间内判断一个数 $x$ 是否符合成为最后答案的要求。

即 $O(n)$ 枚举 $a_i$，$O(\omega )$ 枚举 $c_i$，在满足 $(a_i>>c_i)|x=x$ 的前提下尽可能减小 $c_i$，等价于尽可能增大 $\frac{1}{2^{c_i}}$。

通过 ${\sum }_{i=1}^n\frac{1}{2^{c_i}}\ge 1?$ 来判断 $x$ 能否成为候选答案。

所以我们贪心地从高位到低位考虑尽量填 $0$。

具体而言，先初始 $ans=2^{\omega }-1$（全 $1$），然后 $i=\omega \to 1$ 顺次考虑 $ans-2^i$ 是否可行，可行就 $ans-=2^i$ 即可。

时间复杂度 $O(Tn{\omega }^2)$。

bool check( int ans ) {
    int sum = 0;
    for( int i = 1;i <= n;i ++ ) {
        for( int j = 0;j <= w;j ++ )
            if( ( ans | (a[i] >> j) ) == ans ) { sum += ( 1ll << w - j ); break; }
        if( sum >= (1ll << w) ) return 1;
    }
    return 0;
}
int ans = ( 1ll << w ) - 1;
for( int i = w - 1;~ i;i -- )
    if( check( ans ^ (1ll << i) ) ) ans ^= (1ll << i);
printf( "%lld\n", ans );

• case 16~17，特殊情况 $A$。

显然只需要尽可能让最高位 $1$ 的二进制位最低。

那么每次从序列中选两个最大值，如果相同就合并右移一位，否则直接扔掉最大值。

priority_queue < int > q;
for( int i = 1;i <= n;i ++ ) q.push( a[i] );
while( q.size() > 1 ) {
    int x = q.top(); q.pop();
    int y = q.top(); q.pop();
    if( x == y ) q.push( x >> 1 );
    else q.push( y );
}
printf( "%lld\n", q.top() );

• case 1~20

其实 case 13~15 已经非常接近正解了。

事实上，从高位到低位按位考虑的时候，每个 $i$ 的 $c_i$ 并不需要从头开始枚举。

因为为了满足前面更高位的一些限制的时候，有的 $i$ 就已经要求右移一定位数了。

那么此时我们完全可以直接从之前右移的位数继续累加考虑。

这样每个 $i$ 的 $c_i$ 就只变化了一个 $1\sim \omega$ 的范围。

code

#include <bits/stdc++.h>
using namespace std;
#define int long long
#define maxn 100005
int T, n, w;
int a[maxn], temp[maxn], g[maxn];

signed main() {
    scanf( "%lld", &T );
    while( T -- ) {
        scanf( "%lld %lld", &n, &w );
        for( int i = 1;i <= n;i ++ ) scanf( "%lld", &a[i] );
        memset( g, 0, sizeof( g ) );
        int ans = (1ll << w) - 1;
        for( int k = w - 1;~ k;k -- ) {
            int now = ans ^ (1ll << k), sum = 0;
            for( int i = 1;i <= n;i ++ ) {
                temp[i] = g[i];
                while( ( a[i] >> g[i] | now ) ^ now ) g[i] ++;
                sum += 1ll << w - g[i];
                if( sum >= (1ll << w) ) sum = (1ll << w); //一直加可能炸long long
            }
            if( sum >= (1ll << w) ) ans = now;
            else memcpy( g, temp, sizeof( g ) );
        }
        printf( "%lld\n", ans );
    }
    return 0;
}