2020-05-10 19:56 字节跳动_客户端_iOS开发

关注

“科大讯飞杯”第十七届同济大学程序设计预选赛暨高校网络友谊赛题解

按难度顺序

F. 排列计算

题意：
$有一个长度为n的序列a，m次询问$
$每次询问一个区间和，把每次区间和加起来就是最后结果$
$问最后结果最大是多少$
题解：
$想要结果最大，肯定是最大的数取的次数最多即可$
$所以直接差分，将给出的区间位置计数，看每个位置出现的次数$
$然后排序一下，大的给大数，小的给小数$
AC代码

/*
    Author:zzugzx
    Lang:C++
    Blog:blog.csdn.net/qq_43756519
*/
#include<bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(),(x).end()
#define endl '\n'
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
//const int mod=1e9+7;
const int mod=998244353;
const double eps = 1e-10;
const double pi=acos(-1.0);
const int maxn=1e6+10;
const ll inf=0x3f3f3f3f;
const int dir[4][2]={{0,1},{1,0},{0,-1},{-1,0}};

ll a[maxn];

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);cout.tie(0);
    //freopen("in.txt","r",stdin);
    //freopen("out.txt","w",stdout);
    int n,m;
    cin>>n>>m;
    for(int i=1;i<=m;i++){
        int l,r;
        cin>>l>>r;
        a[l]++,a[r+1]--;
    }
    for(int i=1;i<=n;i++)a[i]+=a[i-1];
    sort(a+1,a+1+n);
    ll ans=0;
    for(ll i=1;i<=n;i++){
        ans+=i*a[i];
    }
    cout<<ans;
    return 0;
}

B. 伤害计算

题意：
$给一个字符串，是一个加法表达式$
$每个部分可能是一个数，也可能是一个ndx$
$ndx表示n个x面的骰子$
$数的贡献是数自身，骰子的贡献是他的期望$
题解：
$这道题其实表面一看算法肯定不难$
$骰子的期望其实就是1-x的和除x$
$化简一下就是（x+1）/2，n个筛子乘个n$
$这道题比较难的是怎么读数$
$看到有dalao用py的split轻松解决，但我只会c++$
$我用的操作就是每次读一个数a表示个数，b表示面数$
$读数就是读到一个数加一位，然后直到读的不是数为止$
$从0到字符串结束，每次读，读完a后观察一下$
$如果下一位是个d，则说明要读b，然后按骰子计算$
$如果当前读到字符串结束或者下一位是个加号$
$这说明这一项就是一个单独的数，直接加上即可$
$然后这道题输出也是一个坑点，如果整数直接输出，否则保留一位，需要判断一下$
AC代码

/*
    Author:zzugzx
    Lang:C++
    Blog:blog.csdn.net/qq_43756519
*/
#include<bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(),(x).end()
#define endl '\n'
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
//const int mod=1e9+7;
const int mod=998244353;
const double eps = 1e-10;
const double pi=acos(-1.0);
const int maxn=1e6+10;
const ll inf=0x3f3f3f3f;
const int dir[4][2]={{0,1},{1,0},{0,-1},{-1,0}};


int main()
{
    //ios::sync_with_stdio(false);
    //cin.tie(0);cout.tie(0);
    //freopen("in.txt","r",stdin);
    //freopen("out.txt","w",stdout);
   string s;
    cin>>s;
    double ans=0;
    int i=0;
    while(i<s.length()){
        double a=0,b=0;
        while(isdigit(s[i])&&i<s.length())a=a*10+s[i]-'0',i++;
        if(i==s.length()){ans+=a;break;}
        if(s[i]!='d'){ans+=a;i++;continue;}
        i++;
        while(isdigit(s[i])&&i<s.length())b=b*10+s[i]-'0',i++;
        i++;
        ans+=a*(b+1)/2;
    }
    ll res=ans;
    if(res==ans)cout<<res;
    else printf("%.1lf",ans);
    return 0;
}

A.张老师和菜哭武的游戏

题意：
$一共n个数，首先张老师和菜哭武分别选数a和b放入集合$
$张老师先手，每次选一个数x$
$这个数必须是集合里任意两个数的和或差$
$取不到数的人输，问张老师是否能赢$
题解：
$根据题意，多次相互求差和和，很明显$
$这是一个gcd操作的分部$
$所以你只要找n个数里有多少个数符合这个数$
$由于初始数是a和b，符合这个数一定是gcd(a,b)的倍数$
$如果有奇数个说明张老师会拿走最后一个，说明赢了$
$否则就是输了$
AC代码

