hihocoder[Offer收割]编程练习赛3及参考

题目1 : hiho密码

时间限制:10000ms

单点时限:1000ms

内存限制:256MB

描述

小Ho根据最近在密码学课上学习到的知识，开发出了一款hiho密码，这款密码的秘钥是这样生成的：对于一种有N个字母的语言，选择一个长度为M的单词；将组成这个单词的所有字母按照顺序不重复的写出（即遇到相同字母时跳过）；然后将字母表剩下的没有使用过的字母按照顺序在其后进行排列。

如对于有5个字母的hiho语，选择单词1, 2, 2, 4, 3（此处数字表示字母在字母表中的顺序），则秘钥为1,2,4,3,5。

但是有一天小Ho在计算出了秘钥之后，却发现他弄丢了一开始选择的单词，于是他找到了你，希望你能够帮他找到能够生成这个秘钥的最短的单词。

输入

每个输入文件包含单组测试数据。

每组测试数据的第一行为一个正整数N，意义如前文所述。

每组测试数据的第二行为N个正整数，用来描述一个秘钥，其中第i个正整数Ai表示秘钥的第i个字符在字母表中的顺序。

对于100%的数据，满足N<=1000，1<=Ai<=N。

对于100%的数据，满足对于任意1<=i, j<=N，若i≠j，则Ai≠Aj。

输出

对于每组测试数据，输出能够生成输入给出的秘钥的最短的单词（空串不认为是单词）。由于字母表没有给出，所以对于每个字母，输出其在字母表中的顺序即可（用空格隔开）。

样例输入

5

1 2 4 3 5

样例输出

1 2 4

#include <iostream>
#include <cstdio>
using namespace std;

int a[2000];
int main()
{
int n;
scanf("%d",&n);
for(int i = 1; i <= n; i++)
scanf("%d", &a[i]);
int p = n-1;
while(p >= 1)
{
if(a[p] < a[p+1]) p--;
else break;
}
if(p == 0)
{
printf("%d\n", a[1]);
}
else
{
for(int i = 1; i <= p; i++)
printf("%d%c", a[i], (i==p)?'\n':' ');
}

}

题目2 : 机会渺茫

时间限制:5000ms

单点时限:1000ms

内存限制:256MB

描述

小Hi最近在追求一名学数学的女生小Z。小Z其实是想拒绝他的，但是找不到好的说辞，于是提出了这样的要求：对于给定的两个正整数N和M，小Hi随机选取一个N的约数N’，小Z随机选取一个M的约数M’，如果N’和M’相等，她就答应小Hi。

小Z让小Hi去编写这个随机程序，到时候她review过没有问题了就可以抽签了。但是小Hi写着写着，却越来越觉得机会渺茫。那么问题来了，小Hi能够追到小Z的几率是多少呢？

输入

每个输入文件仅包含单组测试数据。

每组测试数据的第一行为两个正整数N和M，意义如前文所述。

对于40%的数据，满足1<=N,M<=106

对于100%的数据，满足1<=N,M<=1012

输出

对于每组测试数据，输出两个互质的正整数A和B（以A分之B表示小Hi能够追到小Z的几率）。

样例输入

3 2

样例输出

4 1

#include<cstdio>
#include<iostream>
using namespace std;
typedef long long LL;
LL gcd(LL n,LL m){
if(m==0)return n;
return gcd(m,n%m);
}
LL fnum(LL t){
LL a=0;
for(int i=1;i<=t/i;i++){
if(t%i==0)a++;
else continue;
if(t/i!=i)a++;
}
return a;
}
int main(){
LL n,m;while(scanf("%lld%lld\n",&n,&m)!=EOF){
LL t=gcd(n,m);
LL a=fnum(t),b=fnum(n),c=fnum(m);
b*=c;
c=gcd(a,b);
printf("%lld %lld\n",b/c,a/c);
}
return 0;
}

题目3 : 智力竞赛

时间限制:5000ms

单点时限:1000ms

内存限制:256MB

描述

小Hi、小Ho还有被小Hi强拉来的小Z，准备组队参加一个智力竞赛。竞赛采用过关制，共计N个关卡。在第i个关卡中，小Hi他们需要获得Ai点分数才能够进入下一关。每一关的分数都是独立计算的，即使在一关当中获得超过需要的分数，也不会对后面的关卡产生影响。

小Hi他们可以通过答题获得分数。答对一道题获得S点分数，答错一道题获得T点分数。在所有的N个关卡中，小Hi他们一共有M次答题机会。在每个关卡中，都可以在累计答题次数不超过M的情况下使用任意次的答题机会。

那么现在问题来了，对于给定的N、M、S、T和A，小Hi他们至少需要答对多少道题目才能够完成所有的关卡呢？

输入

每个输入文件包含多组测试数据，在每个输入文件的第一行为一个整数Q，表示测试数据的组数。

每组测试数据的第一行为四个正整数N、M、S和T，意义如前文所述。

第二行为N个正整数，分别表示A1~AN。

对于40%的数据，满足1<=N,M<=100

对于100%的数据，满足1<=N,M<=1000,1<=T< S<=10,1<=Ai<=50

对于100%的数据，满足1<=Q<=100

输出

对于每组测试数据，如果小Hi他们能够顺利完成关卡，则输出一个整数Ans，表示小Hi他们至少需要答对的题目数量，否则输出No。

样例输入

1

2 10 9 1

12 35

样例输出

5

