CSP day1

格雷码

题目描述

通常，人们习惯将所有 $n$ 位二进制串按照字典序排列，例如所有 2 位二进制串按字典序从小到大排列为：00，01，11，10。

格雷码（Gray Code）是一种特殊的 $n$ 位二进制串排列法，它要求相邻的两个二进制串间恰好有一位不同，特别地，第一个串与最后一个串也算作相邻。

所有 2 位二进制串按格雷码排列的一个例子为：00，01，11，10。

$n$ 位格雷码不止一种，下面给出其中一种格雷码的生成算法：

1. 1 位格雷码由两个 1 位二进制串组成，顺序为：0，1。

2. $n+1$ 位格雷码的前 $2^n$ 个二进制串，可以由依此算法生成的 $n$ 位格雷码（总共 $2^n$ 个 $n$ 位二进制串）按顺序排列，再在每个串前加一个前缀 0 构成。

3. $n+1$ 位格雷码的后 $2^n$ 个二进制串，可以由依此算法生成的 $n$ 位格雷码（总共 $2^n$ 个 $n$ 位二进制串）按逆序排列，再在每个串前加一个前缀 1 构成。

综上，$n+1$ 位格雷码，由 $n$ 位格雷码的 $2^n$ 个二进制串按顺序排列再加前缀 0，和按逆序排列再加前缀 1 构成，共 $2^{n+1}$ 个二进制串。另外，对于 $n$ 位格雷码中的 $2^n$ 个二进制串，我们按上述算法得到的排列顺序将它们从 $0\sim 2^{n-1}$ 编号。

按该算法，2 位格雷码可以这样推出：

1. 已知 1 位格雷码为 0，1。

2. 前两个格雷码为 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$，$k$，请你求出按上述算法生成的 $n$ 位格雷码中的 $k$ 号二进制串。

输入格式

仅一行两个整数 $n$，$k$，意义见题目描述。

输出格式

仅一行一个 $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\%$ 的数据：$n\le 10$

对于 $80\%$ 的数据：$k\le 5\times 10^6$

对于 $95\%$ 的数据：$k\le 2^{63}-1$

对于 $100\%$ 的数据：$1\le n\le 64,0\le k<2^n$

sol

根据题意转为十进制暴力模拟

$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;
}

期望得分$80pts$

考场中出现了一个情况，就是模拟到了$2^n$的数，但是考虑到$k$可能远小于$2^n$所以只要到$5e6$就行了。

失去$30pts$

$100pts$:

手玩发现发现第i位即$k\oplus \lfloor \frac{k}{2}\rfloor$的第i位

$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;
}

括号树

题目背景

本题中合法括号串的定义如下：

1. () 是合法括号串。

2. 如果 A 是合法括号串，则 (A) 是合法括号串。

3. 如果 A，B 是合法括号串，则 AB 是合法括号串。

本题中子串与不同的子串的定义如下：

1. 字符串 S 的子串是 S 中连续的任意个字符组成的字符串。S 的子串可用起始位置 $l$ 与终止位置 $r$ 来表示，记为 $S(l,r)$（$1\le l\le r\le |S|$ ，$|S|$ 表示 $S$ 的长度）。

2. $S$ 的两个子串视作不同当且仅当它们在 $S$ 中的位置不同，即 $l$ 不同或 $r$ 不同。

题目描述

一个大小为 $n$ 的树包含 $n$ 个结点和 $n-1$ 条边，每条边连接两个结点，且任意两个结点间有且仅有一条简单路径互相可达。

小 Q 是一个充满好奇心的小朋友，有一天他在上学的路上碰见了一个大小为 $n$ 的树，树上结点从 $1\sim n$ 编号，$1$ 号结点为树的根。除$1$ 号结点外，每个结点有一个父亲结点，$u$（$2\le u\le n$）号结点的父亲为 $f_u$（$1\le f_u<u$）号结点。

小 Q 发现这个树的每个结点上恰有一个括号，可能是( 或)。小 Q 定义 $s_i$ 为：将根结点到 $i$ 号结点的简单路径上的括号，按结点经过顺序依次排列组成的字符串。

