2021年牛客寒假集训营第一场题解

A、 串

思路：
一共n个字符，可以转化为 i (1<=i<=n) 个字母中包含"us"的方案数之和
用 f[i][2/1/0] 表示前 i 个字母中 含有us/含u但不含us/既不含u也不含us 的方案数
然后可得状态转移方程：
f[i][0] = 25 * f[i - 1][0] //前i-1个字符不含u也不含s，那么第 i 个字符除了u可以在另外25个字母中随便填
f[i][1] = f[i - 1][0] + 25f[i - 1][1] //前i-1个字符既不含u也不含us的话，那么第 i 个就填u，前 i-1 个字符含u不含us的话，第i个除了s之外25个字母中随便填
f[i][2] = f[i-1][1] + 26f[i-1][2] //前i-1个字符含u不含us的话，那么第 i 个就填s，前 i-1 个字符含us的话，第i个可以在26个字母中随便填
初始化：f[1][0] = 25，f[1][1] = 1，f[1][2] = 0;

代码：

#include <bits/stdc++.h>

using namespace std;

typedef long long LL;

const int N = 1e6 + 5, MOD = 1e9 + 7;

LL n, ans;
//f[i][0]表示前i个字符没有u的串的数量 
//f[i][1]表示前i个字符有u无us的串的数量 
//f[i][2]表示前i个字符有us的串的数量
LL f[N][4];

int main() {
	scanf("%lld", &n);
	f[1][0] = 25;
	f[1][1] = 1;
	f[1][2] = 0;
	for (int i = 2; i <= n; i++) {
		f[i][0] = (f[i - 1][0] * 25) % MOD;
		f[i][1] = (f[i - 1][1] * 25 + f[i - 1][0]) % MOD;
		f[i][2] = (f[i - 1][1] + f[i - 1][2] * 26) % MOD;
		ans = (ans + f[i][2]) % MOD;
	}
	printf("%lld\n", ans);
	return 0;
} 

B、 括号

思路：
若想使构造的括号串最短，可以先构造出一个“((…))”的对称符号串，该符号串中的合法括号对有k*k个（k为对称匹配的括号对数量），然后在此基础上插入新的半边括号即可构成有任意对数的括号串

代码：

#include <bits/stdc++.h>

using namespace std;

typedef long long LL;

LL k;
string s;

int main() {
    scanf("%lld", &k);
    s += ' ';
    if (!k)
        puts(")(");
    else if (k == 1)
        puts("()");
    else if (k == 2)
        puts("())");
    else if (k == 3) 
        puts("()()");
    else {
        LL t1 = sqrt(k * 1.0);
        LL t2 = k - t1 * t1;
        LL m1 = t1, m2 = t1;
        while (m1--)
            s += '(';
        while (m2--) 
            s += ')';
        if (t1 * t1 == k) {
            for (int i = 1; i < s.size(); i++)
                cout << s[i];
        	return 0;
		}
        if (t2 <= t1) {
        	s[t2] = ')', s[0] = '(';
            cout << s << "\n";
		}
		else {
			s[t1] = ')', s[0] = '(';
			t2 -= t1;
			s[t1 + t1 - t2 + 1] = '(';
			s += ')';
            cout << s << "\n";
 		}
    }
	return 0;
}

C、红与蓝

思路：

从叶节点入手，从叶节点开始，将它的颜色染成和它父亲相同的颜色，如果按这个规律染完后所有的节点都染上色了，那么就构造成功了，否则就无法构造满足条件的染色树

代码：

#include <bits/stdc++.h>

using namespace std;

const int N = 1e5 + 5, M = N * 2;

int n, idx, cnt;
bool flag = 1;
int h[N], e[M], ne[M];
int f[N], col[N];

void add(int a, int b) {
    e[idx] = b;
    ne[idx] = h[a];
    h[a] = idx++;
}

void dfs1(int x, int fa) {
	int son = 0;
	for (int i = h[x]; i != -1; i = ne[i]) {
		int j = e[i];
		//连的双向边特判掉父节点 
		if (j == fa) 
			continue;
		son++;
		dfs1(j, x);
	}
	//若该节点没有子节点或者该节点未被染色 
	if (!son || !f[x]) {
		//若其父节点已被染色则无解 
		if (f[fa]) {
			flag = 0;
			return ;
		}
		//若其父节点未被染色则给其染上相同的颜色 
		f[x] = f[fa] = ++cnt;;
	}
}

