APIO2015

最新推荐文章于 2019-02-25 13:10:18 发布
最新推荐文章于 2019-02-25 13:10:18 发布
阅读量342 收藏 1
点赞数 2
分类专栏： dp 权值线段树 文章标签： dp APIO
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35776579/article/details/55522527
版权

颓了几天了，每次考试都考挂，现在还是来反思反思吧！

这几天总是这样，写着写着就没感觉了，看来还是自己太辣鸡了，甚至连暴力都频频出错，看来是以前写的方法不正确，以后的代码尽量从暴力开始，不要直接就是正解。

还是来讲讲APIO2015的题吧！

自认为APIO2015看着就感觉好写，但是实际上也是这样。每道题都有思路，但是就是捆绑数据有点坑。。。

1.sculpture

    这道题最开始就认为它是dp（其实也是dp），但是最开始的那个n^3的，最容易想到的dp却是错的！！！由于它的性质，所以不能直接取min！！！！！
    但是我还是完美的向这个坑跳下去了。。。。。
    （其实这样如果不WA会有71分，APIO会这么简单吗？）
    所以第一题就爆0了。T_T


    正解：
    贪心+dp
        让答案尽量小，则需要高位尽量为0.
        对于答案，我们考虑从最高位开始一次枚举，我们判断它是否可以为0，如果可以则确定下来，反之，就赋值成1.这样dp也是O(32*n^3)，这样是可以过的。
        但是，有一个问题，对于这样的dp，时间复杂度在第5部分是承受不了的，然而我们又发现，对于第5部分是没有下限，我们可以分类讨论来写两个dp。
        对于第一部分，我们的dp[i][j]代表枚举到第i为，分成j段是否可以满足当前位为0，判断一下是否满足当前的状态即可。
        对于第二部分，我们的g[i]代表到第i为数，使它满足当前位为0，最少需要分多少段。

具体如下：
m[] 是二进制的模板
第一部分：

void solve2(){
    long long ans=0;
    Forr(l,len,0){
        ans+=m[l]-1;
        Set(dp,0);
        dp[0][0]=1;
        For(k,1,B){
            For(i,1,n){
                For(j,0,i-1){
                    dp[i][k]|=(dp[j][k-1] && ((a[i]-a[j])|ans)==ans);
                    if(dp[i][k]) break;
                }
            }
        }
        bool flag=0;
        For(i,A,B){
            if(dp[n][i]) {flag=1;break;}
        }
        if(flag) ans-=m[l]-1;
        else ++ans;
    }
    printf("%lld\n",ans);
}

第二部分：

void solve1(){
    long long ans=0;
    Forr(l,len,0){
        ans+=m[l]-1;
        Set(g,63);
        g[0]=0;
        For(i,1,n){
            For(j,0,i-1){
                if((ans|(a[i]-a[j]))==ans)
                    g[i]=min(g[i],g[j]+1);
            }
        }
        if(g[n]<=B) ans-=m[l]-1;
        else ans++;
    }
    printf("%lld\n",ans);
}

这样第一题就解决了。

#include<iostream>
#include<cstdio>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<vector>
#define For(aa,bb,cc) for(int aa=bb;aa<=cc;++aa)
#define Forr(aa,bb,cc) for(int aa=bb;aa>=cc;--aa)
#define Set(aa,bb) memset(aa,bb,sizeof(aa))
using namespace std;
const int maxn=2010;
int n,A,B,len;
long long a[maxn],m[maxn],g[maxn];
bool dp[maxn][maxn];

void solve1(){
    long long ans=0;
    Forr(l,len,0){
        ans+=m[l]-1;
        Set(g,63);
        g[0]=0;
        For(i,1,n){
            For(j,0,i-1){
                if((ans|(a[i]-a[j]))==ans)
                    g[i]=min(g[i],g[j]+1);
            }
        }
        if(g[n]<=B) ans-=m[l]-1;
        else ans++;
    }
    printf("%lld\n",ans);
}