显然 $s_i$ 是个括号串，但不一定是合法括号串，因此现在小 Q 想对所有的 $i$（$1\le i\le n$）求出，$s_i$ 中有多少个互不相同的子串是合法括号串。

这个问题难倒了小 Q，他只好向你求助。设 $s_i$ 共有 $k_i$个不同子串是合法括号串， 你只需要告诉小 Q 所有 $i\times k_i$ 的异或和，即：

$(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)$

其中 $xor$是位异或运算。

输入格式

第一行一个整数 $n$，表示树的大小。

第二行一个长为 $n$ 的由( 与) 组成的括号串，第 $i$ 个括号表示 $i$ 号结点上的括号。

第三行包含 $n-1$个整数，第 $i$（$1\le i<n$）个整数表示 $i+1$ 号结点的父亲编号 $f_{i+1}$。

输出格式

仅一行一个整数表示答案。

入输出样例

输入 #1

5
(()()
1 1 2 2

输出 #1

6

说明/提示

【样例解释1】

树的形态如下图：

将根到 1 号结点的简单路径上的括号，按经过顺序排列所组成的字符串为 (，子串是合法括号串的个数为 $0$。

将根到 2 号结点的字符串为 ((，子串是合法括号串的个数为 $0$。

将根到 3 号结点的字符串为 ()，子串是合法括号串的个数为 $1$。

将根到 4 号结点的字符串为 (((，子串是合法括号串的个数为 $0$。

将根到 5 号结点的字符串为 (()，子串是合法括号串的个数为 $1$。

【数据范围】

sol

用$h[i]$表示以第$i$个节点结束时的合法串数

用$w[i]$表示从根节点到$i$节点最近一个还没有匹配的左括号的节点编号

如果当前节点$x$为(的话，那么$w[x]=x$

如果是)的话若$w[x]\ne 0$，那么$h[x]=1+h[fa[w[x]]]$，$w[x]=w[fa[w[x]]]$( $fa[w[x]]$为$x$匹配的左括号的前一个 )

由于要求合法子串数，所以要对$h[i]$做个前缀和，然后再做异或

记得开$longlong$

$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-1$ 条边，结点从 $1\sim n$ 编号。初始时每个结点上都有一个 $1\sim n$ 的数字，且每个 $1\sim n$ 的数字都只在恰好一个结点上出现。

接下来你需要进行恰好 $n-1$ 次删边操作，每次操作你需要选一条未被删去的边，此时这条边所连接的两个结点上的数字将会交换，然后这条边将被删去。

$n-1$ 次操作过后，所有的边都将被删去。此时，按数字从小到大的顺序，将数字 $1\sim n$ 所在的结点编号依次排列，就得到一个结点编号的排列 $P_i$。现在请你求出，在最优操作方案下能得到的字典序最小的 $P_i$。

如上图，蓝圈中的数字 $1\sim 5$ 一开始分别在结点②、①、③、⑤、④。按照 (1)(4)(3)(2) 的顺序删去所有边，树变为下图。按数字顺序得到的结点编号排列为①③④②⑤，该排列是所有可能的结果中字典序最小的。

输入格式

本题输入包含多组测试数据。

第一行一个正整数 $T$，表示数据组数。

对于每组测试数据：

第一行一个整数 $n$，表示树的大小。

第二行 $n$ 个整数，第 $i$ ($1\le i\le n$) 个整数表示数字 $i$ 初始时所在的结点编号。

接下来 $n-1$ 行每行两个整数 $x$, $y$，表示一条连接 $x$ 号结点与 $y$ 号结点的边。

输出格式

对于每组测试数据，输出一行共 $n$ 个用空格隔开的整数，表示最优操作方案下所能得到的字典序最小的 $P_i$。

输入输出样例

输入 #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\le$	特殊性质
$1\sim 2$	10	无
$3\sim 4$	160	树的形态是一条链
$5\sim 7$	2000	同上
$8\sim 9$	160	存在度数为 $n-1$的结点
$10\sim 12$	2000	同上
$13\sim 16$	160	无
$17\sim 20$	2000	无

对于所有测试点：$1\le T\le 10$，保证给出的是一个树。

$sol$:

咕咕咕