void dfs2(int x, int fa) {
	for (int i = h[x]; i != -1; i = ne[i]) {
		int j = e[i];
		if (j == fa)
			continue;
		//交替染色 
		if (f[j] == f[x]) 
			col[j] = col[x];
		else
			col[j] = col[x] ^ 1;
		dfs2(j, x);
			
	}
}

int main() {
	memset(h, -1, sizeof h);
	scanf("%d", &n);
	for (int i = 1; i < n; i++) {
		int x, y;
		scanf("%d%d", &x, &y);
		add(x, y);
		add(y, x);
	}
	dfs1(1, 0);
	//若根节点未被染色或有节点没有被染色 
	if (f[0] || !flag) {
		printf("-1\n");
		return 0;
	}
	//根节点染上红色 
	col[1] = 1;
	dfs2(1, 0);
	for (int i = 1; i <= n; i++) {
		if (col[i] == 1)
			printf("R");
		else
			printf("B");
	}
	return 0;
}

F、 对答案一时爽

思路：
最小值为0，最大值为n加上两人所选的相同选项数

代码：

#include <bits/stdc++.h>

using namespace std;

char a[105], b[105];

int main() {
	int n;
    scanf("%d", &n);
    for (int i = 1; i <= n; i++) 
        cin >> a[i];
    for (int i = 1; i <= n; i++) 
        cin >> b[i];
    int k = 0;
    for (int i = 1; i <= n; i++) {
        if (a[i] == b[i])
            k++;
    }
    printf("%d 0\n", n + k);
    return 0;
}

H、幂塔

思路：找规律/欧拉降幂（待补）

I、限制不互素对的排列

思路：
重点在于题目中的 k <= n/2 ，答案就很显然了，当k < n/2时，在前面放 k+1 个偶数即可，当 k == n/2 时，将偶数6放在最后，然后6后面接上3，后面位置从1开始按顺序放没有用过的整数即可

代码：

#include <bits/stdc++.h>

using namespace std;

int n, k;
vector<int> v;
set<int> s;

int main() {
	scanf("%d%d", &n, &k);
	if (n <= 5 && k == n / 2)
		puts("-1");
	else {
		for (int i = 2; i <= n; i += 2) 
			if (i != 6)
				v.push_back(i);
		v.push_back(6);
		v.push_back(3);
		for (int i = 0; i <= k; i++) {
			cout << v[i] << ' ';
			s.insert(v[i]);
		}
		for (int i = 1; i <= n; i++) {
			if (!s.count(i))
				cout << i << ' ';
		}
	}
	return 0;
}

J、一群小青蛙呱蹦呱蹦呱

思路：

剩余的数除了1以外，每个数一定可以分解为两个或两个以上质数相乘，求多个数的最小公倍数实际上就是求所有数中出现的每个质因子的最大次方，然后相乘即可

所以先用欧拉筛筛出1 ~ n中的所有质数，然后求出每个质数在1 ~ n出现的最大次方（推公式）相乘，注意此时我们只用筛选1 ~ n/2 部分的质数即可

代码：

#include <bits/stdc++.h>

using namespace std;

typedef long long LL;

const LL N = 2e8 + 5, MOD = 1e9 + 7;

LL n, k, ans = 1;
LL prime[N];
bool st[N];

void init(LL m) {
    for (int i = 2; i <= m; i++) {
        if (!st[i])
            prime[++k] = i;
        for (int j = 1; prime[j] <= m / i; j++) {
            st[prime[j] * i] = true;
            if (i % prime[j] == 0)
                break;
        }
    }
}

LL qpow(LL a, LL b, LL m) {
    LL ans = 1 % m;
    while (b) {  
        if (b & 1)
            ans = ans * a % m;
        a = a * a % m;
        b >>= 1;  
    }
    return ans;
}

int main() { 
    scanf("%lld", &n);
    init(n / 2);
    for (int i = 1; i <= k; i++) {
    	LL t;
    	if (i == 1) 
    		t = (log(n / 3) / log(2));
		else 
			t = (log(n / 2) / log(prime[i]));
        //cout << t << ' ';
        ans = (ans * qpow(prime[i], t, MOD)) % MOD;
	}
    if (ans == 1)
        puts("empty");
    else
	    printf("%lld\n", ans);
    return 0;
}