F. Divide, XOR, and Conquer

题意

给定一个非负整数数组

a

a

a,定义操作:

对于区间

[

l

,

r

]

[l,r]

[l,r],选择一个分界点

l

k

<

r

l \leq k < r

l≤k

[

l

,

k

]

[l,k]

[l,k] 和

[

k

+

1

,

r

]

[k + 1, r]

[k+1,r] 两部分,然后留下异或和更大的那一部分,丢弃小的那部分。如果异或和一样,可以随意选择留下哪部分。

问对于

i

[

1

,

n

]

\forall i \in [1,n]

∀i∈[1,n],能否从一开始的数组到只留下

a

i

a_i

ai​,即

l

=

r

=

i

l = r = i

l=r=i

思路

这里比较明显的是区间的转移,可以考虑用区间

D

P

DP

DP 来解决。对于当前的区间

[

l

,

r

]

[l,r]

[l,r],我们定义左边部分的异或和为

s

1

s_1

s1​,右边部分的异或和为

s

2

s_2

s2​,显然要能够实现

[

l

,

k

]

[l,k]

[l,k],必须有

s

1

s

2

s_1 \geq s_2

s1​≥s2​。

如果我们直接采用传统区间

D

P

DP

DP 的方法,枚举每一个长度的区间的分界点,时间复杂度会到达

O

(

n

3

)

O(n^3)

O(n3),记录状态的空间复杂度也过高。

进一步观察发现:

[

l

,

r

]

[l,r]

[l,r] 区间的异或和为

s

s

s 且

s

=

0

s = 0

s=0 的话,有

s

=

s

1

s

2

=

0

s = s_1 \bigoplus s_2 = 0

s=s1​⨁s2​=0,即

s

1

=

s

2

s_1 = s_2

s1​=s2​ ,这时候我们区间的分界点可以任选,也就是说可以从区间

[

l

,

r

]

[l,r]

[l,r] 转移到任何从

l

l

l 开始的或者到

r

r

r 结束的长度小于

r

l

+

1

r - l + 1

r−l+1 的区间。若

s

0

s \neq 0

s=0,我们只能留下异或和更大的那个部分,如果

s

s

s 的最高位为

b

i

t

bit

bit 的话,(假设

s

1

>

s

2

s_1 > s_2

s1​>s2​) 我们容易发现在

b

i

t

bit

bit 这一位一定是

s

1

[

b

i

t

]

=

1

,

s

2

[

b

i

t

]

=

0

s_1[bit] = 1,s_2[bit] = 0

s1​[bit]=1,s2​[bit]=0,这样子

s

1

s_1

s1​ 才会大于

s

2

s_2

s2​。所以对于那些 从

l

l

l 开始的或者到

r

r

r 结束的长度小于

r

l

+

1

r - l + 1

r−l+1 的区间,如果它们的异或和的最高位也是

b

i

t

bit

bit 的话,那么就可以从

[

l

,

r

]

[l,r]

[l,r] 转移到这些区间!

我们如果按照区间长度从大到小枚举区间,对于当前枚举的区间

[

l

,

r

]

[l,r]

[l,r],如果它可达的话, 可以对于区间端点维护四种信息:

s

t

[

l

]

st[l]

st[l] 表示从

l

l

l 开始的任意长度更短区间,如果它们要可达,异或和最高位必须存在于

s

t

[

l

]

st[l]

st[l] 里。

e

d

[

r

]

ed[r]

ed[r] 则表示到

r

r

r 结束的任意长度更短区间,如果它们要可达,异或和最高位必须存在于

s

t

[

l

]

st[l]

st[l] 里。

s

t

0

[

l

]

st0[l]

st0[l] 和

e

d

0

[

r

]

ed0[r]

ed0[r] 则表示是否存在长度更大的区间异或和为

0

0

0 ,可以转移到这些端点的更小区间。

对于当前区间

[

l

,

r

]

[l,r]

[l,r] 的最高位

b

i

t

bit

bit ,如果它可达,

如果

s

=

0

s = 0

s=0,那么后续任意长度更小的从

l

l

l 开始的或者到

r

r

r 结束的区间都可达(从

[

l

,

r

]

[l,r]

[l,r]转移过去),这时我们记录

s

t

0

[

l

]

=

e

d

0

[

r

]

=

t

r

u

e

st0[l] = ed0[r] = true

st0[l]=ed0[r]=true如果

s

0

s \neq 0

s=0, 那么我们在

s

t

[

l

]

st[l]

st[l] 和

e

d

[

r

]

ed[r]

ed[r] 加上

b

i

t

bit

bit 的标记,表示后续更短的从

l

l

l 开始的或者到

r

r

r 结束的区间的

m

a

s

k

mask

mask,如果它们的异或和

s

m

a

s

k

>

0

s\prime \wedge mask > 0

s′∧mask>0,则说明它们可以从某个更长的区间转移过来,因为这个区间的异或和

s

s\prime

s′ 的最高位 和 某个

s

s

s 重合了

最终时间复杂度:

O

(

n

2

)

O(n^2)

O(n2)

#include

#define fore(i,l,r) for(int i=(int)(l);i<(int)(r);++i)

#define fi first

#define se second

#define endl '\n'

#define ull unsigned long long

#define ALL(v) v.begin(), v.end()

#define Debug(x, ed) std::cerr << #x << " = " << x << ed;

const int INF=0x3f3f3f3f;

const long long INFLL=1e18;

typedef long long ll;

int main(){

std::ios::sync_with_stdio(false);

std::cin.tie(nullptr);

std::cout.tie(nullptr);

int t;

std::cin >> t;

while(t--){

int n;

std::cin >> n;

std::vector a(n + 1);

std::vector st(n + 1, 0), ed(n + 1, 0);

std::vector st0(n + 1, false), ed0(n + 1, false);

std::vector sum(n + 1, 0);

fore(i, 1, n + 1){

std::cin >> a[i];

sum[i] = sum[i - 1] ^ a[i];

}

std::vector ans(n + 1, 0);

for(int len = n; len >= 1; --len)

fore(L, 1, n - len + 2){

int R = L + len - 1;

ll s = sum[R] ^ sum[L - 1];

ll bit = 1ll << std::__lg(s);

if(len == n || st0[L] || ed0[R] || (s & st[L]) || (s & ed[R])){

if(len == 1) ans[L] = 1;

if(!s) st0[L] = ed0[R] = true;

else{

st[L] |= bit;

ed[R] |= bit;

}

}

}

fore(i, 1, n + 1) std::cout << ans[i];

std::cout << endl;

}

return 0;

}

推荐文章

评论可见,请评论后查看内容,谢谢!!!评论后请刷新页面。