2017.11.05离线赛总结

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

game ——3808

思路：暴力dfs，然而只有30分，正解也显然是数学归纳，也可以按照解答树展开，不难发现 ans[i]=ans[i−1]∗2+num[i]∗∑ij=0num[j]∗2j 

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath> 
#include<cstdlib>
#include<algorithm>
#include<vector>
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 Sz(a) sizeof(a)
#define mcl(a,b) memset(a,b,Sz(a))  
#define pb push_back

#define P 1000000007
#define N 200005

int n;
LL A[N];
LL ans;
struct p30{
    void dfs(int x,LL sum,LL l,LL r){
        if(x==n+1){
            (ans+=sum)%=P;
            return;
        }
        dfs(x+1,(sum+A[x]*l%P)%P,A[x],r);
        dfs(x+1,(sum+A[x]*r%P)%P,l,A[x]);
    }
    void solve(){
        dfs(1,0,A[0],A[0]);
        cout<<ans<<endl;
    }
}p30;

struct p100{
    void solve(){
        LL Pow=1,sum=A[0]<<1;
        REP(i,1,n){
            (ans=ans*2%P+A[i]*sum%P)%=P;
            (Pow<<=1)%=P;
            (sum+=Pow*A[i]%P)%=P;
        }
        cout<<ans<<endl; 
    }
}p100;
int main(){
//  freopen("game.in","r",stdin);
//  freopen("game.out","w",stdout);
    cin>>n;
    REP(i,0,n)scanf("%lld",&A[i]);
    if(n<20)p30.solve(); 
    else p100.solve();
    return 0;
}

cable —— 3809

思路：暴力最小生成树40分；蒟蒻原以为正解是贪心，然而现实总是残酷的，此题显然是dp（大佬说的…）。
看完题解后，感觉dp也是最简单的写法了，且因为村庄时两列的，那么重点是关注两列之间的建边的比较，那么也有点感到定义是与n，m有关的—— dp[i][j][2]
dp[i][j][1]=min(dp[i−1][j][1]+min(Dx,Dy),dp[i−1][j][0]+Dx+Dy);
dp[i][j][0]=min(dp[i−1][j][1],dp[i−1][j][0]+Dx)(Dx=A[i]−A[i−1]orB[i]−B[i−1],Dy=dis(i,j)).

不难发现 i ,j 都能滚动，且O(n+m)。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath> 
#include<ctime>
#include<cstdlib>
#include<algorithm>
#include<vector>
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 Sz(a) sizeof(a)
#define mcl(a,b) memset(a,b,Sz(a))
#define pb push_back

#define N 1000005

void Rd(int &x){
    x=0;char c;
    while(c=getchar(),c<48);
    do x=(x<<1)+(x<<3)+(c^48);
    while(c=getchar(),c>47);
}

int n,m,x1,x2;
int A[N],B[N];
LL dx;


struct p40{
    struct node{
        int from,to;
        db cost;
        bool operator<(const node &a)const{
            return cost<a.cost;
        }
    }es[N<<1];
    int fa[N<<1];
    int cnt;
    db calc(int y1,int y2){
        return 1.0*sqrt(dx+1.0*(y2-y1)*(y2-y1));
    }
    void Init(){
        REP(i,2,n)es[++cnt]=(node){i-1,i,(db)(A[i]-A[i-1])};
        REP(i,2,m)es[++cnt]=(node){i+n-1,i+n,(db)(B[i]-B[i-1])};
        REP(i,1,m)REP(j,1,n)es[++cnt]=(node){i+n,j,(db)calc(A[j],B[i])};
    }
    int Find(int x){return fa[x]==x?x:fa[x]=Find(fa[x]);}

    void solve(){
        db ans=0;
        Init();
        sort(es+1,es+1+cnt);
        REP(i,1,n+m)fa[i]=i;
        REP(i,1,cnt){
            int x=es[i].from,y=es[i].to;
            int fx=Find(x),fy=Find(y);
            if(fx!=fy){
                fa[fy]=fx;
                ans+=es[i].cost;
            }
        }
        printf("%.2lf\n",ans);
    }
}p40;