/*
    Author:zzugzx
    Lang:C++
    Blog:blog.csdn.net/qq_43756519
*/
#include<bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(),(x).end()
#define endl '\n'
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
//const int mod=1e9+7;
const int mod=998244353;
const double eps = 1e-10;
const double pi=acos(-1.0);
const int maxn=1e6+10;
const ll inf=0x3f3f3f3f;
const int dir[4][2]={{0,1},{1,0},{0,-1},{-1,0}};

ll a[maxn];

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);cout.tie(0);
    //freopen("in.txt","r",stdin);
    //freopen("out.txt","w",stdout);
    int t;
    cin>>t;
    while(t--){
        int n,a,b;
        cin>>n>>a>>b;
        if((n/__gcd(a,b))&1)cout<<"Yes"<<endl;
        else cout<<"No"<<endl;
    }
    return 0;
}

D.车辆调度

题意：
$有一张w*h的图，一个或多辆车$
$每辆车可以进行如下操作$
$可以向上下左右任意一个方向行驶边界或者撞到另外一辆车或障碍物$
$每个操作一分钟$
$图中存在一个或多个目标点$
$问你是否可能在k分钟的时候，有任一一辆车到任一一个目标点$
题解：
$w,h<=10,k<=5$
$这道题数据非常小，直接用DFS回溯暴力每一时刻的状态$
$由于不是碰到目标点就能停止，所以目标地相当于空地$
$把目标地变成空地，然后用set维护一下目标点$
$接下来就用DFS直接暴力每分钟的操作$
$枚举任何一辆车往四个方向的某一个走到头$
$然后DFS下一分钟，直到有一辆车到目标点或者超出给定时间$
$每次车移动后要更新一下车的新位置和旧位置$
$因为别的车会因为这个车停止$
$如果遇到某一个时刻某辆车到目标点，直接输出yes然后exit(0)$
$否则就输出no$
AC代码

/*
    Author:zzugzx
    Lang:C++
    Blog:blog.csdn.net/qq_43756519
*/
#include<bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(),(x).end()
#define endl '\n'
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
//const int mod=1e9+7;
const int mod=998244353;
const double eps = 1e-10;
const double pi=acos(-1.0);
const int maxn=1e6+10;
const ll inf=0x3f3f3f3f;
const int dir[4][2]={{0,1},{1,0},{0,-1},{-1,0}};

int n,m,k;
char g[20][20];
set<pii> e;
vector<pii> s;
bool ok(int x,int y){
    if(x>=1&&x<=n&&y>=1&&y<=m&&g[x][y]=='.')return 1;
    return 0;
}
void dfs(int cur){
    if(cur==k)return;
    for(auto &i:s)
        for(int p=0;p<4;p++){
            int cx=i.fi,cy=i.se;
            int x=i.fi,y=i.se;
            int dx=x+dir[p][0];
            int dy=y+dir[p][1];
            while(ok(dx,dy))x=dx,y=dy,dx+=dir[p][0],dy+=dir[p][1];
            if(e.count(mp(x,y))){cout<<"YES";exit(0);}
            swap(g[cx][cy],g[x][y]);
            i.fi=x,i.se=y;
            dfs(cur+1);
            i.fi=cx,i.se=cy;
            swap(g[cx][cy],g[x][y]);
        }
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);cout.tie(0);
    //freopen("in.txt","r",stdin);
    //freopen("out.txt","w",stdout);
    cin>>m>>n>>k;
    for(int i=1;i<=n;i++)cin>>g[i]+1;
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++){
            if(g[i][j]=='R')s.pb(mp(i,j));
            if(g[i][j]=='D')e.insert(mp(i,j)),g[i][j]='.';
        }
    dfs(0);
    cout<<"NO"<<endl;
    return 0;
}

E.弦

题意：
$一个圆上有2n个点，找出n条弦不相交的概率$
题解：
$先找2n个点不相交有多少种，作为分子$
$通过打表或者推一下规律可以发现结果应该是f[i]*f[n-i-1]的累加$
$如果学习过卡特兰数的，一看这应该是个卡特兰数的递推式$
$所以不用多说了，这个分子是个卡特兰数$
$分母很好算，每次从2*n个数里选两个$
$然后从2*n-2里再选两个，直到选完为止$
$但是这样会出现重复状态，就需要再除以n!$
$卡特兰数K[i]=C(2n,n)/(n+1)$
$和分母放一起，化简，即可得到2^n/(n+1)!$
$由于数比较大需要取余，记得用一下费马小求逆元就可以了$
AC代码

