格雷码
题目描述
通常,人们习惯将所有 n n n 位二进制串按照字典序排列,例如所有 2 位二进制串按字典序从小到大排列为:00,01,11,10。
格雷码(Gray Code)是一种特殊的 n n n 位二进制串排列法,它要求相邻的两个二进制串间恰好有一位不同,特别地,第一个串与最后一个串也算作相邻。
所有 2 位二进制串按格雷码排列的一个例子为:00,01,11,10。
n n n 位格雷码不止一种,下面给出其中一种格雷码的生成算法:
-
1 位格雷码由两个 1 位二进制串组成,顺序为:0,1。
-
n + 1 n + 1 n+1 位格雷码的前 2 n 2^n 2n 个二进制串,可以由依此算法生成的 n n n 位格雷码(总共 2 n 2^n 2n 个 n n n 位二进制串)按顺序排列,再在每个串前加一个前缀 0 构成。
-
n + 1 n + 1 n+1 位格雷码的后 2 n 2^n 2n 个二进制串,可以由依此算法生成的 n n n 位格雷码(总共 2 n 2^n 2n 个 n n n 位二进制串)按逆序排列,再在每个串前加一个前缀 1 构成。
综上, n + 1 n + 1 n+1 位格雷码,由 n n n 位格雷码的 2 n 2^n 2n 个二进制串按顺序排列再加前缀 0,和按逆序排列再加前缀 1 构成,共 2 n + 1 2^{n+1} 2n+1 个二进制串。另外,对于 n n n 位格雷码中的 2 n 2^n 2n 个二进制串,我们按上述算法得到的排列顺序将它们从 0 ∼ 2 n − 1 0 \sim 2^{n-1} 0∼2n−1 编号。
按该算法,2 位格雷码可以这样推出:
-
已知 1 位格雷码为 0,1。
-
前两个格雷码为 00,01。后两个格雷码为 11,10。合并得到 00,01,11,10,编号依次为 0 ~ 3。
同理,3 位格雷码可以这样推出:
已知 2 位格雷码为:00,01,11,10。
前四个格雷码为:000,001,011,010。后四个格雷码为:110,111,101,100。合并得到:000,001,011,010,110,111,101,100,编号依次为 0 ~ 7。
现在给出 n n n, k k k,请你求出按上述算法生成的 n n n 位格雷码中的 k k k 号二进制串。
输入格式
仅一行两个整数 n n n, k k k,意义见题目描述。
输出格式
仅一行一个 n n n 位二进制串表示答案。
输入输出样例
输入 #1
2 3
输出 #1
10
输入 #2
3 5
输出 #2
111
输入 #3
44 1145141919810
输出 #3
00011000111111010000001
说明/提示
【样例 1 解释】
2 位格雷码为:00,01,11,10,编号从 0∼3,因此 3 号串是 10。
【样例 2 解释】
3 位格雷码为:000,001,011,010,110,111,101,100,编号从 0∼7,因此 5 号串是 111。
【数据范围】
对于 50 % 50\% 50% 的数据: n ≤ 10 n \leq 10 n≤10
对于 80 % 80\% 80% 的数据: k ≤ 5 × 1 0 6 k \leq 5 \times 10^6 k≤5×106
对于 95 % 95\% 95% 的数据: k ≤ 2 63 − 1 k \leq 2^{63} - 1 k≤263−1
对于 100 % 100\% 100% 的数据: 1 ≤ n ≤ 64 , 0 ≤ k < 2 n 1 \leq n \leq 64, 0 \leq k \lt 2^n 1≤n≤64,0≤k<2n
sol
根据题意转为十进制暴力模拟
c o d e code code:
#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int twx=7e6+100;
ll read()
{
ll flag=1;
ll sum=0;
char c=getchar();
while(c<'0'||c>'9')
{
if(c=='-')
{
flag=-1;
}
c=getchar();
}
while(c>='0'&&c<='9')
{
sum=(sum*10)+(int)(c-'0');
c=getchar();
}
return sum*flag;
}
ll n,k;
ll num[twx];
int asd[twx];
int cnt=0;
void init()
{
n=read();
k=read();
}
void to_bin(ll x)
{
while(x)
{
int tmp=x%2;
asd[++cnt]=tmp;
x/=2;
}
}
void work()
{
num[0]=0;
num[1]=1;
for(int i=1;i<=n;i++)
{
int qwe=1<<i;
if(qwe>5e6)
{
break ;
}
ll tmp1=(1<<i)-1;
ll tmp2=(1<<i+1)-1;
int asd=(1<<i);
reverse(num,num+asd);
for(int j=tmp1+1;j<=tmp2;j++)
{
num[j]=num[j-(1<<i)];
}
reverse(num,num+asd);
for(int j=tmp1+1;j<=tmp2;j++)
{
num[j]+=(1<<i);
}
}
to_bin(num[k]);
for(int i=1;i<=n-cnt;i++)
{
cout<<0;
}
for(int i=cnt;i>=1;i--)
{
cout<<asd[i];
}
}
int main()
{
init();
work();
return 0;
}
期望得分 80 p t s 80pts 80pts
考场中出现了一个情况,就是模拟到了 2 n 2^n 2n的数,但是考虑到 k k k可能远小于 2 n 2^n 2n所以只要到 5 e 6 5e6 5e6就行了。
失去 30 p t s 30pts 30pts
100 p t s 100pts 100pts:
手玩发现发现第i
位即
k
⊕
⌊
k
2
⌋
k\oplus \lfloor\frac k2\rfloor
k⊕⌊2k⌋的第i
位
c o d e code code:
#include<bits/stdc++.h>
using namespace std;
const int twx=1e6+100;
const int inf=0x3f3f3f3f;
ll read()
{
ll sum=0;
ll flag=1;
char c=getchar();
while(c<'0'||c>'9')
{
if(c=='-')
{
flag=-1;
}
c=getchar();
}
while(c>='0'&&c<='9')
{
sum=((sum*10)+c-'0');
c=getchar();
}
return sum*flag;
}
ll n,k;
void init()
{
n=read();
k=read();
}
void work()
{
k^=k>>1;
}
void print()
{
while(n--)
{
printf("%llu",k>>n&1);
}
}
int main()
{
init();
work();
print();
return 0;
}
括号树
题目背景
本题中合法括号串的定义如下:
-
()
是合法括号串。 -
如果
A
是合法括号串,则(A)
是合法括号串。 -
如果
A
,B
是合法括号串,则AB
是合法括号串。
本题中子串与不同的子串的定义如下:
-
字符串
S
的子串是S
中连续的任意个字符组成的字符串。S
的子串可用起始位置 l l l 与终止位置 r r r 来表示,记为 S ( l , r ) S (l, r) S(l,r)( 1 ≤ l ≤ r ≤ ∣ S ∣ 1 \leq l \leq r \leq |S| 1≤l≤r≤∣S∣ , ∣ S ∣ |S| ∣S∣ 表示 S S S 的长度)。 -
S S S 的两个子串视作不同当且仅当它们在 S S S 中的位置不同,即 l l l 不同或 r r r 不同。
题目描述
一个大小为 n n n 的树包含 n n n 个结点和 n − 1 n − 1 n−1 条边,每条边连接两个结点,且任意两个结点间有且仅有一条简单路径互相可达。
小 Q 是一个充满好奇心的小朋友,有一天他在上学的路上碰见了一个大小为 n n n 的树,树上结点从 1 ∼ n 1 ∼ n 1∼n 编号, 1 1 1 号结点为树的根。除 1 1 1 号结点外,每个结点有一个父亲结点, u u u( 2 ≤ u ≤ n 2 \leq u \leq n 2≤u≤n)号结点的父亲为 f u f_u fu( 1 ≤ f u < u 1 \leq f_u < u 1≤fu<u)号结点。
小 Q 发现这个树的每个结点上恰有一个括号,可能是(
或)
。小 Q 定义
s
i
s_i
si 为:将根结点到
i
i
i 号结点的简单路径上的括号,按结点经过顺序依次排列组成的字符串。
显然 s i s_i si 是个括号串,但不一定是合法括号串,因此现在小 Q 想对所有的 i i i( 1 ≤ i ≤ n 1\leq i\leq n 1≤i≤n)求出, s i s_i si 中有多少个互不相同的子串是合法括号串。
这个问题难倒了小 Q,他只好向你求助。设 s i s_i si 共有 k i k_i ki个不同子串是合法括号串, 你只需要告诉小 Q 所有 i × k i i \times k_i i×ki 的异或和,即:
( 1 × k 1 ) xor ( 2 × k 2 ) xor ( 3 × k 3 ) xor ⋯ xor ( n × k n ) (1 \times k_1)\ \text{xor}\ (2 \times k_2)\ \text{xor}\ (3 \times k_3)\ \text{xor}\ \cdots\ \text{xor}\ (n \times k_n) (1×k1) xor (2×k2) xor (3×k3) xor ⋯ xor (n×kn)
其中 x o r xor xor是位异或运算。
输入格式
第一行一个整数 n n n,表示树的大小。
第二行一个长为 n n n 的由( 与) 组成的括号串,第 i i i 个括号表示 i i i 号结点上的括号。
第三行包含 n − 1 n − 1 n−1个整数,第 i i i( 1 ≤ i < n 1 \leq i \lt n 1≤i<n)个整数表示 i + 1 i + 1 i+1 号结点的父亲编号 f i + 1 f_{i+1} fi+1。
输出格式
仅一行一个整数表示答案。
入输出样例
输入 #1
5
(()()
1 1 2 2
输出 #1
6
说明/提示
【样例解释1】
树的形态如下图:
将根到 1 号结点的简单路径上的括号,按经过顺序排列所组成的字符串为 (
,子串是合法括号串的个数为
0
0
0。
将根到 2 号结点的字符串为 ((
,子串是合法括号串的个数为
0
0
0。
将根到 3 号结点的字符串为 ()
,子串是合法括号串的个数为
1
1
1。
将根到 4 号结点的字符串为 (((
,子串是合法括号串的个数为
0
0
0。
将根到 5 号结点的字符串为 (()
,子串是合法括号串的个数为
1
1
1。
【数据范围】
sol
用 h [ i ] h[i] h[i]表示以第 i i i个节点结束时的合法串数
用 w [ i ] w[i] w[i]表示从根节点到 i i i节点最近一个还没有匹配的左括号的节点编号
如果当前节点
x
x
x为(
的话,那么
w
[
x
]
=
x
w[x]=x
w[x]=x
如果是)
的话若
w
[
x
]
≠
0
w[x]\not=0
w[x]=0,那么
h
[
x
]
=
1
+
h
[
f
a
[
w
[
x
]
]
]
h[x]=1+h[fa[w[x]]]
h[x]=1+h[fa[w[x]]],
w
[
x
]
=
w
[
f
a
[
w
[
x
]
]
]
w[x]=w[fa[w[x]]]
w[x]=w[fa[w[x]]](
f
a
[
w
[
x
]
]
fa[w[x]]
fa[w[x]]为
x
x
x匹配的左括号的前一个 )
由于要求合法子串数,所以要对 h [ i ] h[i] h[i]做个前缀和,然后再做异或
记得开 l o n g l o n g long\ long long long
c o d e code code:
#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int twx=5e5+100;
const int inf=0x3f3f3f3f;
ll read()
{
ll sum=0;
ll flag=1;
char c=getchar();
while(c<'0'||c>'9')
{
if(c=='-')
{
flag=-1;
}
c=getchar();
}
while(c>='0'&&c<='9')
{
sum=((sum*10)+c-'0');
c=getchar();
}
return sum*flag;
}
ll n;
ll h[twx];
ll w[twx];
ll fa[twx];
ll ans;
char s[twx];
struct LV
{
ll Next;
ll y;
}a[twx];
ll Link[twx];
ll len;
void Insert(ll x,ll y)
{
a[++len].y=y;
a[len].Next=Link[x];
Link[x]=len;
}
void dfs(ll x)
{
w[x]=w[fa[x]];
if(s[x]=='(')
{
w[x]=x;
}
else if(w[x])
{
h[x]=h[fa[w[x]]]+1;
w[x]=w[fa[w[x]]];
}
for(ll i=Link[x];i;i=a[i].Next)
{
ll y=a[i].y;
dfs(y);
}
}
void init()
{
n=read();
scanf("%s",s+1);
for(ll i=2;i<=n;i++)
{
ll x=read();
fa[i]=x;
Insert(x,i);
}
dfs(1);
ans=h[1];
for(ll i=2;i<=n;i++)
{
h[i]+=h[fa[i]];
ans^=(i*h[i]);
}
printf("%lld\n",ans);
}
int main()
{
init();
return 0;
}
树上的数
题目描述
给定一个大小为 n n n 的树,它共有 n n n 个结点与 n − 1 n - 1 n−1 条边,结点从 1 ∼ n 1 \sim n 1∼n 编号。初始时每个结点上都有一个 1 ∼ n 1 \sim n 1∼n 的数字,且每个 1 ∼ n 1 \sim n 1∼n 的数字都只在恰好一个结点上出现。
接下来你需要进行恰好 n − 1 n - 1 n−1 次删边操作,每次操作你需要选一条未被删去的边,此时这条边所连接的两个结点上的数字将会交换,然后这条边将被删去。
n − 1 n - 1 n−1 次操作过后,所有的边都将被删去。此时,按数字从小到大的顺序,将数字 1 ∼ n 1 \sim n 1∼n 所在的结点编号依次排列,就得到一个结点编号的排列 P i P_i Pi。现在请你求出,在最优操作方案下能得到的字典序最小的 P i P_i Pi。
如上图,蓝圈中的数字 1 ∼ 5 1 \sim 5 1∼5 一开始分别在结点②、①、③、⑤、④。按照 (1)(4)(3)(2) 的顺序删去所有边,树变为下图。按数字顺序得到的结点编号排列为①③④②⑤,该排列是所有可能的结果中字典序最小的。
输入格式
本题输入包含多组测试数据。
第一行一个正整数 T T T,表示数据组数。
对于每组测试数据:
第一行一个整数 n n n,表示树的大小。
第二行 n n n 个整数,第 i i i ( 1 ≤ i ≤ n 1 \leq i \leq n 1≤i≤n) 个整数表示数字 i i i 初始时所在的结点编号。
接下来 n − 1 n - 1 n−1 行每行两个整数 x x x, y y y,表示一条连接 x x x 号结点与 y y y 号结点的边。
输出格式
对于每组测试数据,输出一行共 n n n 个用空格隔开的整数,表示最优操作方案下所能得到的字典序最小的 P i P_i Pi。
输入输出样例
输入 #1
4
5
2 1 3 5 4
1 3
1 4
2 4
4 5
5
3 4 2 1 5
1 2
2 3
3 4
4 5
5
1 2 5 3 4
1 2
1 3
1 4
1 5
10
1 2 3 4 5 7 8 9 10 6
1 2
1 3
1 4
1 5
5 6
6 7
7 8
8 9
9 10
输出 #1
1 3 4 2 5
1 3 5 2 4
2 3 1 4 5
2 3 4 5 6 1 7 8 9 10
说明/提示
【数据范围】
测试点编号 | n ≤ n \leq n≤ | 特殊性质 |
---|---|---|
1 ∼ 2 1 \sim 2 1∼2 | 10 | 无 |
3 ∼ 4 3 \sim 4 3∼4 | 160 | 树的形态是一条链 |
5 ∼ 7 5 \sim 7 5∼7 | 2000 | 同上 |
8 ∼ 9 8 \sim 9 8∼9 | 160 | 存在度数为 n − 1 n - 1 n−1的结点 |
10 ∼ 12 10 \sim 12 10∼12 | 2000 | 同上 |
13 ∼ 16 13 \sim 16 13∼16 | 160 | 无 |
17 ∼ 20 17 \sim 20 17∼20 | 2000 | 无 |
对于所有测试点: 1 ≤ T ≤ 10 1 \leq T \leq 10 1≤T≤10,保证给出的是一个树。
s o l sol sol: