2017.11.03离线赛总结

最新推荐文章于 2023-01-02 21:27:42 发布
最新推荐文章于 2023-01-02 21:27:42 发布
阅读量178 收藏
点赞数
分类专栏： 离线赛-总结
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Caristra/article/details/78444065
版权

excellent ——3802

思路：首先显然可以看出是枚举i个a，得到n-i个b，但组合数只有70，而且还有mod，那么当然要通过逆元+费马小定理来快速幂掉。

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<vector>
#include<queue>
using namespace std;

#define REP(i,f,t) for(int i=(f),i##_end_=(t);i<=i##_end_;i++)
#define DREP(i,f,t) for(int i=(f),i##_end_=(t);i>=i##_end_;i--)
#define LL long long 
#define db double
#define INF 0x3f3f3f3f
#define inf 0x7fffffff
#define mcl(a,b) memset(a,b,sizeof(a))
#define Sz(a) sizeof(a)
#define pb push_back

#define N 1000005
#define P 1000000007

int a,b,n;

bool check(int x){
    while(x>0){
        int y=x%10;
        if(y!=a && y!=b)return 0;
        x/=10;
    }
    return 1;
}
struct p40{
    int ans;
    void dfs(int x,int sum){
        if(x==n){
            if(check(sum)){
                ans++;
                if(ans>=P)ans-=P;
            }
            return;
        }
        dfs(x+1,sum+a);
        dfs(x+1,sum+b);
    }
    void solve(){
        dfs(0,0);
        cout<<ans<<endl;
    }
}p40;

struct p70{
    int ans;
    int C[1505][1505];
    void Init(){
        C[0][0]=1;
        REP(i,1,1500){
            C[i][0]=1;
            REP(j,1,i)(C[i][j]=C[i-1][j-1]+C[i-1][j])%=P;
        }
    }   
    void solve(){
        Init();
        REP(i,0,n){
            int x=a*i+b*(n-i);
            if(check(x)){
                ans+=C[n][i];
                if(ans>=P)ans-=P;
            }
        }
        cout<<ans<<endl;
    }
}p70;
struct p100{
    LL Pow(LL x,LL y){
        LL res=1;
        while(y>0){
            if(y&1)(res*=x)%=P;
            x=x*x%P;y>>=1;
        }
        return res;
    }
    LL fac[N];
    void solve(){
        fac[0]=1;
        REP(i,1,n)fac[i]=fac[i-1]*i%P;
        LL ans=0;
        REP(i,0,n){
            int x=a*i+b*(n-i);
            if(!check(x))continue;
            ans+=fac[n]*Pow(fac[n-i],P-2)%P*Pow(fac[i],P-2)%P,ans%=P;
        }
        cout<<ans<<endl;
    }
}p100;
int main(){
//  freopen("excellent.in","r",stdin);
//  freopen("excellent.out","w",stdout);
    cin>>a>>b>>n;
    if(n<=15)p40.solve();
    else if(n<=1000)p70.solve();
    else p100.solve();
    return 0;
}

num ——3803

思路：赤裸裸的dp，也比较好定义的—— dp[i][j] 表示上一个截点的位置为 j ，当前的数字串为j+1到 i 。但这样还不够（只有70），还需要后缀数组优化一下（kmp）。

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<vector>
#include<queue>
using namespace std;

#define REP(i,f,t) for(int i=(f),i##_end_=(t);i<=i##_end_;i++)
#define DREP(i,f,t) for(int i=(f),i##_end_=(t);i>=i##_end_;i--)
#define LL long long 
#define db double
#define INF 0x3f3f3f3f
#define inf 0x7fffffff
#define mcl(a,b) memset(a,b,sizeof(a))
#define Sz(a) sizeof(a)
#define pb push_back

#define N 3004
#define P 1000000007

int n;
char s[N];
int dp[N][N];
struct P80{
    bool Cmp(int x,int y,int len){
        while(len && s[x]==s[y])x++,y++,len--;
        if(len)return s[x]<s[y];
        return 0;
    }
    void solve(){
        int tmp;
        if(s[1]!='0')REP(i,1,n)dp[1][i]=1;
        REP(i,1,n)REP(j,i,n-1)if((tmp=dp[i][j]) && s[j+1]!='0'){
            int len=j-i+1;
            if(j+len<=n && Cmp(i,j+1,len))(dp[j+1][j+len]+=tmp)%=P;
            REP(k,j+len+1,n)(dp[j+1][k]+=tmp)%=P;
        }
        int ans=0;
        REP(i,1,n)(ans+=dp[i][n])%=P;
        cout<<ans<<endl;
    }
}p80;
struct p100{
    int mark[N][N];
    void Init(){
        DREP(i,n,1){
            DREP(j,n,1){
                if(s[i]>s[j])mark[i][j]=i;
                else if(s[i]<s[j])mark[i][j]=0;
                else mark[i][j]=mark[i+1][j+1];
            }
        }
    }
    void solve(){
        Init();
        REP(i,1,n)dp[1][i]=1;
        REP(i,2,n){
            if(s[i]=='0')continue;
            for(int j=i,k=i-1;j<=n && k;j++,k--){
                if(s[k]=='0')continue;
                if(mark[i][k] && mark[i][k]<=j)(dp[i][j]+=dp[k][i-1])%=P;
                else (dp[i][j+1]+=dp[k][i-1])%=P;
            }
            REP(j,i+1,n)(dp[i][j]+=dp[i][j-1])%=P;
        }
        LL ans=0;
        REP(i,1,n)(ans+=dp[i][n])%=P;
        cout<<ans<<endl;
    }
}p100;
int main(){
//  freopen("num.in","r",stdin);
//  freopen("num.out","w",stdout);
    cin>>n;
    scanf("%s",s+1);
    if(n<1000)p80.solve();
    else p100.solve();
    return 0;
}

tree ——3804

思路：题意十分清晰，简而言之，就是其它点到两个被选定的点的最大距离。
由链的情况——答案应为max(a−1,n−b,mid(b−a>>1))
引发我们思考，将树抽出一条链，也就是树的直径，那么答案同理，即a左边的所有点到a的最大距离，b右边的所有点到b的最大距离，以及a，b之间的所有点到a，b的最小值的最大值。这里两边的点都比较好处理，而中间的点需要再求出直径上a，b之间的点到其子树的每个点的距离，也就是 max(min(dis[top]−dis[a],dis[b]−dis[top])+dep[x])

然而实现起来就比较困难了。
1.距离要倍增算，而且还要每个点向上跳和向下跳都要算出来。（蒟蒻我还没来得及写…）
2.也可以线段树来维护。

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<vector>
#include<queue>
using namespace std;

#define REP(i,f,t) for(int i=(f),i##_end_=(t);i<=i##_end_;i++)
#define DREP(i,f,t) for(int i=(f),i##_end_=(t);i>=i##_end_;i--)
#define LL long long 
#define db double
#define INF 0x3f3f3f3f
#define inf 0x7fffffff
#define mcl(a,b) memset(a,b,sizeof(a))
#define Sz(a) sizeof(a)
#define pb push_back
#define lson L,mid,p<<1
#define rson mid+1,R,p<<1|1
#define family tree[p],tree[p<<1],tree[p<<1|1]
#define root 1,n,1 

#define N 100000

int n,m;
int A[N],B[N];
int D[N],son[N],fa[N],top[N],sz[N];
vector<int>E[N];

void dfs1(int x,int f){
    sz[x]=1;
    D[x]=D[f]+1;
    fa[x]=f;
    son[x]=0;
    REP(i,0,E[x].size()-1){
        int y=E[x][i];
        if(y==f)continue;
        dfs1(y,x);
        sz[x]+=sz[y];
        if(sz[y]>sz[son[x]])son[x]=y;
    }
}
void dfs2(int x,int tp){
    top[x]=tp;
    if(son[x])dfs2(son[x],tp);
    REP(i,0,E[x].size()-1){
        int y=E[x][i];
        if(y==fa[x] || y==son[x])continue;
        dfs2(y,y);  
    }
}
int Lca(int a,int b){
    while(top[a]!=top[b]){
        if(D[top[a]]<D[top[b]])swap(a,b);
        a=fa[top[a]];
    }
    return D[a]<D[b]?a:b;
}

struct plist{
    int Index,ID[100012];
    bool check(){
        REP(i,1,n)if(E[i].size()>2)return 0;
        return 1;   
    }
    void dfs(int x,int f){
        ID[x]=++Index;
        REP(i,0,E[x].size()-1){
            int V=E[x][i];
            if(V==f) continue;
            dfs(V,x);
        }
    }
    void solve(){
        int s=0;
        for(int i=1;i<=n;i++)if(E[i].size()==1){s=i;break;}
        Index=0;
        dfs(s,s);
        REP(i,1,m){
            int a,b;
            int ans=0;
            a=ID[A[i]],b=ID[B[i]];
            if(a>b) swap(a,b);
            ans=max(a-1,n-b);
            ans=max(ans,(b-a)>>1);
            printf("%d\n",ans);
        }
    }
}p_list;
struct p30{
    void solve(){
        dfs1(1,0);
        dfs2(1,1);
        REP(i,1,m){
            int a=A[i],b=B[i];
            int ans=0;
            REP(j,1,n){
                int lca1=Lca(a,j),lca2=Lca(b,j);
                int s1=D[a]+D[j]-D[lca1]*2;
                int s2=D[b]+D[j]-D[lca2]*2;
                ans=max(ans,min(s1,s2));
            }
            printf("%d\n",ans);
        }
    }
}p30;

int Mxval[N];
struct p100{
    int d,Dx,Rx,s;
    int Id[N],dis[N],is_D[N],Link[N];
    struct Tree{
        struct node{
            int L,R,mx;
        }tree[N<<2];
        void build(int L,int R,int p,int x){
            tree[p].L=L,tree[p].R=R;
            if(L==R){
                tree[p].mx=Mxval[L]+L*x;
                return;
            } 
            int mid=(L+R)>>1;
            build(lson,x),build(rson,x);
            tree[p].mx=max(tree[p<<1].mx,tree[p<<1|1].mx); 
        } 
        int query(int L,int R,int p){
            if(tree[p].L==L && tree[p].R==R)return tree[p].mx;
            int mid=(tree[p].L+tree[p].R)>>1;
            if(R<=mid)return query(L,R,p<<1);
            else if(L>mid)return query(L,R,p<<1|1);
            else return max(query(lson),query(rson)); 
        }
    }Tree[2];
    void dfs(int x,int f,int cost){
        if(cost>d)d=cost,Dx=x;
        fa[x]=f;
        REP(i,0,E[x].size()-1){
            int y=E[x][i];
            if(y==f)continue;
            dfs(y,x,cost+1);
        }
    }
    int k;
    void Dfs(int x,int f,int cost){
        Id[x]=k;
        dis[x]=cost;
        if(cost>Mxval[k])Mxval[k]=cost;
        REP(i,0,E[x].size()-1){
            int y=E[x][i];
            if(y==f || is_D[y])continue;
            Dfs(y,x,cost+1);
        } 
    }
    void Setid(){
        int a=Dx;
        while(a!=Rx){
            is_D[a]=1;
            Link[++s]=a;
            a=fa[a];
        }
        Link[++s]=a;
        is_D[a]=1;
        REP(i,1,s){
            k=i;
            Dfs(Link[i],0,0);
        }
    }
    void solve(){
        d=-1;
        dfs(1,0,0);
        Rx=Dx,d=-1;
        dfs(Rx,0,0);
        Setid(); 
        Tree[0].build(1,s,1,1);
        Tree[1].build(1,s,1,-1); 


        REP(i,1,m){
            int a=A[i],b=B[i];
            if(Id[b]<Id[a])swap(a,b);
            int x=(Id[a]+Id[b]+dis[b]-dis[a])/2;
            int ans=0;
            if(Id[a]==Id[b]){
                ans=min(dis[a],dis[b])+Id[a]-1;
                ans=max(s+min(dis[a],dis[b])-Id[a],ans);
                printf("%d\n",ans);
                continue;
            }else {
                int tmp1=min(dis[a]+Id[a]-1,dis[b]+Id[b]-1);
                int tmp2=min(dis[a]+s-Id[a],dis[b]+s-Id[b]);
                ans=max(tmp1,tmp2);
            }
            if(Id[a]<min(Id[b],x))ans=max(ans,Tree[0].query(Id[a]+1,min(Id[b],x),1)-Id[a]+dis[a]);
            if(max(Id[a],x+1)<Id[b])ans=max(ans,Tree[1].query(max(Id[a],x+1),Id[b]-1,1)+Id[b]+dis[b]);
            printf("%d\n",ans);
        } 
    }
}p100;
int main(){
//  freopen("tree.in","r",stdin);
//  freopen("tree.out","w",stdout);
    cin>>n;
    REP(i,1,n-1){
        int a,b;
        scanf("%d%d",&a,&b);
        E[a].pb(b);E[b].pb(a);
    }
    cin>>m;
    REP(i,1,m)scanf("%d%d",&A[i],&B[i]);
//  if(n<=2000)p30.solve();
//  else if(p_list.check())p_list.solve();
//  else p100.solve();
    p100.solve();
    return 0;
}

小结：今天考得不是很好，第1题逆元没想到，第3题链写错了…（代码功底还要加强呀！）

