A - tokitsukaze and Counting
题目描述
给出3个整数L，R，x。tokitsukaze想知道，闭区间[L,R]中，x的倍数出现了几次。
输入描述:
第一行包括一个正整数T(T<=1000)，表示T组数据。
接下来T行，每行包括3个正整数L，R，x。
1≤L≤R≤10^18
1≤x≤10^18输出描述:
输出T行，每一行一个整数，表示答案。
示例1
输入
复制
1
2 5 3输出
复制
1
代码如下：
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<string>
#include<cstring>
#include<queue>
#include<cmath>
#include<set>
#include<map>
using namespace std;
#define ll long long
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
const int INF=0x3f3f3f3f;
const int N=105;
int a[N];
int main(){
int t;
ll L,R,x;
scanf("%d",&t);
while(t--){
scanf("%lld%lld%lld",&L,&R,&x);
ll ans=R/x-(L-1)/x;
printf("%lld\n",ans);
}
}
B - tokitsukaze and RPG - 暴力+剪枝
题目描述
tokitsukaze最近沉迷一款RPG。
这个RPG一天有k分钟，每一天从第1分钟开始。
有n种怪物，第i种怪物每天第一次出现的时间为Xi分钟，第二次出现的时间为2*Xi分钟，第三次出现的时间为3*Xi分钟......同一时刻出现的怪物种类越多，打怪获得的经验也越高。
为了高效练级，tokitsukaze想知道在一天内出现怪物种类最多的时间点会出现多少种怪物，这样的时间点有多少个。
输入描述:
第一行包括2个正整数n，k(1≤n≤10^5，1≤k≤10^6)，表示有n种怪物，一天有k分钟。
接下来一行包括n个正整数X(1≤Xi≤10^6)，含义如题面所示。输出描述:
输出一行，包括两个整数a，b。
a表示怪物种类数，b表示时间点的个数。
示例1
输入
复制
3 6
2 2 3
输出
复制
3 1
说明
在第6分钟时，3种怪物都出现了。示例2
输入
复制
3 5
2 2 3
输出
复制
2 2
说明
在第2分钟和第4分钟时，第一种和第二种怪物出现了。示例3
输入
复制
6 10
1 2 3 4 5 6
输出
复制
4 1
说明
在第6分钟时，出现了第一种、第二种、第三种、第六种怪物。示例4
输入
复制
3 5
6 6 6
输出
复制
0 5
说明
在第1分钟、第2分钟、第3分钟、第4分钟、第5分钟，都没有出现怪物。思路：
用类似埃氏筛素数的方法去求每个数的倍数，但是这样会超时，我们把每个数出现的次数计算出来，然后筛的时候直接加上次数就可以啦，这是一个剪枝的好方法啊，以后遇到超时的时候，就要考虑是不是我们重复计算了重复出现的数！
代码如下：
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<string>
#include<cstring>
#include<queue>
#include<cmath>
#include<set>
#include<map>
using namespace std;
#define ll long long
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
const int INF=0x3f3f3f3f;
const int N=1000005;
int bei[N],a[N],ci[N];
int num[N],vis[N];
int main(){
int n,k,tmp,mm=0;
scanf("%d%d",&n,&k);
for(int i=0;i<n;i++){
scanf("%d",&tmp);
if(vis[tmp]==0){a[mm++]=tmp;vis[tmp]=1;}
ci[tmp]++;
}
for(int i=0;i<mm;i++){
for(int j=a[i];j<=k;j+=a[i])bei[j]+=ci[a[i]];
}
int maxx=-1;
for(int i=1;i<=k;i++){
if(bei[i]>maxx){
maxx=bei[i];
}
num[bei[i]]++;
}
printf("%d %d\n",maxx,num[maxx]);
}
C - tokitsukaze and Number Game - 模拟
题目描述
tokitsukaze又在玩3ds上的小游戏了，现在她遇到了难关。
tokitsukaze得到了一个整数x，并被要求使用x的每一位上的数字重新排列，组成一个能被8整除的数，并且这个数尽可能大。
聪明的你们请帮帮可爱的tokitsukaze，如果无法组成被8整除的数，请输出-1。
保证输入不含前导0，输出也不能含前导0。
输入描述:
第一行包括一个正整数T(T<=1000)，表示T组数据。 接下来T行，每一行包括一个整数x，(0≤x≤10^100)。
输出描述:
请输出用这些数字组成出能被8整除的最大的数，如果无法组成出能被8整除的数，请输出-1。
示例1
输入
复制
2 666 1256
输出
复制
-1 6512
思路：
能被8整除的数字的特点是后三位能被8整除，然后对于只有1,2位的数字我们直接判断，对于3位及以上的数字，我们从0开始一直到992，（注意0看成是000,8看成是008，这样数字1000,1008,等就可以被判断到啦）判断后三位是这些数成立不成立，若是成立的话，我们再把剩余的数字从大到小排列组成一个最大的数字，最后找出组成数字里最大的那一个！
（其中判断最后三位也是有技巧的，具体见代码注释，刚开始写的绕来绕去，后来改了，这样还挺简洁qwq）
代码如下：
#include<iostream>
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<string>
#include<cstring>
#include<queue>
#include<cmath>
#include<set>
#include<map>
using namespace std;
#define ll long long
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
const int INF=0x3f3f3f3f;
const int N=105;
int q=0,a[N],res[1000],num[15];
void solve(int x){
int y=(x%10)*10+x/10;
int aa=max(x,y),bb=min(x,y);
if(aa%8==0)printf("%d\n",aa);
else if(bb%8==0)printf("%d\n",bb);
else printf("-1\n");
return ;
}
int main(){
int t;
char ch;
for(int i=0;i<1000;i++){
if(i%8==0)res[q++]=i;
}
scanf("%d",&t);
getchar();
while(t--){
memset(a,0,sizeof(a));
memset(num,0,sizeof(num));
int k=0;
while((ch=getchar())!='\n'){
a[k++]=ch-'0';
num[ch-'0']++;
}
if(k==1){//判断只有一位的情况
if(a[0]==8||a[0]==0)printf("%d\n",a[0]);
else printf("-1\n");
continue;
}
if(k==2){//判断只有两位的情况
solve(a[0]*10+a[1]);
continue;
}
string str="";
for(int i=0;i<q;i++){//判断三位以上的情况
int tmp=res[i];
int t1=tmp%10;tmp/=10;
int t2=tmp%10;tmp/=10;
int t3=tmp;
num[t1]--;num[t2]--;num[t3]--;
string s1;
s1+=t3+'0';s1+=t2+'0';s1+=t1+'0';
if(num[t1]>=0&&num[t2]>=0&&num[t3]>=0){//如果能满足要求
string s2;
for(int i=9;i>=0;i--){//从9开始(因为9最大)，加上每个数的个数
for(int j=0;j<num[i];j++){
s2+=i+'0';
}
}
s2+=s1;//最后再加上后三位
if(s2>str)str=s2;//选择最大的数
}
num[t1]++;num[t2]++;num[t3]++;
}
if(str=="")cout<<-1<<endl;
else cout<<str<<endl;
}
}
D - tokitsukaze and Inverse Number - 线代的概念or找规律
题目描述
tokitsukaze给你一个长度为n的序列，这个序列是1到n的一种排列。
然后她会进行q次操作。每次操作会给你L R k这三个数，表示区间[L,R]往右移动k次。
移动一次的定义是：一个数的位置是P(L≤P≤R-1)，它往右移动后就会在P+1这个位置上；如果一个数在R这个位置，它会移动到L这个位置。
在每次操作结束后，tokitsukaze想让你算出现在这个序列的逆序数的多少，简单起见，你只需要告诉她现在这个序列的逆序数是奇数还是偶数就行了。
提示：序列的逆序数指的是：a[i]>a[j](i<j)，满足条件的(i,j)的个数。
输入描述:
第一行包括一个正整数n(1≤n≤10^5)。
接下来一行，包括一个长度为n的序列，序列为1到n的一种排列。
第三行包括一个正整数q(1≤q≤10^5)。
接下来q行，每行包括三个正整数L,R,k(1≤L≤R≤n，1≤k≤10^9)。
所有变量的含义题面均有给出。输出描述:
在每次操作后，逆序数如果是奇数，就输出1，如果是偶数，就输出0。
示例1
输入
复制
4
2 3 1 4
3
1 3 2
2 4 1
2 3 1
输出
复制
0
0
1
说明
原序列为：2 3 1 4
第一次操作后，序列变为：3 1 2 4，逆序数为2，所以答案为0。
第二次操作后，序列变为：3 4 1 2，逆序数为4，所以答案为0。
第三次操作后，序列变为：3 1 4 2，逆序数为3，所以答案为1。思路：
结论：1 到 n 的排列，任意交换两个数，逆序数奇偶性发生
因此我们只需要知道，要经过多少次变换就可以啦
代码如下：
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<string>
#include<cstring>
#include<queue>
#include<cmath>
#include<set>
#include<map>
using namespace std;
#define ll long long
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
const int INF=0x3f3f3f3f;
const int N=100005;
ll ans=0;
int a[N],b[N];
void Merge(int s[],int t[],int b,int m,int e){
int i=b,j=m+1,k=0;
while(i<=m&&j<=e){
if(s[i]>s[j]){
ans+=m-i+1;
t[k++]=s[j++];
}
else t[k++]=s[i++];
}
while(i<=m)t[k++]=s[i++];
while(j<=e)t[k++]=s[j++];
for(int q=0;q<k;q++)s[q+b]=t[q];
}
void Msort(int s[],int t[],int b,int e){
if(b<e){
int m=(b+e)>>1;
Msort(s,t,b,m);
Msort(s,t,m+1,e);
Merge(s,t,b,m,e);
}
}
int main(){
int n,q,l,r,k;
scanf("%d",&n);
for(int i=0;i<n;i++){
scanf("%d",&a[i]);
}
Msort(a,b,0,n-1);
scanf("%d",&q);
ans%=2;
while(q--){
scanf("%d%d%d",&l,&r,&k);
k%=(r-l+1);
ans=(ans+((r-l)%2*k)%2)%2;
printf("%lld\n",ans%2);
}
}
扫一扫
275
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