在这里插入代码片`/*
    Author:zzugzx
    Lang:C++
    Blog:blog.csdn.net/qq_43756519
*/
#include<bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(),(x).end()
#define endl '\n'
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int mod=1e9+7;
//const int mod=998244353;
const double eps = 1e-10;
const double pi=acos(-1.0);
const int maxn=1e6+10;
const ll inf=0x3f3f3f3f;
const int dir[4][2]={{0,1},{1,0},{0,-1},{-1,0}};

ll Pow(ll a, ll b){
    ll ans = 1;
    while(b > 0){
        if(b & 1){
            ans = ans * a % mod;
        }
        a = a * a % mod;
        b >>= 1;
    }
    return ans;
}
//逆元
ll inv(ll b){
    return Pow(b,mod-2);
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);cout.tie(0);
    //freopen("in.txt","r",stdin);
    //freopen("out.txt","w",stdout);
    ll n;
    cin>>n;
    ll a=Pow(2,n),b=1;
    for(ll i=1;i<=n+1;i++)b=b*i%mod;
    ll ans=a*inv(b)%mod;
    cout<<ans;
    return 0;
}
`

C. 张老师的旅行

题意：
$共有n个点，所有点在一条直线上，有一个坐标p_i$
$张老师每次走一公里需要花费一分钟$
$张老师需要在t_i之前到达i点，然后每个点都要走一遍$
$有一个t_i为0的点是张老师的起点$
$问张老师最少需要多长时间完成$
$完成不了输出-1$
题解：
$n<=1e3$
$感觉一开始看这道题比较像二分答案，但是check函数不好写$
$然后观察这个n不是很大，可以开一个二维数组做dp$
$这道题只能符合区间dp$
$由于张老师能跑到两端就能跑完全程，所以说明最后肯定在两端的某一个点$
$然后就可以列出一个dp模型$
$dp[i][j][0/1]在i到j这个区间里，张老师在i(0)或者j(1)花费的最小时间$
$然后这个区间必须要包括起点x，在这个基础上列区间dp即可$
$然后找状态转移方程$
$可能的状态是从最右边走到最左边，或者最左边走到最右边$
$也可能最左边往左移一个点，或者最右边往右移一个点$
$每次移动只要保证移动到的那个点的t_i要大于等于到的时间$
$这样就可以列状态转移方程了$

$dp[l][r][0]=min(dp[l][r][0],dp[l+1][r][0]+a[l+1]-a[l]);$
$dp[l][r][0]=min(dp[l][r][0],dp[l+1][r][1]+a[r]-a[l]);$
$dp[l][r][1]=min(dp[l][r][1],dp[l][r-1][1]+a[r]-a[r-1]);$
$dp[l][r][1]=min(dp[l][r][1],dp[l][r-1][0]+a[r]-a[l]);$

$转移的前提就是上面说的要保证下一个到的点，大于等于到达的时间$
$最后的结果是dp[l][r][0]和dp[l][r][1]取最小值$
$如果两个都为inf，那么说明不存在$
AC代码

/*
    Author:zzugzx
    Lang:C++
    Blog:blog.csdn.net/qq_43756519
*/
#include<bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(),(x).end()
#define endl '\n'
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int mod=1e9+7;
//const int mod=998244353;
const double eps = 1e-10;
const double pi=acos(-1.0);
const int maxn=1e6+10;
const ll inf=0x3f3f3f3f;
const int dir[4][2]={{0,1},{1,0},{0,-1},{-1,0}};

int dp[1010][1010][2],a[1010],t[1010];

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);cout.tie(0);
    //freopen("in.txt","r",stdin);
    //freopen("out.txt","w",stdout);
    int n;
    cin>>n;
    for(int i=1;i<=n;i++)cin>>a[i];
    int pos;
    for(int i=1;i<=n;i++){
        cin>>t[i];
        if(t[i]==0)pos=i;
    }
    memset(dp,inf,sizeof dp);
    dp[pos][pos][0]=dp[pos][pos][1]=0;
    for(int len=1;len<=n;len++)
        for(int l=max(1,pos-len+1),r;l<=pos&&l+len-1<=n;l++){
            r=l+len-1;
            if(dp[l+1][r][0]+a[l+1]-a[l]<=t[l])
                dp[l][r][0]=min(dp[l][r][0],dp[l+1][r][0]+a[l+1]-a[l]);
            if(dp[l+1][r][1]+a[r]-a[l]<=t[l])
                dp[l][r][0]=min(dp[l][r][0],dp[l+1][r][1]+a[r]-a[l]);
            if(dp[l][r-1][1]+a[r]-a[r-1]<=t[r])
                dp[l][r][1]=min(dp[l][r][1],dp[l][r-1][1]+a[r]-a[r-1]);
            if(dp[l][r-1][0]+a[r]-a[l]<=t[r])
                dp[l][r][1]=min(dp[l][r][1],dp[l][r-1][0]+a[r]-a[l]);
        }
    int ans=min(dp[1][n][0],dp[1][n][1]);
    if(ans==inf)cout<<-1;
    else cout<<ans;
    return 0;
}