#include <iostream>
#include <string.h>
#include <stdio.h>
#include <map>
#define maxn 1010
#define ll long long
using namespace std;
int dp[maxn][maxn];
int a[maxn];
int main()
{
int ncase;
scanf("%d",&ncase);
while(ncase--){
int n,m,s,t,limit=0;
scanf("%d%d%d%d",&n,&m,&s,&t);
for(int i=1;i<=n;i++){
scanf("%d",&a[i]);
limit+=(a[i]+s-1)/s;
}
if(limit>m){
printf("No\n");
continue;
}
memset(dp,1,sizeof(dp));
dp[0][0]=0;
int num=0;
for(int i=0;i<n;i++){
num+=(a[i]+s-1)/s;
for(int j=0;j<=num;j++){
if(dp[i][j]<=m){
int ed=(a[i+1]+s-1)/s;
for(int k=0;k<=ed;k++){
int left=a[i+1]-k*s,fal=0;
if(left>0)
fal=(left+t-1)/t;
dp[i+1][j+k]=min(dp[i+1][j+k],dp[i][j]+fal+k);
}
}
}
}
int ans=0;
for(int i=0;i<=limit;i++){
if(dp
[i]<=m){
ans=i;
break;
}
}
printf("%d\n",ans);
}
return 0;
}

题目4 : 子矩阵求和

时间限制:20000ms

单点时限:2000ms

内存限制:256MB

描述

给定一个无限矩阵A，如下图所示，其中Aij=min(i,j)。

1 1 1 1 1 1 1 1 1

1 2 2 2 2 2 2 2 2

1 2 3 3 3 3 3 3 3

1 2 3 4 4 4 4 4 4

1 2 3 4 5 5 5 5 5 … y

1 2 3 4 5 6 6 6 6

1 2 3 4 5 6 7 7 7

1 2 3 4 5 6 7 8 8

1 2 3 4 5 6 7 8 9

⋮ ⋱

x

小Hi希望你从中找到一个N*M的子矩阵，使得子矩阵中元素的和是K的整数倍。

如果不存在这样的子矩阵，输出-1；否则输出子矩阵左上角元素的下标x和y。如果存在多个满足条件的子矩阵，输出x+y最小的一个；如果仍有多个，输出其中x最小的一个。

输入

输入的第一行是一个整数Q (1 <= Q <= 100)表示输入数据的组数。

对于每组数据，输入一行三个整数N， M， K。1 <= N, M <= 105, 1 <= K <= 106。

输出

对于每组数据输出一行，-1或者子矩阵左上角元素的下标x和y。

样例输入

2

2 2 10

3 3 31

样例输出

2 3

6 7

#include<algorithm>
#include<cstring>
#include<cstdio>
#include<string>
#include<iostream>
#include<fstream>
#include<map>
#include<vector>
#include <stdlib.h>
#include <time.h>
#include<cmath>
#include<sstream>
using namespace std;
long long a[300005];
long long b[300005];
int num[1000005];
int flag[1000005];
int main()
{

int Q;
cin>>Q;
while(Q--)
{
long long n,m,k;
cin>>n>>m>>k;
int p=max(n,m)+2;
int anp=1e8,anq=1e8;
memset(flag,0,sizeof(flag));
memset(num,-1,sizeof(num));
long long s=n*m%k;
long long h=0;
for(int i=0;i<=k;i++)
{
if(flag[h]==1)
break;
flag[h]=1;
num[h]=i;
h=(h+s)%k;
//       cout<<h<<'g'<<endl;
}
//   for(int i=0;i<=10;i++)
//      cout<<num[i]<<endl;
for(long long i=1;i<=2*p;i++)
{
if(i<=n)
a[i]=((i*(i-1))/2+i*(n-i+1))%k;
else
a[i]=(n*(n+1))/2%k;
//      cout<<i<<' '<<a[i]<<endl;
}

b[0]=0;
for(int i=1;i<=2*p;i++)
{
b[i]=(b[i-1]+a[i])%k;
}
for(int i=1;i<=p;i++)
{
int g=(b[i+m-1]-b[i-1]+k)%k;
//     cout<<i<<' '<<g<<endl;
int o;
if(g==0)
o=0;
else
o=k-g;
if(num[o]==-1)
continue;
int np=num[o]+1;
int nq=num[o]+i;
if(np+nq<anp+anq||((np+nq)==(anp+anq)&&np<anp))
{
anp=np;
anq=nq;
}
}

for(long long i=1;i<=2*p;i++)
{
if(i<=m)
a[i]=((i*(i-1))/2+i*(m-i+1))%k;
else
a[i]=(m*(m+1))/2%k;
//     cout<<i<<' '<<a[i]<<endl;
}
b[0]=0;
for(int i=1;i<=2*p;i++)
{
b[i]=(b[i-1]+a[i])%k;
}

for(int i=1;i<=p;i++)
{
int g=(b[i+n-1]-b[i-1]+k)%k;
int o;
if(g==0)
o=0;
else
o=k-g;
if(num[o]==-1)
continue;
int np=num[o]+i;
int nq=num[o]+1;
if(np+nq<anp+anq||((np+nq)==(anp+anq)&&np<anp))
{
anp=np;
anq=nq;
}
}

if(anp==1e8)
cout<<-1<<endl;
else
cout<<anp<<' '<<anq<<endl;
}
return 0;
}

代码取自排名靠前的优秀选手，简洁值得学习