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
从后向前遍历整个序列，如果前一个数比后一个数大，那么最短的密钥就是从第一个数到前一个数；如果整个序列是递增的，那么最短的密钥就是第一个数。
AC代码：

#include<cstdio>  
#include<iostream>  
using namespace std;  
int main()  
{  
    int N[1010];  
    int num,pos=0;  
    scanf("%d",&num);  
    for(int i=1;i<=num;i++)  
    {  
        scanf("%d",&N[i]);  
    }  
    for(int i=num;i>=2;i--)  
    {  
        if(N[i-1]>N[i])   
        {  
            pos=i-1;  
            break;   
        }  
    }  
    if(pos)  
    {  
        for(int i=1;i<=pos;i++)  
        {  
            printf("%d ",N[i]);  
        }  
        printf("\n");  
    }  
    else  
    {  
        printf("%d\n",N[1]);  
    }  
}  

题目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<=10^6。
对于100%的数据，满足1<=N,M<=10^12。
输出
对于每组测试数据，输出两个互质的正整数A和B(以A分之B表示小Hi能够追到小Z的几率)。
样例输入
3 2
样例输出
4 1
思路很直接，没有什么好说的。
AC代码：

#include<cmath>  
#include<cstdio>  
#include<vector>  
#include<algorithm>  
#include<iostream>  
using namespace std;  
int main()  
{  
    long long int N,M,i;  
    vector<long long int> N1,M1;  
    N1.clear();  
    M1.clear();  
    cin>>N>>M;  
    for(i=1;i<=sqrt(N);i++)  
    {  
        if(!(N%i))  
        {  
            N1.push_back(i);  
            if(i!=(N/i)) N1.push_back(N/i);  
        }  
    }  
    for(i=1;i<=sqrt(M);i++)  
    {  
        if(!(M%i))  
        {  
            M1.push_back(i);  
            if(i!=(M/i)) M1.push_back(M/i);  
        }  
    }  
    sort(N1.begin(),N1.end());  
    sort(M1.begin(),M1.end());  
    long long int m=N1.size()*M1.size();  
    long long int A=m;  
    long long int B=0;  
    long long int len=N1.size();  
    for(i=0;i<len;i++)  
    {  
        long long int d=N1[i];  
        if(binary_search(M1.begin(),M1.end(),d))  
        {  
            B++;  
        }  
    }  
    for(i=2;i<=B;i++)  
    {  
        while(!(B%i)&&!(A%i))   
        {  
            A=A/i;  
            B=B/i;  
        }  
    }  
    cout<<A<<" "<<B<<endl;  
}  

题目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
动态规划，比较简单。从比赛的结果来看通过的人数明显较多。
AC代码：

#include<cstdio>  
#include<climits>    
#include<cstring>    
#include<iostream>    
#define MAXN 1010    
#define MAXM 1010   
using namespace std;    
int dp[MAXN][MAXM];   
//dp[i][j]表示过前i关答对j题时最少要答错多少道题  
int a[MAXN];    
int n,m,s,t;    
    
int main()  
{    
    int Q,k,p;    
    scanf("%d",&Q);    
    while(Q--)  
    {    
        memset(dp,0,MAXM*sizeof(int));    
        memset(a,0,sizeof(a));    
        scanf("%d%d%d%d",&n,&m,&s,&t);    
        for(int i=1;i<=n;i++)  
        {    
            scanf("%d",&a[i]);    
            fill(dp[i],dp[i]+MAXM,INT_MAX);    
        }    
        for(int i=1;i<=n;i++)  
        {    
            k=(a[i]+s-1)/s;  
            //第i个关卡最多需要答对几道题    
            for(int j=0;j<=m;j++)  
            {    
                for(int h=0;h<=k;h++)  
                {    
                    p=a[i]-h*s;    
                    p=(p<=0?0:((p+t-1)/t));  
                    //p表示在答对h道题的情况下需要答错几道题    
                    dp[i][j+h]=min(dp[i][j+h],dp[i-1][j]+p);    
                }    
            }    
        }    
        bool has=false;    
        for(int i=0;i<=m;i++)  
        {    
            if(i+dp[n][i]<=m)  
            {    
                has=true;    
                printf("%d\n",i);   
                break;    
            }    
        }    
        if(!has) printf("No\n");  
    }    
}    