void solve2(){
    long long ans=0;
    Forr(l,len,0){
        ans+=m[l]-1;
        Set(dp,0);
        dp[0][0]=1;
        For(k,1,B){
            For(i,1,n){
                For(j,0,i-1){
                    dp[i][k]|=(dp[j][k-1] && ((a[i]-a[j])|ans)==ans);
                    if(dp[i][k]) break;
                }
            }
        }
        bool flag=0;
        For(i,A,B){
            if(dp[n][i]) {flag=1;break;}
        }
        if(flag) ans-=m[l]-1;
        else ++ans;
    }
    printf("%lld\n",ans);
}

void work(){
    scanf("%d%d%d",&n,&A,&B);
    For(i,1,n) scanf("%lld",&a[i]),a[i]+=a[i-1];
    long long tmp=1;
    len=1;
    while(tmp<a[n]){
        ++len;
        tmp<<=1;
    }
    m[0]=1;
    For(i,1,len) m[i]=m[i-1]<<1;
    if(A==1) solve1();
    else solve2();
}

int main(){
    work();
    return 0;
}

2.skyscrapers
这一题，看一眼就是个图论题。
而且好像比较好骗分。
36分：
对于每一个doge所可以到达的建筑物连边，然后最短路，MLE。
57分:
以建筑物为点连边，只连接有doge的建筑物，最短路
100分：
做法很多，可以建辅助点等等。
但是我主要讲一种：

    对于这个图，我们考虑以建筑物为点，将它上面的doge的跳跃能力值都记录下来，并且去重（由于相同的再次访问浪费时间）。但是这必须限制在一定的范围内，否则会炸掉。然后最短路。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<vector>
#include<queue>
#define For(aa,bb,cc) for(int aa=bb;aa<=cc;++aa)
#define Forr(aa,bb,cc) for(int aa=bb;aa>=cc;--aa)
#define Set(aa,bb) memset(aa,bb,sizeof(aa))
using namespace std;
const int maxn=30010,inf=0x3f3f3f3f;
int n,m;
vector<int>map[maxn];
struct doge{
    int h,w;
}dog[maxn];
int sum[maxn],dis[maxn];
bool ligature[maxn][210],vis[maxn];

queue<int>q;
int spfa(int s,int t){
    Set(dis,inf);
    q.push(s);
    dis[s]=0;
    while(!q.empty()){
        int u=q.front();
        q.pop();
        vis[u]=0;
        Forr(i,sum[u]-1,0){
            int k=map[u][i];
            for(int node=u,j=1;node-k>=0;++j){
                node-=k;
                if(dis[node]>dis[u]+j){
                    dis[node]=dis[u]+j;
                    if(!vis[node]){
                        vis[node]=1;
                        q.push(node);
                    }
                }
                if(k<=200 && ligature[node][k]) break;
            }
            for(int node=u,j=1;node+k<n;++j){
                node+=k;
                if(dis[node]>dis[u]+j){
                    dis[node]=dis[u]+j;
                    if(!vis[node]){
                        vis[node]=1;
                        q.push(node);
                    }
                }
                if(k<=200 && ligature[node][k]) break;
            }
        }
    }
    return dis[t];
}

void work(){
    scanf("%d%d",&n,&m);
    For(i,0,m-1){
        scanf("%d%d",&dog[i].h,&dog[i].w);
        map[dog[i].h].push_back(dog[i].w);
        if(dog[i].w<=200) ligature[dog[i].h][dog[i].w]=1;
    }
    For(i,0,n-1){
        sort(map[i].begin(),map[i].end());
        sum[i]=unique(map[i].begin(),map[i].end())-map[i].begin();
    }
    int ans=spfa(dog[0].h,dog[1].h);
    printf("%d\n",ans>=inf?-1:ans);
}

