比赛感想##
本来21:05开始的比赛，结果记成21:30了。。。晚了25分钟才开始[捂脸]
这次是Educational Round，所以还比较简单。
前两道题一眼看去模拟+贪心，怕错仔细看了好几遍题，很快切掉
第三题，dfs+贪心
一开始想得有点简单，少了几种情况，写代码时才发现问题……
悲伤地发现 写+调 这道题用了我很长时间…（这叫什么？基础不牢，地动山摇！）
然后，居然只剩40分钟了……
第四题，啊啊啊！
图论，我的痛！ 果断跳过
第五题，额，不就是个线段树么？
n<=10 (^9) ？不好不好，要动态开节点
噼里啪啦噼里啪啦……
提交。为什么超时了？？？ 我的常数真的这么大么？？
调一调…还是不行。。（……比赛结束后才发现是编译器的问题……）
然后，居然只剩10分钟了……
第六题，啊啊啊！怎么又是图论！
图论，我的痛！果断跳过
第七题，数论，有关gcd
奇迹般地有了思路，可惜，时间不够没写完……
接着，悲伤地发现比赛结束了。悲伤地发现我只做对了3道水题…
嗯，水平还有很大提升空间啊，前方路还很长……
题目+题解##
Codeforces 915###
A. Garden###
Luba要给花园浇水，花园长度为k
她有n个水桶，每个水桶一次浇的长度为(a_i) （不能多也不能少）
她要选择1个水桶，使她浇得最快，且不会有地方被浇两次，不会浇到花园外面
求她浇完的最短时间。
（n,k,(a_i) (leq) 100）
想法####
在ai中找到可整除k的最大的数，用k除以这个数便是答案
代码####
#include<cstdio>
#include<iostream>
#include<algorithm>
using namespace std;
int main()
{
int n,k,i,x,ans=1000;
scanf("%d%d",&n,&k);
for(i=0;i<n;i++){
scanf("%d",&x);
if(k%x!=0) continue;
ans=min(ans,k/x);
}
printf("%d
",ans);
return 0;
}
B. Browser###
Luba在浏览器中打开了n个标签，从左到右标号1~n
她只需[l,r]的标签，所以她要把其他的标签关上
她的鼠标停在第pos个标签页上
设她某时间鼠标位置为i，她可以有两种操作：
1.关闭[1,i-1]或[i+1,n]中所有开着的标签
2.将鼠标移到第i-1或第i+1个标签上 （前提：移到的那个标签必须是开着的）
求她把除[l,r]外其他标签都关闭的最少操作数。
（n (leq) 100）
想法####
分情况考虑+贪心
代码####
#include<cstdio>
#include<iostream>
#include<algorithm>
using namespace std;
int main()
{
int n,pos,l,r,s;
scanf("%d%d%d%d",&n,&pos,&l,&r);
if(l==1 && r==n) printf("0
");
else if(l==1) printf("%d
",abs(r-pos)+1);
else if(r==n) printf("%d
",abs(l-pos)+1);
else {
s=min(abs(l-pos),abs(r-pos));
s+=r-l+2;
printf("%d
",s);
}
return 0;
}
C. Permute Digits###
给定a与b，求 将组成a的数字重新排列，组成的不大于b的最大整数
注意，输出的整数与a的位数要一致，前导0要输出
（a,b (leq) (10^{18}) ）
想法####
若b的位数比a大，那么直接贪心，将组成a的数字从大到小输出
否则，先把在b前补0使它与a的位数一致，接着从高位往低位考虑贪心，dfs回溯判断是否可行，若贪心到某一位发现 a的这一位<b的这一位，后面的位直接贪心
代码####
#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
int a[10];
char b[20],s[20];
int m,ans[20];
void Max(int cur){
for(int i=9;i>=0;i--)
for(int j=0;j<a[i];j++)
ans[cur++]=i;
}
bool dfs(int cur){
if(cur==m) return true;
int i;
if(a[i=b[cur]-'0']){
ans[cur]=i;
a[i]--;
if(dfs(cur+1)) return true;
a[i]++;
}
for(i=i-1;i>=0;i--)
if(a[i]){
ans[cur]=i;
a[i]--;
Max(cur+1);
return true;
}
return false;
}
int main()
{
int i,n;
scanf("%s",s);
n=strlen(s);
for(i=0;i<n;i++) a[s[i]-'0']++;
scanf("%s",b);
m=strlen(b);
if(m>n) Max(0);
else{
for(i=m-1;i>=0;i--) b[i+n-m]=b[i];
for(i=0;i<n-m;i++) b[i]='0';
m=n;
dfs(0);
}
for(i=0;i<n;i++) printf("%d",ans[i]);
printf("
");
return 0;
}
D. Almost Acyclic Graph###
给定一个n个点m条边的有向图
问是否可以去掉一条边是图中不再有环
（ 2 (leq) n (leq) 500 , 1 (leq) m (leq) min(n(n-1),100000) ）
想法####
tarjan找scc，过程中记录某一个环
若scc数目n，则yes
否则，对于记录下来的那个环，试着把每条边删一遍，跑tarjan
若删掉某条边后的scc数目n，则yes
否则no （因为若删一条边满足条件的话，这条边一定在每个环中都出现）
代码####
#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int N = 505;
int dfn[N],map[N][N],low[N],vis[N],fa[N];
int scc,n,cnt;
int s[N],t;
int cir[N],tot;
void dfs(int u){
dfn[u]=low[u]=++cnt;
s[t++]=u; vis[u]=1;
for(int v=1;v<=n;v++)
if(map[u][v]){
if(!dfn[v]){
fa[v]=u;
dfs(v);
low[u]=min(low[u],low[v]);
}
else if(vis[v]){
low[u]=min(low[u],dfn[v]);
if(!tot){
for(int i=u;i!=v;i=fa[i]) cir[tot++]=i;
cir[tot++]=v;
}
}
}
if(dfn[u]==low[u]){
scc++;
while(s[t-1]!=u) vis[s[--t]]=0;
vis[s[--t]]=0;
}
}
void tarjan() { for(int i=1;i<=n;i++) if(!dfn[i]) dfs(i); }
int main()
{
int i,m,x,y,flag;
scanf("%d%d",&n,&m);
for(i=0;i<m;i++)
scanf("%d%d",&x,&y),map[x][y]=1;
tarjan();
if(scc==n) puts("YES");
else{
flag=0;
y=cir[tot-1];
for(i=0;i<tot;i++){
x=cir[i];
memset(dfn,0,sizeof(dfn));
map[x][y]=0;
cnt=scc=0; tarjan();
if(scc==n) { flag=1; break; }
map[x][y]=1;
y=cir[i];
}
if(flag) puts("YES");
else puts("NO");
}
return 0;
}
E. Physical Education Lessons###
距学期结束还有n天，Alex需要在这n天上课
但由于他的学校上课时间常变动（共q次），所以他想知道每次变动后他需要上多少天课
有两种变动：
1.[l,r]都不上课
2.[l,r]都要上课
假设一开始他要上n天课
（ 1 (leq) n (leq) (10^9) , 1 (leq) q (leq) 300000 ）
想法####
标准的线段树啊
由于n最大1e9所以需要动态开节点
代码####
#include<cstdio>
#include<iostream>
#include<algorithm>
using namespace std;
const int N = 300005;
int n;
struct node{
node *ch[2];
int sum,lazy;
}pool[N*50],*root;
int cnt;
void pushdown(node *p,int l,int r){
int mid=(l+r)>>1;
if(!p->ch[0]){
p->ch[0]=&pool[++cnt];
p->ch[0]->sum=(mid-l+1);
p->ch[0]->lazy=-1;
}
if(!p->ch[1]){
p->ch[1]=&pool[++cnt];
p->ch[1]->sum=(r-mid);
p->ch[1]->lazy=-1;
}
if(p->lazy!=-1){
p->ch[0]->sum=(mid-l+1)*p->lazy;
p->ch[1]->sum=(r-mid)*p->lazy;
p->ch[0]->lazy=p->ch[1]->lazy=p->lazy;
p->lazy=-1;
}
}
void update(node *p) { p->sum=p->ch[0]->sum+p->ch[1]->sum; }
void change(node *p,int l,int r,int L,int R,int k){
if(p->sum==(r-l+1)*k) return;
if(l==L && r==R){
p->sum=k*(r-l+1);
p->lazy=k;
return;
}
pushdown(p,l,r);
int mid=(l+r)>>1;
if(mid>=R) change(p->ch[0],l,mid,L,R,k);
else if(mid<L) change(p->ch[1],mid+1,r,L,R,k);
else{
change(p->ch[0],l,mid,L,mid,k);
change(p->ch[1],mid+1,r,mid+1,R,k);
}
update(p);
}
int main()
{
int q,i,k,l,r;
scanf("%d%d",&n,&q);
root=&pool[++cnt]; root->lazy=-1;
root->sum=n;
for(i=0;i<q;i++){
scanf("%d%d%d",&l,&r,&k);
change(root,1,n,l,r,k-1);
printf("%d
",root->sum);
}
return 0;
}
F. Imbalance Value of a Tree###
给定一棵n个节点的树，每个点都有权值ai
函数I(x,y)的值为从x到y的唯一路径上点权最大－点权最小 （包括路径上的点x,y）
求所有点对的I(x,y)之和
（n (leq) (10^6)）
想法####
若是暴力枚举每对点的话，就算求I为O(1)也会超时
于是考虑函数I，实际上是求每对点间路径上的点权最小值之和 及 最大值之和
先考虑最小值
对于点权最小的那个点，显然所有经过它的路径上点权最小的都是它
对于点权次小的点，所有经过它且不经过点权最小点的路径上，点权最小的都为它
……
对于点权次大的点，它被计算当且仅当有一条边连接它与点权最大的点
对于点权最大的点，它不会被计算
由于是树，两两点间路径是唯一的
于是就有这样一种做法：将每条边按照所连两点权值较小值 从大到小排序
借助并查集，按排好的顺序合并边所连的两点，共n-1次
每次合并，两个集合中各任取一点，它们之间的路径上点权最小值为 这条边所连两点权值较小值
最大值同理，只不过是按边所连两点权值较大值 从小到大排序
代码####
#include<cstdio>
#include<iostream>
#include<algorithm>
using namespace std;
const int N = 1000005;
typedef long long ll;
struct edge{
int u,v;
}e[N];
int val[N],fa[N],size[N];
bool cmp1(edge x,edge y) { return min(val[x.u],val[x.v])>min(val[y.u],val[y.v]); }
bool cmp2(edge x,edge y) { return max(val[x.u],val[x.v])<max(val[y.u],val[y.v]); }
int Getfa(int x) { return fa[x]==x ? x : fa[x]=Getfa(fa[x]); }
int n;
int main()
{
int i,x,y,v;
ll ans=0;
scanf("%d",&n);
for(i=1;i<=n;i++) scanf("%d",&val[i]);
for(i=1;i<n;i++) scanf("%d%d",&e[i].u,&e[i].v);
for(i=1;i<=n;i++) fa[i]=i,size[i]=1;
sort(e+1,e+n,cmp1);
for(i=1;i<n;i++){
v=min(val[e[i].u],val[e[i].v]);
x=Getfa(e[i].u); y=Getfa(e[i].v);
if(size[x]<size[y]) swap(x,y);
ans-=(ll)v*size[x]*size[y];
fa[y]=x;
size[x]+=size[y];
}
for(i=1;i<=n;i++) fa[i]=i,size[i]=1;
sort(e+1,e+n,cmp2);
for(i=1;i<n;i++){
v=max(val[e[i].u],val[e[i].v]);
x=Getfa(e[i].u); y=Getfa(e[i].v);
if(size[x]<size[y]) swap(x,y);
ans+=(ll)v*size[x]*size[y];
fa[y]=x;
size[x]+=size[y];
}
printf("%lld
",ans);
return 0;
}
G. Coprime Arrays###
人们管满足 gcd((a_1),(a_2),…,(a_n)) =1的数组a叫Coprime Array
给出n,k
设对于i (in) [1,k] 满足每个元素都(in)[1,i] 的Coprime Array的个数为(b_i)
求(sumlimits_{i=1}^k) ( (b_i) ^ i)
（n,k (leq) 2 ( imes) (10^6)）
想法一####
定义对于一个数组a，lgcd=gcd((a_1),(a_2),…,(a_n))
设 每个元素都(in)[1,i]的 满足lgcd=j 的数组个数为w[i][j]
那么b[i]=(i^n)-(sumlimits_{j=2}^i) w[i][j]
很容易发现，w[i][j]=b[$ frac {i} {j}$ ]
接下来跟“余数求和”有那么一点像
愉快地超时了……
代码####
#include<cstdio>
#include<iostream>
#include<algorithm>
#define P 1000000007
using namespace std;
typedef long long ll;
const int N = 2000005;
int PowerMod(int x,int b){
int ret=1;
while(b){
if(b&1) ret=((ll)ret*x)%P;
x=((ll)x*x)%P;
b>>=1;
}
return ret;
}
int f[N];
int n,k;
int main()
{
int i,l,r,ans;
scanf("%d%d",&n,&k);
f[1]=1;
ans=0;
for(i=2;i<=k;i++){
f[i]=PowerMod(i,n);
for(l=2,r;l<=i;l=r+1){
r=i/(i/l);
if(r>i) r=i;
f[i]=(f[i]-((ll)r-l+1)*(f[i/l]-P))%P;
}
ans=(ans+(f[i]^i))%P;
}
printf("%d
",ans);
return 0;
}
想法二####
想一想可以发现，b数组是递增的
设f[i]=b[i]-b[i-1]
f[i]统计的是至少有一个元素为i的Coprime Array个数
和想法一的思路有一点点像
设 每个元素都(in)[1,i]的 满足lgcd=j 且至少有一个元素为i 的数组个数为w[i][j]
由于确定数组中一定有一个数是i，那么算出的lgcd值只能为i的约数
很容易发现，w[i][j]=f[$frac {i} {j} $ ]
那么f[i]=(i^n) - ((i-1)^n) - (sum){w[i][j] | j (in) [1,i] , i mod j=0 } （无比神奇的sum用法。。。）
代码####
#include<cstdio>
#include<iostream>
#include<algorithm>
#define P 1000000007
using namespace std;
typedef long long ll;
const int N = 2000005;
ll PowerMod(int x,int b){
ll ret=1;
while(b){
if(b&1) ret=(ret*x)%P;
x=((ll)x*x)%P;
b>>=1;
}
return ret;
}
ll f[N],p[N];
int n,k;
int main()
{
int i,j;
ll ans,sum;
scanf("%d%d",&n,&k);
ans=sum=0;
for(i=1;i<=k;i++){
p[i]=PowerMod(i,n);
f[i]=(f[i]+p[i]-p[i-1]+P)%P;
sum=(sum+f[i])%P;
ans=(ans+(sum^i))%P;
for(j=i*2;j<=k;j+=i)
f[j]=(f[j]-f[i]+P)%P;
}
printf("%d
",ans);
return 0;
}
终于……