db dp[N][2][2];
struct p100{
    db Calc(int i,int j) {
        return sqrt(dx+1LL*(A[i]-B[j])*(A[i]-B[j]));
    }
    void solve(){
        dp[1][1][1]=Calc(1,1);
        int cur=1;
        REP(i,1,n){
            if(i!=1){
                db Dx=Calc(i,cur),Dy=A[i]-A[i-1];
                int now=cur&1;
                dp[i][now][1]=min(dp[i-1][now][1]+min(Dx,Dy),dp[i-1][now][0]+Dx+Dy);
                dp[i][now][0]=min(dp[i-1][now][1],dp[i-1][now][0]+Dy);
            }
            while((A[i]>=B[cur] || i>=n) && cur<m){
                cur++;
                db Dx=Calc(i,cur),Dy=B[cur]-B[cur-1];
                int now=cur&1;
                dp[i][now][1]=min(dp[i][now^1][1]+min(Dx,Dy),dp[i][now^1][0]+Dx+Dy);
                dp[i][now][0]=min(dp[i][now^1][1],dp[i][now^1][0]+Dy);
            }
        }
        printf("%.2lf\n",dp[n][m&1][1]);
    }
}p100;
struct pAC{
    db dp[2][2][2];
    int cur1,cur2;
    db calc(int i,int j){
        return sqrt(dx+1LL*(A[i]-B[j])*(A[i]-B[j]));
    }
    void work_i(int i,int j){
        db Dx=calc(i,j),Dy=A[i]-A[i-1];
        dp[!cur1][cur2][0]=min(dp[cur1][cur2][1],dp[cur1][cur2][0]+Dy);
        dp[!cur1][cur2][1]=min(dp[cur1][cur2][1]+min(Dx,Dy),dp[cur1][cur2][0]+Dx+Dy);
        cur1^=1;
    }
    void work_j(int i,int j){
        db Dx=calc(i,j),Dy=B[j]-B[j-1];
        dp[cur1][!cur2][0]=min(dp[cur1][cur2][1],dp[cur1][cur2][0]+Dy);
        dp[cur1][!cur2][1]=min(dp[cur1][cur2][1]+min(Dx,Dy),dp[cur1][cur2][0]+Dx+Dy);
        cur2^=1;
    }
    void solve(){
        dp[cur1][cur2][0]=0;
        dp[cur1][cur2][1]=calc(1,1);
        int j=1;
        REP(i,1,n){
            if(i>1)work_i(i,j);
            while(j<m && (A[i]>=B[j] || i==n))work_j(i,++j);
        }
        printf("%.2lf\n",dp[cur1][cur2][1]);
    }
}pAC;
int main(){
//  freopen("cable.in","r",stdin);
//  freopen("cable.out","w",stdout);
//  printf("%d\n",(Sz(A)+Sz(B)+Sz(fa)+Sz(dy1)+Sz(dy1))/1024/1024);
    srand(time(NULL));
    int f=rand()%2;
    cin>>n>>m>>x1>>x2;
    dx=1LL*(x1-x2)*(x1-x2);
    REP(i,1,n)Rd(A[i]),A[i]+=A[i-1];
    REP(i,1,m)Rd(B[i]),B[i]+=B[i-1];
    if(n<=1000 && m<=1000)p40.solve();
    else if(f)p100.solve();
    else pAC.solve();
    return 0;
}

seat ——3810

思路：此题暴力共计40分，然而m=1还是没推出来，十分遗憾…
60分可以状压dp，but这根本不会想到dp去…
定义和转移都是十分easy的…
dp[i][j] 表示 i 个人固定了位置后状态为 j ;
正解的复杂度也比较玄乎（数据略水）——dfs，m<=8，小的离谱，这告诉我们着突破点。
考虑 n<=10 的做法，其实我们只关注已经固定编号的人的位
置是否合法就行了。
那么我们就去 dfs 每个已经固定了编号的人。假设第 i 个人编号为 x ，需要坐到 y ，那么就需要坐在 x−y−1 之间的人都在 i <script type="math/tex" id="MathJax-Element-735">i</script> 之前选择位置，这里就可以组合数来计算。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath> 
#include<cstdlib>
#include<algorithm>
#include<vector>
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 Sz(a) sizeof(a)
#define mcl(a,b) memset(a,b,Sz(a))  
#define mcp(a,b) memcpy(a,b,Sz(b))
#define pb push_back

#define N 35

int n,m,P;
LL ans;
int D[N],A[N];
bool mark[N];
LL C[N][N],fac[N];

struct node{
    int x,pos;
    bool operator<(const node &a)const{
        return x<a.x;
    }
}B[N];

void Init(){
    C[0][0]=1;
    REP(i,1,N-5){
        C[i][0]=1;
        REP(j,1,i)C[i][j]=(C[i-1][j-1]+C[i-1][j])%P;
    }
    fac[0]=1;
    REP(i,1,N-5)fac[i]=fac[i-1]*i%P;
}

struct P30{
    void dfs(int x){
        if(x>n){
            ans++;
            return;
        }
        if(!A[x])REP(i,1,n){
            if(mark[i])continue;
            D[x]=i;
            mark[i]=1;
            dfs(x+1);
            mark[i]=0;
        }
        else {
            REP(i,A[x],n){
                if(mark[i])continue;
                D[x]=i;
                mark[i]=1;
                dfs(x+1);
                mark[i]=0;
                break;
            }
        }
    }
    void solve(){
        REP(i,1,m){
            int x,pos;
            scanf("%d%d",&x,&pos);
            A[x]=pos;
        }
        dfs(1);
        printf("%lld\n",ans%P);
    }
}p30;