题目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
这种压轴的题，没有什么套路，考智商考思维。
我们设Sij表示左上角是Aij的子矩阵的和。 
那么有两个重要的性质： 
1. Sij + N × M = Si+1,j+1 
2. 当y>=n时，S1,y=S1,y+1；当x>=m时，Sx,1=Sx+1,1
根据性质1，我们只要知道S11的值，那么S11,S22,S33...这条对角线上的子矩阵和哪些是K的倍数可以O(1)求出。只要解一个同余方程S11+xnm=0 mod K。同理知道S12可以得到S23,S34,S45...
根据性质2，我们只要求S11,S12,S13...S1n和S21,S31,S41...Sm1这O(N+M)条对角线上哪些子矩阵是K的倍数就行。
我的代码TLE了，大家可以参考下，有什么改进的地方希望能不吝赐教。解同余方程的扩展欧几里得算法这里就不再讲解了。

#include<cmath>  
#include<cstdio>  
#include<cstring>    
#include<iostream>    
#define MAXN 100010    
#define MAXM 100010   
using namespace std;    
int N,M,K;  
int sum1[MAXN];  
int sum2[MAXM];  
  
//扩展欧几里得算法   
int exgcd(int m,int n,int &x,int &y)  
{  
    int x1,y1,x0,y0;  
    x0=1; y0=0;  
    x1=0; y1=1;  
    x=0; y=1;  
    int r=m%n;  
    int q=(m-r)/n;  
    while(r)  
    {  
        x=x0-q*x1; y=y0-q*y1;  
        x0=x1; y0=y1;  
        x1=x; y1=y;  
        m=n; n=r; r=m%n;  
        q=(m-r)/n;  
    }  
    return n;  
}  
  
//ax与b关于n同余,解x   
int modular_linear_equation(int a,int b,int n)  
{  
    int x,y,x0;  
    int d=exgcd(a,n,x,y);  
    if(b%d) return -1;  
    x0=x*(b/d)%n;    
    for(int i=0;i<d;i++)   
    {  
        int res=(x0+i*(n/d))%n;  
        if(res>=0) return res;  
    }  
}  
  
//求第i行前M个元素的和   
int row(int i)  
{  
    int res=0;  
    if(i>=M)  
    {  
        int j=M;  
        while(j)  
        {  
            res+=j;  
            j--;  
        }  
    }  
    else  
    {  
        int j=1;  
        while(j<=i)  
        {  
            res+=j;  
            j++;  
        }  
        res+=i*(M-i);  
    }  
    return res;   
}  
  
//求第i列前N个元素的和   
int col(int i)  
{  
    int res=0;  
    if(i>=N)  
    {  
        int j=N;  
        while(j)  
        {  
            res+=j;  
            j--;  
        }  
    }  
    else  
    {  
        int j=1;  
        while(j<=i)  
        {  
            res+=j;  
            j++;  
        }  
        res+=i*(N-i);  
    }  
    return res;   
}  
  
int main()  
{  
    int Q;  
    cin>>Q;  
    while(Q--)  
    {  
        memset(sum1,0,sizeof(sum1));  
        memset(sum2,0,sizeof(sum2));  
        cin>>N>>M>>K;  
        int tempn=N;  
        int tempm=M;   
        int minx=999999;  
        int miny=999999;  
        int i=1;  
        while(tempn&&tempm)  
        {  
            sum1[1]+=i*(tempm+tempn-1);  
            i++;  
            tempn--;  
            tempm--;   
        }  
        sum2[1]=sum1[1];  
        for(i=2;i<=N;i++)  
        {  
            sum1[i]=sum1[i-1]+col(i+M-1)-col(i-1);  
        }  
        for(i=2;i<=M;i++)  
        {  
            sum2[i]=sum2[i-1]+row(i+N-1)-row(i-1);  
        }  
        for(i=1;i<=N;i++)  
        {  
            int res=modular_linear_equation(N*M,abs(sum1[i]-K),K);  
            if(res>0)  
            {  
                if(1+res+i+res<minx+miny)  
                {  
                    minx=1+res;  
                    miny=i+res;  
                }  
                else if(1+res+i+res==minx+miny)  
                {  
                    if(1+res<minx)  
                    {  
                        minx=1+res;  
                        miny=i+res;  
                    }  
                }  
            }  
        }  
        for(i=1;i<=M;i++)  
        {  
            int res=modular_linear_equation(N*M,abs(sum2[i]-K),K);  
            if(res>0)  
            {  
                if(i+res+1+res<minx+miny)  
                {  
                    minx=i+res;  
                    miny=1+res;  
                }  
                else if(i+res+1+res==minx+miny)  
                {  
                    if(i+res<minx)  
                    {  
                        minx=i+res;  
                        miny=1+res;  
                    }  
                }  
            }  
        }  
        if(minx==999999) cout<<"-1"<<endl;  
        else cout<<minx<<" "<<miny<<endl;  
    }  
}