7.25 2020牛客暑期多校训练营（第五场）题解及补题
目录
7.25 2020牛客暑期多校训练营（第五场）题解及补题
比赛过程
本场做F、I，I题猜测性质的出题，0.5，2/3；F题图形构造出了一些问题，好在及时修改，DE两题做法有误，菜了。
题解
B Graph
题意
给定一个顶点个数为\(n\)、边数为\(n−1\)的图，图上的边有边权，可执行的操作为在任意两个不连通的点之间连一条边和删去一条边，但在任何时候都应满足图是连通的且图中的任意一个环的所有边的边权异或和为0。
求图中边权和（不是异或和）的最小值。（\(n≤100000\)）
解法
求一些数的最大或最小异或值，我们可以很轻松的想到用字典树例如这个题最大异或对，如果已经会做这个题，我们
可以轻松的发现，在处理异或最值得问题时，往往要和字典树关联。学会了上面的题，我们不妨看一下下面这个题CF 888-G，
这个题除了用到了字典树还用到了分治的思想，其余的和“最大异或对”的做法类似。
下面就是本题的解法：因为图一直联通，并且环的异或和为0，所以从A点到B点的路径的异或和一定是固定的，我们可以构造每个点的权值，那么两点
之间连边的权值就应该是两端点权值的异或，这样问题就转化成了异或最小生成树的问题，也就用到了字典树。
代码
#include<bits/stdc++.h>
using namespace std;
const int maxn=100000+100;
int n,a[maxn],tot;
int trie[maxn*30][2];
long long ans;
vector<pair<int,int> >G[maxn];
void dfs1(int u,int fa)
{
for(pair<int,int> v:G[u])
{
if(v.first!=fa)
{
a[v.first]=a[u]^v.second;
dfs1(v.first,u);
}
}
}
void Insert(int x){
int rt=0;
for(int i=29;i>=0;i--)
{
int now=(x>>i)&1;
if(!trie[rt][now]) trie[rt][now]=++tot;
rt=trie[rt][now];
}
}
int Search(int x)
{
int ans=0,rt=0;
for(int i=29;i>=0;i--)
{
int now=(x>>i)&1;
if(trie[rt][now]){
rt=trie[rt][now];
}
else{
rt=trie[rt][now^1];
ans|=(1<<i);
}
}
return ans;
}
void dfs(int l,int r,int dep)
{
if(dep<0 || l>=r)return;
int mid=l-1;
while(mid<r && (a[mid+1]&(1<<dep))==0)mid++;
dfs(l,mid,dep-1);
dfs(mid+1,r,dep-1);
if(mid==l-1 || mid==r)return;
for(int i=l;i<=mid;i++)Insert(a[i]);
int tmp=INT_MAX;
for(int i=mid+1;i<=r;i++)tmp=min(tmp,Search(a[i]));
ans+=tmp;
for(int i=0;i<=tot;i++) {
trie[i][0]=trie[i][1]=0;
}
tot=0;
}
int main()
{
cin>>n;
int u,v,w;
for(int i=1;i<n;i++)
{
scanf("%d%d%d",&u,&v,&w);
u++,v++;
G[u].push_back(make_pair(v,w));
G[v].push_back(make_pair(u,w));
}
dfs1(1,0);
sort(a+1,a+1+n);
dfs(1,n,29);
cout<<ans<<endl;
}
D Drop Voicing
题意
给定一个1~n的排列，有两种操作：
操作1：可以将倒数第二个数放到开头
操作2：可以将开头的第一个数放到最后
连续的第一种操作值花费1，第二种操作不花费。
问你最少花费多少能使得排列变成顺序。
解法
假设我们要将p[pos]插入p[i] 和 p[i + 1]之间，则可以先利用有限次操作2将x放到最后一个，然后再连续利用有限次操作1将p[i + 1]到p[pos - 1]的数移动到开头，再连续利用操作2将此时开头的元素放到结尾，这样实际效果就是任意一个数插入任意位置只花费1。所以只需要找环上的最长上升子序列，剩下的元素个数就是最少花费。
代码
#include <bits/stdc++.h>
#define IO ios::sync_with_stdio(0), cin.tie(0)
using namespace std;
typedef long long ll;
const int maxn = 500 + 5;
const int inf = ~0u >> 1;
typedef pair<int,int> P;
#define REP(i, a, n) for (int i = a; i < (n); ++i)
#define PER(i, a, n) for (int i = (n) - 1; i >= a; --i)
int p[maxn], dp[maxn];
int LIS(int n) {
fill(dp, dp + n, 1);
REP(i, 0, n) {
REP(j, 0, i) {
if (p[i] > p[j])
dp[i] = max(dp[i], dp[j] + 1);
}
}
return dp[n - 1];
}
int main() {
IO;
int n;
cin >> n;
REP(i, 0, n) {
cin >> p[i];
}
int ans = 0;
REP(i, 0, n) {
ans = max(ans, LIS(n));
rotate(p, p + 1, p + n); //rotate左旋转，rotate(原起始，旋转后起始，原结尾)
}
cout << n - ans << endl;
return 0;
}
E Bogo Sort
题意
置换方式为\(c[i]=a[b[i]]\)，\(a\)为初始数字，\(b\)为置换数组。
给你初始\(b\)数组，求存在多少个\(a\)数组经过一些置换可以变成有序数组。
解法
找置换群，每一个组的置换群的个数求最小公倍数。
代码
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cerrno>
#include <clocale>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <limits>
#include <list>
#include <map>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <utility>
#include <vector>
#include <cwchar>
#include <cwctype>
using namespace std;
typedef long long ll;
#define IO ios::sync_with_stdio(false), cin.tie(0)
#define FOR(a,b,c) for(int a=b;a<=c;a++)
#define MAXN 9999
#define MAXSIZE 1010
#define DLEN 4
class BigNum{
private:
int a[5000]; //可以控制大数的位数
int len;
public:
BigNum(){len=1;memset(a,0,sizeof(a));} //构造函数
BigNum(const ll); //将一个int类型的变量转化成大数
BigNum(const char*); //将一个字符串类型的变量转化为大数
BigNum(const BigNum &); //拷贝构造函数
BigNum &operator=(const BigNum &); //重载赋值运算符，大数之间进行赋值运算
friend istream& operator>>(istream&,BigNum&); //重载输入运算符
friend ostream& operator<<(ostream&,BigNum&); //重载输出运算符
BigNum operator+(const BigNum &)const; //重载加法运算符，两个大数之间的相加运算
BigNum operator-(const BigNum &)const; //重载减法运算符，两个大数之间的相减运算
BigNum operator*(const BigNum &)const; //重载乘法运算符，两个大数之间的相乘运算
BigNum operator/(const int &)const; //重载除法运算符，大数对一个整数进行相除运算
BigNum operator^(const int &)const; //大数的n次方运算
int operator%(const int &)const; //大数对一个int类型的变量进行取模运算
bool operator>(const BigNum &T)const; //大数和另一个大数的大小比较
bool operator>(const int &t)const; //大数和一个int类型的变量的大小比较
void print(); //输出大数
};
BigNum::BigNum(const ll b) //将一个int类型的变量转化为大数
{
ll c,d=b;
len=0;
memset(a,0,sizeof(a));
while(d>MAXN){
c=d-(d/(MAXN+1))*(MAXN+1);
d=d/(MAXN+1);
a[len++]=c;
}
a[len++]=d;
}
BigNum::BigNum(const char *s) //将一个字符串类型的变量转化为大数
{
int t,k,index,L,i;
memset(a,0,sizeof(a));
L=strlen(s);
len=L/DLEN;
if(L%DLEN)len++;
index=0;
for(i=L-1;i>=0;i-=DLEN)
{
t=0;
k=i-DLEN+1;
if(k<0)k=0;
for(int j=k;j<=i;j++)
t=t*10+s[j]-'0';
a[index++]=t;
}
}
BigNum::BigNum(const BigNum &T):len(T.len) //拷贝构造函数
{
int i;
memset(a,0,sizeof(a));
for(i=0;i<len;i++)
a[i]=T.a[i];
}
BigNum & BigNum::operator=(const BigNum &n) //重载赋值运算符，大数之间赋值运算
{
int i;
len=n.len;
memset(a,0,sizeof(a));
for(i=0;i<len;i++)
a[i]=n.a[i];
return *this;
}
istream& operator>>(istream &in,BigNum &b)
{
char ch[MAXSIZE*4];
int i=-1;
in>>ch;
int L=strlen(ch);
int count=0,sum=0;
for(i=L-1;i>=0;)
{
sum=0;
int t=1;
for(int j=0;j<4&&i>=0;j++,i--,t*=10)
{
sum+=(ch[i]-'0')*t;
}
b.a[count]=sum;
count++;
}
b.len=count++;
return in;
}
ostream& operator<<(ostream& out,BigNum& b) //重载输出运算符
{
int i;
cout<<b.a[b.len-1];
for(i=b.len-2;i>=0;i--)
{
printf("%04d",b.a[i]);
}
return out;
}
BigNum BigNum::operator+(const BigNum &T)const //两个大数之间的相加运算
{
BigNum t(*this);
int i,big;
big=T.len>len?T.len:len;
for(i=0;i<big;i++)
{
t.a[i]+=T.a[i];
if(t.a[i]>MAXN)
{
t.a[i+1]++;
t.a[i]-=MAXN+1;
}
}
if(t.a[big]!=0)
t.len=big+1;
else t.len=big;
return t;
}
BigNum BigNum::operator-(const BigNum &T)const //两个大数之间的相减运算
{
int i,j,big;
bool flag;
BigNum t1,t2;
if(*this>T)
{
t1=*this;
t2=T;
flag=0;
}
else
{
t1=T;
t2=*this;
flag=1;
}
big=t1.len;
for(i=0;i<big;i++)
{
if(t1.a[i]<t2.a[i])
{
j=i+1;
while(t1.a[j]==0)
j++;
t1.a[j--]--;
while(j>i)
t1.a[j--]+=MAXN;
t1.a[i]+=MAXN+1-t2.a[i];
}
else t1.a[i]-=t2.a[i];
}
t1.len=big;
while(t1.a[len-1]==0 && t1.len>1)
{
t1.len--;
big--;
}
if(flag)
t1.a[big-1]=0-t1.a[big-1];
return t1;
}
BigNum BigNum::operator*(const BigNum &T)const //两个大数之间的相乘
{
BigNum ret;
int i,j,up;
int temp,temp1;
for(i=0;i<len;i++)
{
up=0;
for(j=0;j<T.len;j++)
{
temp=a[i]*T.a[j]+ret.a[i+j]+up;
if(temp>MAXN)
{
temp1=temp-temp/(MAXN+1)*(MAXN+1);
up=temp/(MAXN+1);
ret.a[i+j]=temp1;
}
else
{
up=0;
ret.a[i+j]=temp;
}
}
if(up!=0)
ret.a[i+j]=up;
}
ret.len=i+j;
while(ret.a[ret.len-1]==0 && ret.len>1)ret.len--;
return ret;
}
BigNum BigNum::operator/(const int &b)const //大数对一个整数进行相除运算
{
BigNum ret;
int i,down=0;
for(i=len-1;i>=0;i--)
{
ret.a[i]=(a[i]+down*(MAXN+1))/b;
down=a[i]+down*(MAXN+1)-ret.a[i]*b;
}
ret.len=len;
while(ret.a[ret.len-1]==0 && ret.len>1)
ret.len--;
return ret;
}
int BigNum::operator%(const int &b)const //大数对一个 int类型的变量进行取模
{
int i,d=0;
for(i=len-1;i>=0;i--)
d=((d*(MAXN+1))%b+a[i])%b;
return d;
}
BigNum BigNum::operator^(const int &n)const //大数的n次方运算
{
BigNum t,ret(1);
int i;
if(n<0)exit(-1);
if(n==0)return 1;
if(n==1)return *this;
int m=n;
while(m>1)
{
t=*this;
for(i=1;(i<<1)<=m;i<<=1)
t=t*t;
m-=i;
ret=ret*t;
if(m==1)ret=ret*(*this);
}
return ret;
}
bool BigNum::operator>(const BigNum &T)const //大数和另一个大数的大小比较
{
int ln;
if(len>T.len)return true;
else if(len==T.len)
{
ln=len-1;
while(a[ln]==T.a[ln]&&ln>=0)
ln--;
if(ln>=0 && a[ln]>T.a[ln])
return true;
else
return false;
}
else
return false;
}
bool BigNum::operator>(const int &t)const //大数和一个int类型的变量的大小比较
{
BigNum b(t);
return *this>b;
}
void BigNum::print() //输出大数
{
int i;
printf("%d",a[len-1]);
for(i=len-2;i>=0;i--)
printf("%04d",a[i]);
printf("\n");
}
ll gcd(ll a, ll b) {return b==0?a:gcd(b, a%b);}
const int maxn = 1e5 + 5;
int A[maxn];
int vis[maxn] = {0};
//求置换群组的最小公倍数
int main(){
IO;
int n;
cin >> n;
FOR(i,1,n){
cin >> A[i];
}
BigNum ans=BigNum(1);
//ll ans = 1;
FOR(i,1,n){
if(!vis[i]){
vis[A[i]] = 1;
int cnt = 1;
int p = A[A[i]];
while(p!=A[i]){
vis[p] = 1;
p = A[p];
cnt++;
}
ll temp = ans % cnt;
if(temp>0){
temp = gcd(cnt, temp);
ans = ans * cnt;
ans = ans / temp;
}
}
}
ans.print();
return 0;
}
F DPS
题意
解法
代码
#include <bits/stdc++.h>
#define IO ios::sync_with_stdio(0), cin.tie(0)
using namespace std;
typedef long long ll;
const int maxn = 100 + 5;
const int inf = ~0u >> 1;
typedef pair<int,int> P;
#define REP(i, a, n) for (int i = a; i < (n); ++i)
#define PER(i, a, n) for (int i = (n) - 1; i >= a; --i)
ll d[maxn];
int main() {
IO;
int n;
cin >> n;
ll maxd = -1;
REP(i, 0, n) {
cin >> d[i];
maxd = max(maxd, d[i]);
}
REP(i, 0, n) {
ll s = 50ll * d[i] / maxd;
if (50 * d[i] % maxd)
s++;
cout << '+';
REP(j, 0, s) {
cout << '-';
}
cout << '+' << endl;
cout << '|';
int blank = s;
if (d[i] == maxd)
blank--;
REP(j, 0, blank) {
cout << ' ';
}
if (d[i] == maxd)
cout << '*';
cout << '|' << d[i] << endl;
cout << '+';
REP(j, 0, s) {
cout << '-';
}
cout << '+' << endl;
}
return 0;
}
I Hard Math Problem
题意
\(n×m\)的棋盘，每个格子可以放\(G,H,E\)
但是每个\(H\)旁边必须有一个\(G\)或者\(E\)，\(f(n,m)\)为这个棋盘可以放置的最多\(H\)数
求\(n\),\(m\)都无穷大时的$ \frac{f(n,m)}{n×m}$
解法
\(EEEEEEEE\)
\(HHHHHHHH\)
\(HHHHHHHH\)
\(GGGGGGGG\)
\(HHHHHHHH\)
\(HHHHHHHH\)
类似的因为无穷大，排列下去。
代码
#include <bits/stdc++.h>
using namespace std;
int main()
{
double ans=0.5;
cout<<0.666667<<endl;
return 0;
}
浙公网安备 33010602011771号