struct p0{
    void solve(){
        printf("%lld\n",fac[n]);
    }
}p0;

struct p1{
    void solve(){
        REP(i,1,m){
            int x,pos;
            scanf("%d%d",&x,&pos);
            A[x]=pos;
        }
        int u=0;
        REP(i,1,n)if(A[i])u=i;
        ans=fac[n-1];
        REP(i,1,n){
            if(A[u]+i>n||u-1<i)break;
            ans+=C[u-1][i]*fac[i]%P*fac[n-i-1]%P;
            ans%=P;
        }
        printf("%lld\n",ans%P);
    }
}p1;

struct p60{
    #define M 20
    LL dp[M][1<<M];
    void solve(){
        REP(i,1,m){
            int x,pos;
            scanf("%d%d",&x,&pos);
            A[x]=pos-1;
            mark[x]=1;
        }
        mcl(dp,-1);
        dp[0][0]=1;
        REP(k,1,n){
            REP(i,0,(1<<n)-1){
                if(dp[k-1][i]==-1)continue;
                REP(j,A[k],n-1){
                    if(i&(1<<j))continue;
                    if(dp[k][i|(1<<j)]==-1)dp[k][i|(1<<j)]=0;
                    (dp[k][i|(1<<j)]+=dp[k-1][i])%=P;
                    if(mark[k])break;
                }
            }
        }
        printf("%lld\n",dp[n][(1<<n)-1]==-1?0:dp[n][(1<<n)-1]);
    }
}p60;

struct p100{
    void dfs(int x,int res,LL sum){
        if(x==m+1){
            res+=n-B[m].x;
            ans+=fac[res]*sum%P,ans%=P;
            return;
        }
        res+=B[x].x-B[x-1].x-1;
        int cnt=0;
        bool tmp[N];
        mcp(tmp,mark);
        REP(i,B[x].pos,n){
            if(mark[i])continue;
            if(cnt>res)break;
            mark[i]=1;
            dfs(x+1,res-cnt,sum*C[res][cnt]%P*fac[cnt]%P);
            cnt++;
        }
        mcp(mark,tmp);
    }

    void solve(){
        REP(i,1,m)scanf("%d%d",&B[i].x,&B[i].pos);
        sort(B+1,B+1+m);
        dfs(1,0,1); 
        cout<<ans<<endl;
    }
}p100;

int main(){
//  freopen("seat.in","r",stdin);
//  freopen("seat.out","w",stdout);
    scanf("%d%d%d",&n,&m,&P);
    Init();
    if(m==0)p0.solve();
    else if(m==1)p1.solve();
    else if(n<10)p30.solve();
    else if(n<20)p60.solve();
    else p100.solve();
    return 0;
}

小结：今天的整体难度相比昨天大幅提升（对于蒟蒻来说吧），然而noip是你琢磨不透的，也有可能今年的三道题目难度顺序不再递增，很有可能不按照一般套路出牌了。 所以一定要放好心态，写好note再敲。
其也是导致了今天第1题爆0（最后急了，文件名没开…），第3题的暴力敲的很乱很慢很杂。
这也时刻体现自我的代码功底还是格外的薄弱，对数据范围的敏感度还是不够（如 m<=20 ——刚好状压 ， Ai<=1e9 —— 开LL）。

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 237
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.03离线赛总结
Caristra的博客
11-04 178
excellent ——3802思路：首先显然可以看出是枚举i个a，得到n-i个b，但组合数只有70，而且还有mod，那么当然要通过逆元+费马小定理来快速幂掉。#include<iostream> #include<cstdio> #include<cmath> #include<cstring> #include<cstdlib> #include<algorithm> #include<vect
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.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 6470
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的棋子，向右移动一格，前提
chrome 114.0.5735.90 离线安装
最新发布
04-20
Chrome 114.0.5735.90 是一个特定版本的Chrome浏览器。离线安装是指在没有网络连接的情况下安装软件。通过离线安装，您可以将软件文件下载到本地，并在需要时进行安装，而无需依赖网络连接。 要进行Chrome 114.0.5735.90的离线安装，您可以按照以下步骤进行操作： 1. 首先，您需要找到适用于您的操作系统的Chrome 114.0.5735.90的离线安装程序。您可以通过在浏览器中搜索“Chrome 114.0.5735.90 离线安装程序”来找到官方下载页面。 2. 在下载页面上，选择适用于您操作系统的版本，并点击下载按钮。 3. 下载完成后，找到下载的安装程序文件，并双击运行它。 4. 按照安装程序的指示进行安装。通常情况下，您只需点击“下一步”按钮，并接受许可协议即可完成安装过程。 5. 安装完成后，您就可以打开Chrome浏览器并开始使用了。 请注意，离线安装程序的文件大小可能会比在线安装程序大，因为它包含了完整的安装文件。此外，建议您定期更新Chrome浏览器以获取最新的功能和安全性修复。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值