int main(){
#ifndef ONLINE_JUDGE
    freopen("skyscraper.in","r",stdin);
    freopen("skyscraper.out","w",stdout);
#endif
    work();
    return 0;
}

3.Bridges
这道题有一个数学性质，那就是最优解一定是在中位数（自己想想）。
并且我们发现，对于A边或B边，我们都可以把它看成同一边，过桥的费用是一样的，最后统一累加。同时，桥一定是在办公室或家的那个坐标上（自己想想）
22分：

    k=1，暴力找中位数，

31分：

    由于满足上述性质，所以枚举桥的位置，k=2可以过小数据。

再多一点点：

    由于是距离中位数的距离和，所以我们可以用中点来进行排序，然后枚举来做。

100分：

    我们发现在中点排序后，插入后面的是不会影响前面的答案，所以我们可以利用数据结构来进行维护中位数。权值线段树便可以发挥作用了。
    权值线段树是可以支持整个区间上的第k大，所以求中位数也是可以的。（最主要比主席树好写多了)

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
#define For(aa,bb,cc) for(int aa=bb;aa<=cc;++aa)
#define Set(aa,bb) memset(aa,bb,sizeof(aa))
#define rank Rank
#define ls node<<1
#define rs node<<1|1
using namespace std;
typedef long long LL;
const int maxn=300010;
LL ans[maxn];
struct asdf{
    LL sum;
    int size;
}tree[maxn<<1];
struct asdfg{
    int x,y;
}a[maxn<<1];
int n,m,tot,size,rank[maxn];

int ask(int node){
    return lower_bound(rank+1,rank+1+size,node)-rank;
}

bool cmp(asdfg c,asdfg b){
    return c.x+c.y<b.x+b.y;
}

void pushup(int node){
    tree[node].sum=tree[ls].sum+tree[rs].sum;
    tree[node].size=tree[ls].size+tree[rs].size;
}

void create_tree(int node,int l,int r){
    if(l==r){
        tree[node].sum=tree[node].size=0;
        return ;
    }
    int mid=(l+r)>>1;
    create_tree(ls,l,mid);
    create_tree(rs,mid+1,r);
    pushup(node);
    return ;
}

void insert(int node,int l,int r,int k){
    if(l==r){
        tree[node].sum+=rank[l];
        ++tree[node].size;
        return ;
    }
    int mid=(l+r)>>1;
    if(k<=mid) insert(ls,l,mid,k);
    else insert(rs,mid+1,r,k);
    pushup(node);
    return ;
}

LL query(int node,int l,int r,int k){
    if(tree[node].size<=k) return tree[node].sum;
    if(l==r) return 1LL*k*rank[l];
    int mid=(l+r)>>1;
    if(tree[ls].size>=k) return query(ls,l,mid,k);
    else return tree[ls].sum+query(rs,mid+1,r,k-tree[ls].size);
}

LL Query(int k){
    return tree[1].sum-2LL*query(1,1,size,k);
}

void work(){
    LL hh=0;
    scanf("%d%d",&m,&n);
    For(i,1,n){
        char s1[2],s2[2];int x,y;
        scanf("%s%d%s%d",s1,&x,s2,&y);
        if(s1[0]==s2[0]){
            hh+=abs(x-y);
            continue;
        }
        ++hh;
        rank[++size]=x,rank[++size]=y;
        a[++tot].x=x,a[tot].y=y;
    }
    sort(rank+1,rank+1+size);
    size=unique(rank+1,rank+1+size)-rank-1;
    if(size){
        create_tree(1,1,size);
        sort(a+1,a+1+tot,cmp);
        For(i,1,tot){
            insert(1,1,size,ask(a[i].x));
            insert(1,1,size,ask(a[i].y));
            ans[i]=Query(i);
        }
    }
    if(m==1) printf("%lld\n",ans[tot]+hh);
    else{
        LL Ans=ans[tot];
        if(size){
            create_tree(1,1,size);
            for(int i=tot;i>1;--i){
                insert(1,1,size,ask(a[i].x));
                insert(1,1,size,ask(a[i].y));
                Ans=min(ans[i-1]+Query(tot-i+1),Ans);
            }
        }
        printf("%lld\n",Ans+hh);
    }
}