Caristra
关注
专栏目录
2017.11.08离线赛总结
Caristra的博客
11-08 234
river ——3817思路：这是一道十分骚的题目…首先，我也不知道我的暴力bfs只有20分…然而实际死爆零的——格式错误（输出一行，最后没空格且有换行T_T）。 正解也是挺简单的，预处理每个点两次dfs就够了，第1次dfs染色+找边界， 第2次算步数。code：#include<iostream> #include<cstdio> #include<cstring> #include<cstd
2017.11.09离线赛总结
Caristra的博客
11-09 238
kth ——3820思路：这是一道比较玄学的题目。 首先，此题一定是二分答案，且它的上界应为k，而前缀和直接维护仅只有90。不难发现每个数的方案数应该与它因子有关， 即x∗y=ix*y=i，不妨令x<yx<y，那么可以有x∈[1,sqrt(i)]x∈[1,sqrt(i)],y∈[sqrt(i),i]y∈[sqrt(i),i]。 可以简单地打表出x，y的分布会长成这样： y：i,i−j,i−j
2017.11.07离线赛总结
Caristra的博客
11-07 223
travel ——3814思路：显然的dp，但显然有点贪心的味道。 首先，说一下O(n3)O(n^3)的暴力dp：dp[i][j]dp[i][j] 表示走到第i个路段时，上一个路段的高度为j，转移也十分容易，dp[i][j]=min(dp[i−1][k]+abs(A[i]−k)+abs(k−j),dp[i][j])dp[i][j]=min(dp[i-1][k]+abs(A[i]-k)+abs(k-
2017.11.06离线赛总结
Caristra的博客
11-06 237
dna ——3811思路：经过昨天第1题的教育后，今天第1题都虚的一档一档写了，结果在暴力的时间上花的太多了，导致想成纯hash（其实题没审清楚），正解十分从简，因为只有4种字符，k也很小，4进制枚举就行了（T_T）。seq ——3812思路：神tm数学题，推导公式。 暴力15分，不解释； 当a0a0于a1a1同号时，可推出从s=4s=4开始数列严格单调（题解时这么说的…），所以就暴力求出前几项
2017.11.04离线赛总结
Caristra的博客
11-04 226
foreat ——3805思路：显然的二分答案，不解释。robot ——3806思路：有点不明显的状压dp（但看数据范围还是能猜出来的），状压颜色，然而还要前缀和预处理一下，并且每次找该状态的lowbit转移。#include<iostream> #include<cstdio> #include<cstring> #include<cmath> #include<cstdlib> #include
2017.11.05离线赛总结
Caristra的博客
11-05 236
game ——3808思路：暴力dfs，然而只有30分，正解也显然是数学归纳，也可以按照解答树展开，不难发现ans[i]=ans[i−1]∗2+num[i]∗∑ij=0num[j]∗2jans[i]=ans[i-1]*2 + num[i]*\sum_{j=0}^i num[j]*2^j#include<iostream> #include<cstdio> #include<cstring> #inc
2017.10.11离线赛总结
Caristra的博客
10-15 192
network ——3012思路：这是一道比较奇葩的题（主要是题意描述不清吧），但看懂后，觉得这道题还是有套路可寻的，简而言之，就是一个神经元的c>0就可以传给与它相邻的神经元，那么输入时算它的度即可， 有起初有出度一定是出发点，可以想象神经元传来传去，到一定时刻它们的c都小于0就结束，这就很容易想到bfs。maxlexicographic ——3110思路：此题切分切了好几档，30分暴力，60dp
2017.10.15离线赛总结
Caristra的博客
10-15 208
prime ——3784思路：筛一筛质数，再将质数的倍数判一下，前缀和维护，然而这样就卡过去了…当然，正解无非就是更强大的筛法——线性筛。然而，老司机（小c）还有一种做法：将一个数除以其最大质因子，再判断商的最大质因子是否为本身这样似乎不用线性筛就更快了…那么我就将二者结合一下。#include<bits/stdc++.h> #define REP(i,f,t) for(int i=(f),i##_
2017.10.26离线赛总结
Caristra的博客
10-26 208
magic ——4124思路：强模拟，不解释…message ——4125思路：仔细读完题，实际上是找一个最小的环，那么便bfs，但这样只有60， 因为n<=200 000，也便知道只有O(n log n)的复杂度，而且，此题的关系比较明显——父子关系，脑海一闪而过——并查集，再思考一下，并两个集合，查一数，十分符合。#include<bits/stdc++.h> #define REP(i,f,
HTML5和CSS3 WEB技术开发
张晨光老师的播客
01-02 6471
B站视频参考：https://www.bilibili.com/video/BV1H44y1k7ze/[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Uwbid43Z-1672665963237)(asseits/image-20210831212039584.png)]HTML:超文本标记语言(Hyper Text Markup Language)，标准通用标记语言下的一个应用。 HTML 不是一种编程语言（C、Java、python、R等），而是一种标记语言 (markup
2017山东省ACM省赛总结(校史首金!!)
Jonariguez 吾本优秀
05-09 6914
前言： 这次省赛是在青岛科技大学，5月7号-8号。我们山东建筑大学出了4个正式队参加（随着每届省赛的正式名额的增加，我们学校已经没必要出星花队了，因为我们实验室水平能够参加省赛ACMer光正式队就够了-_-|）。 我们是周六（5月7号）一早6点多和山大的一块拼车，坐汽车出发去青岛。山大可是10个队呢，满满的大神，心里默默地膜拜了一番（其实几乎每年打省赛我们学校都会和山大的拼车，所以我参...
【基于物理的渲染（PBR）白皮书】（四）法线分布函数相关总结
热门推荐
【浅墨的游戏编程Blog】毛星云（浅墨）的专栏
06-16 1万+
本文由@浅墨_毛星云出品，首发于知乎专栏，转载请注明出处 文章链接：https://zhuanlan.zhihu.com/p/69380665 作为基于物理的渲染（PBR）技术中材质高光质感的决定因素，更先进的法线分布函数（Normal Distribution Function，NDF）的问世和发展，是PBR能够在游戏和电影工业日益普及的重要...
四合天地软件测试系统,GZ-2017025软件测试赛题.-全国职业院校技能大赛.doc
weixin_29881131的博客
07-22 3101
GZ-2017025软件测试赛题.-全国职业院校技能大赛.doc2017年全国职业院校技能大赛高职组“软件测试”项目竞赛任务书2017年全国职业院校技能大赛(高职组)“软件测试”赛项执委会制2017年5月目录一、赛程说明3二、竞赛技术平台及资料说明4三、竞赛时间、内容及总成绩4(一)竞赛时间4(二)竞赛内容概述4(三)竞赛总成绩5四、任务说明5(一)任务一：制定测试方案5(二)任务二：设计测试用例...
学会比赛：多模态控制环境中的自主赛车
9793学会比赛：一种用于自主赛车的多模态控制环境James Herman1*Jonathan Francis1，2 * Siddha Ganju3Bingqing Chen1AnirudhKoul4 Abhinav Gupta1Alexey Skabelkin5Ivan Zhukov5Max Kumskoy5Eric Nyberg1美国...
2017.10.7离线赛总结
Caristra的博客
10-07 396
第1题：S数 题意：定义S(x)为x每位上的数字和。eg：S(123)=1+2+3=6;S(22)=2+2=4 如果S(x*x)=S(x)*S(x) 则称x为S数，如x=22，S(x)=4,S(x*x)=S(484)=16;所以22是一个S数。 求[L,R]范围内S数的个数。数据范围： 80%,R<=10^5; 100%,R<=10^9。思路：当时只打了暴力（然而暴力数组炸了），打表找规
2017.10.6离线赛总结
Caristra的博客
10-06 368
2017.10.6离线赛总结
2018.9.11离线赛 by Isrothy
Caristra的博客
09-13 341
T1——jsr(3910) Description: 给你一个初始数字AAA,和目标数字BBB.你需要按照以下操作将AAA变为BBB. 数字xxx的二进制式(可以有前导000)下,将000,111的位置任意排列.再令x+1x+1x+1. 求最少次数的操作将AAA变为BBB.若无解,输出−1−1-1. A,B≤1018A,B≤1018A,B \le 10^{18} Solution: ...
2017.10.3离线赛总结
Caristra的博客
10-04 313
第1题：写书 题意：(…)总而言之，输入n，计算1~n每个数字位数的总和(n<=10^9)虽然是水题，但考试时做的还是太慢了， 现在回忆一下，当时只想着把数切分，再来打个小表。(还虚的要对拍) 然而，这题推公式也是很容易的…第2题：LR棋盘 题意: 有一个长度为1*n的棋盘，有一些棋子在上面，标记为L和R。 每次操作可以把标记为L的棋子，向左移动一格，把标记为R的棋子，向右移动一格，前提
使用strophe.js重新登录接收离线消息
最新发布
07-08
使用 Strophe.js 重新登录并接收离线消息，你可以按照以下步骤进行操作： 1. 首先，确保已经在页面中引入了 Strophe.js 的 JavaScript 文件。 2. 创建一个 Strophe 连接对象，例如： ```javascript var ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值