J.斐波那契和

题意：
$给定n和k求如下式子$
$\sum_{i=1}^n {i^kFib(i)} \quad$

$Fib(i)表示第i位斐波那契数$
题解：
$n<=1e18$
$Berlekamp-Massey算法$
$这道题很玄学的用了一发BM算法$
$大概意思就是给出前几位，然后用算法能跑出第n位的数$
$所以我就用暴力算出了前1000位数直接跑BM算法$
$代码其实我也不太懂，直接抄的模版$
模版来自:https://www.cnblogs.com/zzqsblog/p/6877339.html $直接套模版的题，直接上代码$
$AC代码$

/*
    Author:zzugzx
    Lang:C++
    Blog:blog.csdn.net/qq_43756519
*/
#include<bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(),(x).end()
#define endl '\n'
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
//const int mod=1e9+7;
const int mod=998244353;
const double eps = 1e-10;
const double pi=acos(-1.0);
const int maxn=1e6+10;
const ll inf=0x3f3f3f3f;
const int dir[4][2]={{0,1},{1,0},{0,-1},{-1,0}};


const int MOD=998244353;
const int SZ=maxn;
ll qp(ll a,ll b)
{
    ll x=1; a%=MOD;
    while(b)
    {
        if(b&1) x=x*a%MOD;
        a=a*a%MOD; b>>=1;
    }
    return x;
}
namespace linear_seq {
inline vector<ll> BM(vector<ll> x)
{
    vector<ll> ls,cur;
    int pn=0,lf,ld;
    for(int i=0;i<int(x.size());++i)
    {
        ll t=-x[i]%MOD;
        for(int j=0;j<int(cur.size());++j)
            t=(t+x[i-j-1]*(ll)cur[j])%MOD;
        if(!t) continue;
        if(!cur.size())
        {cur.resize(i+1); lf=i; ld=t; continue;}
        ll k=-t*qp(ld,MOD-2)%MOD;
        vector<ll> c(i-lf-1); c.pb(-k);
        for(int j=0;j<int(ls.size());++j) c.pb(ls[j]*k%MOD);
        if(c.size()<cur.size()) c.resize(cur.size());
        for(int j=0;j<int(cur.size());++j)
            c[j]=(c[j]+cur[j])%MOD;
        if(i-lf+(int)ls.size()>=(int)cur.size())
            ls=cur,lf=i,ld=t;
        cur=c;
    }
    vector<ll>&o=cur;
    for(int i=0;i<int(o.size());++i)
        o[i]=(o[i]%MOD+MOD)%MOD;
    return o;
}
int N; ll a[SZ],h[SZ],t_[SZ],s[SZ],t[SZ];
inline void mull(ll*p,ll*q)
{
    for(int i=0;i<N+N;++i) t_[i]=0;
    for(int i=0;i<N;++i) if(p[i])
        for(int j=0;j<N;++j)
            t_[i+j]=(t_[i+j]+p[i]*q[j])%MOD;
    for(int i=N+N-1;i>=N;--i) if(t_[i])
        for(int j=N-1;~j;--j)
            t_[i-j-1]=(t_[i-j-1]+t_[i]*h[j])%MOD;
    for(int i=0;i<N;++i) p[i]=t_[i];
}
inline ll calc(ll K)
{
    for(int i=N;~i;--i) s[i]=t[i]=0;
    s[0]=1; if(N!=1) t[1]=1; else t[0]=h[0];
    for(;K;mull(t,t),K>>=1) if(K&1) mull(s,t); ll su=0;
    for(int i=0;i<N;++i) su=(su+s[i]*a[i])%MOD;
    return (su%MOD+MOD)%MOD;
}
inline int gao(vector<ll> x,ll n)
{
    if(n<int(x.size())) return x[n];
    vector<ll> v=BM(x); N=v.size(); if(!N) return 0;
    for(int i=0;i<N;++i) h[i]=v[i],a[i]=x[i];
    return calc(n);
}
}
ll fff[3000]={1,1,1};
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);cout.tie(0);
    //freopen("in.txt","r",stdin);
    //freopen("out.txt","w",stdout);
    ll n,k;
    cin>>n>>k;
    vector<ll> qqq;
    qqq.pb(0);
    for(int i=3;i<2000;i++)
        fff[i]=(fff[i-1]+fff[i-2])%MOD;
    for(int i=1;i<=1000;i++){
        ll sss=0;
        for(int j=1;j<=i;j++)
            sss=(sss+qp(j,k)*fff[j])%MOD;
        qqq.pb(sss);
    }
    cout<<linear_seq::gao(qqq,n);
    return 0;
}