2018.8.10 提高B组模拟赛

T1 阶乘

Time Limits: 1000 ms Memory Limits: 262144 KB Detailed Limits

Goto ProblemSet

Description

有n个正整数a[i]，设它们乘积为p，你可以给p乘上一个正整数q，使p*q刚好为正整数m的阶乘，求m的最小值。

Input

共两行。

第一行一个正整数n。

第二行n个正整数a[i]。

Output

共一行

一个正整数m。

Sample Input

1

6

Sample Output

3

样例解释：

当p=6，q=1时，p*q=3！

Data Constraint

对于10%的数据，n<=10

对于30%的数据，n<=1000

对于100%的数据，n<=100000，a[i]<=100000

解题思路

可以发现被选出的m的阶乘的每个质因数的个数都一定大于a[i]的乘积，所以可以二分答案，然后判断。

代码

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>

using namespace std;
const int MAXN = 100005;
typedef long long LL;

inline int rd(){
    int x=0,f=1;char ch=getchar();
    while(!isdigit(ch)) {if(ch=='-') f=-1;ch=getchar();}
    while(isdigit(ch))  {x=(x<<1)+(x<<3)+ch-'0';ch=getchar();}
    return x*f;
}

int n,cnt,prime[10000],ans,mx;
LL num[MAXN];
bool vis[MAXN];

inline void solve(int x){
    int t=0;
    while(++t){
        while(x%prime[t]==0){
            num[prime[t]]++;
            x/=prime[t];mx=max(mx,t);
        }
        if(x==1) break;
    }
}

inline bool check(int x){
    for(register int i=1;i<=mx;i++){
        int now=0;
        for(register int j=prime[i];j<=x;j=j*prime[i]) {
            now+=x/j;
            if(now>=num[prime[i]]) break;
        }
        if(now<num[prime[i]]) return false;
    }return true;
}

int main(){
    freopen("factorial.in","r",stdin);
    freopen("factorial.out","w",stdout);
    for(register int i=2;i<=100000;i++){
        if(!vis[i]) {prime[++cnt]=i;vis[i]=1;}
        for(register int j=1;j<=cnt && (LL)prime[j]*i<=100000;j++) {
            vis[i*prime[j]]=1;
            if(i%prime[j]==0) break;
        }
    }
    n=rd();
    for(register int i=1;i<=n;i++){
        int x=rd();
        solve(x);
    }
    int l=1,r=1e9;
    while(l<=r){
        int mid=l+r>>1;
        if(check(mid)){
            ans=mid;
            r=mid-1;
        }else l=mid+1;
    }cout<<ans<<endl;
    return 0;
}

T2 小S爱跑步

Description

   小S是一个爱锻炼的孩子，他在放假期间坚持在A公园练习跑步。
  但不久后，他就开始为在重复的地点练习感到厌烦了，他就打算去B公园跑步。
  但是小S由于没有去过B公园，他不知道B公园是否适合练习跑步，又不知道在B公园怎样跑是最优的。所以小S就去B公园进行了一番勘测。
  小S在进行了一番勘测后，画出了一张地图，地图每一个位置上都辨识了小S到达该位置后不能往哪一个方位移动。其中有5种表示的符号：“U”代表不能向上移动，“D”代表不能向下移动，“L”代表不能向左移动，“R”代表不能向右移动，如果该位置有障碍物，小S到达那里后无法继续训练，就用“S”来代表。整个公园共有n行m列，小S会从第1行第1列出发，到第n行第m列结束他的练习。
  现在小S想要知道，从起点（即第1行第1列）到终点（第n行第m列），途中最少要改变几次方向（即上一次移动的方向和这一次移动的方向不一样）？
  注意：小S如在训练途中离开公园（即地图范围），则算是结束训练。

Input

  第1行两个整数n和m，它们的定义请看【题目描述】。
  第2~n+1行，每行有m个字符，表示小S的移动方向。

Output

  如果小S从第1行第1列出发无论如何都到达不了第n行第m列，输出“No Solution”，否则输出小S途中最少要改变方向的次数。

Sample Input

3 3

ULL

LDU

SUD

Sample Output

1

【样例解释】

小S先向右移动移动了2格，再向下移动2格，就到达了终点，这样只用改变一次方向。

Data Constraint

【数据范围限制】

10%的数据是题目的馈赠。

30%的数据，1≤n,m≤10。

50%的数据，1≤n,m≤50。

70%的数据，1≤n,m≤250。

100%的数据，1≤n,m≤500.

其中50%的数据是先构造出路径，再构造地图的。

100%数据是随机构造的。

解题思路

直接bfs，模仿spfa的形式。

代码

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>

using namespace std;
const int MAXN = 505;

int n,m,ans[MAXN][MAXN][8];
int xx[5]={0,0,0,1,-1},yy[5]={0,-1,1,0,0};
char c[MAXN][MAXN];
bool vis[MAXN][MAXN][8];
queue<int> Q[4];

inline int pre(char ch){
    if(ch=='S') return 0;
    if(ch=='L') return 1;
    if(ch=='R') return 2;
    if(ch=='D') return 3;
    return 4;
}

int main(){
    freopen("run.in","r",stdin);
    freopen("run.out","w",stdout);
    memset(ans,0x3f,sizeof(ans));
    scanf("%d%d",&n,&m);
    for(register int i=1;i<=n;i++) scanf("%s",c[i]+1);
    Q[1].push(1);Q[2].push(1);Q[3].push(5);vis[1][1][5]=1;ans[1][1][5]=-1;
    while(Q[1].size()){
        int x=Q[1].front(),y=Q[2].front(),k=Q[3].front();int w=ans[x][y][k];
        Q[1].pop();Q[2].pop();Q[3].pop();if(c[x][y]=='S') continue;
        for(register int z=1;z<=4;z++){
            if(pre(c[x][y])==z) continue;
            int ii=xx[z]+x;int jj=yy[z]+y;
            if(ii>=1 && ii<=n && jj>=1 && jj<=m)
                if(ans[ii][jj][z]>w+(z!=k)){
                    ans[ii][jj][z]=w+(z!=k);
                    if(!vis[ii][jj][z]){
                        Q[1].push(ii);Q[2].push(jj);Q[3].push(z);
                        vis[ii][jj][z]=1;
                    }
                }
        }
        vis[x][y][k]=0;
    }ans[n][m][1]=min(ans[n][m][1],ans[n][m][0]);
    cout<<min(min(min(ans[n][m][1],ans[n][m][2]),ans[n][m][3]),ans[n][m][4]);
    return 0;
}