int main(){
#ifndef ONLINE_JUDGE
    freopen("bridge.in","r",stdin);
    freopen("bridge.out","w",stdout);
#endif
    work();
    return 0;
}
South-twilight
关注
专栏目录
【APIO2015】雅加达的摩天楼
weixin_43823476的博客
09-07 242
题目 题目描述 雅加达（印尼首都）有座摩天楼排成一列，依次编号为到。 有只神秘生物 doge 住在雅加达，分别编号为到。号 doge 最初居住于号摩天楼。 doge 能够在摩天楼间跳跃，号 doge 的弹跳力为。每次跳跃，位于号摩天楼、弹跳力为的 doge只能跳跃到号（若）或号（若）摩天楼。 号 doge 有一条紧急的消息要尽快传送给号 doge。任何一个收到消息的 doge 可以跳跃到其他摩天楼上，也可以将消息传递给它当前所在的摩天楼上的其他...
APIO2015.zip
05-13
APIO2015 数据 题面自己搜，1.巴厘岛的雕塑 N个数，分成连续的A-B个组，让每个组的和或起来最小，求最小值。 对于Task1 n<=100 　　由于涉及到位运算，所以很容易想到按二进制位来做。要让答案最小，显然要从二进制高位到低位判断，能取0就取0。
APIO2015简要题解
weixin_30648587的博客
02-17 146
　　最近老师把apio的题目拿出来了，然后由于我实在是菜，分数还没三位数...... 　----------------我是分割线 1.巴厘岛的雕塑 N个数，分成连续的A-B个组，让每个组的和或起来最小，求最小值。 对于Task1 n<=100 　　由于涉及到位运算，所以很容易想到按二进制位来做。要让答案最小，显然要从二进制高位到低位判断，能取0就取0。 　　所以我们考虑一...
APIO2015&2014题解
weixin_30852419的博客
04-26 121
传送门：似乎uoj都有 思路： APIO2015： 巴厘岛的雕塑： 看到位运算，又要求结果最小，最外层肯定是个从高位到低位的按位贪心 这里有两个部分分， task1:N<=100,1<=A<=B<=N task2:N<=2000,A=1,1<=B<=N 先考虑task1 令sum[i]表示雕塑权值的前缀和 假设我们考...
APIO2015总结
Tgop_Knight的专栏
05-02 1202
可怜的铜牌……
APIO2015 Problemset
06-12
### APIO2015 Problemset - Bali Sculptures #### 问题背景 在亚洲太平洋信息学奥林匹克（Asia-Pacific Informatics Olympiad，简称APIO）2015年的竞赛中，有一道名为“Bali Sculptures”的题目。这道题目的背景...
APIO2015年竞赛试题中文版
09-11
2015年亚太地区信息学奥林匹克竞赛（Asia-Pacific Informatics Olympiad, APIO）试题中文版
APIO2015竞赛试题中文版
09-11
2015年亚太地区信息学奥林匹克竞赛（Asia-Pacific Informatics Olympiad, APIO）试题中文版
APIO 2015
binarycopycode
07-01 1268
DAY0 晚上7点上的火车，火车上玩了几把dota，然后看了一下电影，软卧的床真心舒服啊，只是房间里没有插座，我只能强行到厕所旁边给笔记本充电，12点就睡了。DAY1 我一睁开眼，看见手表5点半，我就想这我手表什么时候坏的，昨晚看时间还是对的啊，我去年买的表怎么就坏了。。。。但天太亮了，我也睡不着了，就出门去隔壁看看，一出门就碰到GB，我问几点了，结果他说5点半- -，我擦，北方这天亮
【BZOJ 4070】 [Apio2015]雅加达的摩天楼
Regina8023
05-16 2992
分块+最短路~
[APIO] [最短路] [UOJ#111] APIO2015 Jakarta Skyscrapers
HeRaNO@HSAHRBNU
02-28 1213
题目传送门 容易看出是最短路，但是直接暴力加边最多可以加出n2n^2条，这是57pts的，所以需要优化…… 一种优化方法是利用分块思想，网上有很多就不再赘述了，大体思路是：根据摩天楼分成n√\sqrt n块，如果pi≥n√p_i\ge \sqrt n就暴力建边，如果pi<n√p_i< \sqrt n就按步数拆点，再连一些使图联通的边就好了。 这种方法最多建边数为nn√n\sqrt n级别的，请
bzoj4070【APIO2015】雅加达的摩天楼
AaronPolaris
04-20 3712
SPFA求最短路+分块思想优化构图
APIO2015 UOJ #110 - #112 题解
毒液哥的专栏
04-27 555
T1：给你一个序列A，问将A划分成K块(A 有个显然的想法是按二进制位依次考虑。那么假设当前在考虑第pos位，之前位的ans已经确定，我们可以用dp[[i][j]表示前i个元素分成j块能否满足条件，那么枚举断点，再判断一下就行。最后看这一位能否为0，就是找dp[N][i] (A 上述做法复杂度为O(N ^ 3 * log(Ans))，无法通过最后一个子任务。 但我们注意到最后一个子任务中
APIO2015 UOJ 110-112
月下沙茶树
04-27 664
#110. 【APIO2015】Bali Sculptures 很像NOI2014的起床困难综合征 首先每一位拆开来做 从高位到低位贪心，看每一位能不能为0 N N #include #include #include #include using namespace std; const int inf=1e9; #define rep(i,l,r) for(int i=l;i<=r
[UOJ 111][APIO 2015]Jakarta Skyscrapers(Dijkstra+pbds堆暴力)
某沙茶的OI代码库
05-19 1623
题目链接http://uoj.ac/problem/111思路显然每条狗在整个过程中只会连续地跳跃一段时间，这显然不用我多说了。 这样显然就是一个最短路问题(大雾)，求0号狗所在柱子到1号狗所在柱子的最短路于是有下面的几个做法。1、36分做法 直接暴力加边，然后跑SPFA啥的最短路就OK了 但是题目似乎故意卡了下这种做法，因此这种做法虽然时间复杂度和57分做法一样，但是会炸掉内存 2、5
APIO2015题解
TYB的博客
02-25 226
感觉这套还是十分可做的…… 巴厘岛的雕塑 Bali Sculptures 这题比较简单，看完就大概知道做法。显然要从高到低一位一位的贪心，问题是如何保证前面位也是合法的。如果已经确定了前kkk位，显然只要当前状态的前kkk位是其子集就行了。于是有一个暴力的DP：fi,jf_{i,j}fi,j​表示前i个数，分了jjj段是否可以使当前这位取到最大。这样是O(n3)O(n^3)O(n3)的。来看一下最...
「APIO 2015」八邻旁之桥「权值线段树」
_Gion
09-16 354
题目传送门 题解 对于在河同侧的，直接累加进答案。 剩下的直接看做mmm条线段li,rili,ril_i,r_i（因为桥宽度为111，最后加上mmm就行）. 然后当k=1k=1k=1时： 就是找到一个ppp来最小化∑mi=1abs(li−p)+abs(ri−p)∑i=1mabs(li−p)+abs(ri−p)\sum_{i=1}^{m} abs(l_i-p)+abs(r_i-p) 直接...
APIO2009竞赛试题解析-采油区域问题
"APIO2009试题-中文版，2014年的亚太地区信息学奥林匹克竞赛试题，包括三个题目：采油区域、会议中心、抢掠计划。" 在2009年的亚太地区信息学奥林匹克竞赛（APIO）中，参赛者面临的挑战之一是名为"采油区域"的问题...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值