Benelux Algorithm Programming Contest 2019 计蒜客解(补)题报告

最新推荐文章于 2021-08-04 17:37:22 发布

Happig丶

最新推荐文章于 2021-08-04 17:37:22 发布

阅读量331

点赞数

分类专栏： # 计蒜客

本文链接：https://blog.csdn.net/qq_44691917/article/details/105024459

版权

计蒜客专栏收录该内容

26 篇文章 0 订阅

订阅专栏

B - Breaking Branches（博弈论）

题目链接
在这里插入图片描述
1.题目大意：A和B两个人玩一个游戏，其中A先手。给出一个数字n，每个人每次必须将n或者其一部分分成两个整数，最后一个不能分的人算输，即最后一次分的人算赢，输出赢的人的名字。如果A赢还输出A最后一次分完形成的数字大小

2.显然，当都分成1时，就是不可再分状态。对于2，分一次就成了两个1，肯定先手赢。对于3，只能分成1和2这一个状态，后手赢。对于4，分成1和3的话，变成了B作为3的先手，那么B赢；如果4分成2和2，那么对于1个2的话是先手赢，两个的话就是后手(A)赢，所以总的来说是先手赢…可以发现这样一个规律，如果是奇数的话无论怎么分都是B赢，如果是偶数的话就无论怎么分都是A赢

代码：

#include <iostream>
using namespace std;
int main()
{
    int n;
    cin>>n;
    if(n&1){
        cout<<"Bob"<<endl;
    }else{
        cout<<"Alice"<<endl;
        cout<<"1"<<endl;
    }
    return 0;
}

E - Efficient Exchange（规律模拟）

题目链接
在这里插入图片描述
1.题目大意：现在只有10的幂次面额的钱（1,10,100…），现在两个人要换
大小为n的钱，问最少经过几次“金钱交易”（如83，那么A给出一张100和三张1元，B找给A两张10元，最少交换6张人民币）

2.对于每一位来说，第一种方案直接用它的大小数量的钱；第二种方案是通过高一位的钱作中介。从钱的最低位开始不断向左看（因为如果可以用一张高位的做中介，低位交换的数量会减少）。假如该位小于5，那么贡献就是该位的大小，另外一种方案不是最优。假如该位大于5，那么使用高位当中介，高位的数量加一，低位的数量变为10-m

3.最容易遗漏的是该位是5的情况，因为如果直接按第一种就是5，但是按第二种会使前一位多一用一张。但是如果前一位多了一张后，可能发生微妙的变化！可以去试试450和85，不难发现前面的位数如果小于5，那么就使用第一种方案，否则就使用第二种方案。另外需要注意，因为整体来说最多进一位，那么就要考虑n+1位

代码：

#include <iostream>
#include <string>
#include <cstring>
using namespace std;
int a[1005],ans[1005];

int main()
{
    string s;
    int n;
    memset(ans,0,sizeof ans);
    getline(cin,s);
    n=s.size();
    for(int i=n-1,j=0;i>=0;i--,j++){
        a[j]=s[i]-'0';
    }
    for(int i=0;i<=n;i++){  //[0,n]!!!
        if(a[i]<=4){
            ans[i]=a[i];
        }else if(a[i]==5){
            if(a[i+1]>=5){
                a[i+1]++;
            }
            ans[i]=a[i];
        }else{
            if(a[i]<=10){
                a[i+1]++;
                ans[i]=10-a[i];
            }else{
                a[i+1]++;
                ans[i]=a[i]%10;
            }
        }
    }
    int res=0;
    for(int i=0;i<=n;i++){
        //cout<<ans[i]<<" ";
        res+=ans[i];
    }
    cout<<res<<endl;
    return 0;
}

F - Find my Family（STL+RMQ）

题目链接
在这里插入图片描述
1.题目大意：给出若干照片，如果一张照片能满足对于照片中的某个人来说，前面有比它高的，后面有比二者都高的，那么就是符合要求的照片。求所有满足的照片，并输出总数量和编号

2.从照片的第二个人到第n-1个人，假如它前面的比它大的最小值和它都比后面区间的最大值小，那么一定满足。对于前缀最大的最小值，前面2019沈阳区域赛的A题就是正解，使用set维护每个前缀，upperbound查找前缀最大的最小值。对于后缀区间的最大值，这里用静态RMQ查询即可

代码：

#include <iostream>
#include <set>
#include <cstring>
#include <algorithm>
using namespace std;
#define M 25
#define N 300005
using namespace std;
int n,m;
int a[N],Log[N];
int f[N][M];
int min_prev[N];
void GetLog()
{
	int i;
	Log[1]=0;
	for(i=2;i<=n+1;++i)
	  Log[i]=Log[i/2]+1;
}
void RMQ()
{
	int i,j;
	for(i=1;i<=n;++i)
	  f[i][0]=a[i];
	for(j=1;(1<<j)<=n;++j)
	  for(i=1;i+(1<<(j-1))<=n;++i)
	    f[i][j]=max(f[i][j-1],f[i+(1<<(j-1))][j-1]);
}

int main()
{
    int t,num=0;
    set<int> s,ans;
    scanf("%d",&t);
    for(int kase=1;kase<=t;kase++){
        scanf("%d",&n);
        s.clear();
        memset(min_prev,0,sizeof min_prev);
        for(int i=1;i<=n;i++){
            scanf("%d",&a[i]);
            auto pos=s.upper_bound(a[i]);  //先查找后插入
            if(pos!=s.end()){
                min_prev[i]=*pos;
            }
            s.insert(a[i]);
        }
        GetLog();
        RMQ();
        for(int i=2;i<n;i++){
            int k=Log[n-i];
            int res=max(f[i+1][k],f[n-(1<<k)+1][k]);
            if(min_prev[i]>a[i] && res>a[i] && res>min_prev[i]){
                ans.insert(kase);
                num++;
                break;
            }
        }
    }
    printf("%d\n",num);
    for(auto i=ans.begin();i!=ans.end();i++){
        printf("%d\n",*i);
    }
    return 0;
}

G - Gluttonous Goop（模拟+填补法）

题目链接
在这里插入图片描述
1.题目大意：给出一个初始r行c列的培养皿，里面的’#'代表初始有病毒。病毒每繁殖一次就会向周围的八个格子繁衍，问经过若干天后一共有多少病毒（病毒可以跨过初始培养皿）

2.对于一个病毒来说，每次它的高度和宽度都会增加2，但是仔细观察下面这个图，当培养皿的病毒连在一起时，就变成了一个整体，每次扩张和一个病毒一样，而且框住该部分的矩形的空缺部分不变
在这里插入图片描述
3.但是怎么知道什么时候病毒的繁殖会连在一起呢？跟培养皿的大小有关，因为培养皿最大是20×20的，那么经过20次之后病毒一定会连在一起。也就是说如果繁殖20次以上，先处理前20次确保连在一起，算出此时的高度宽度和空缺部分，接下来直接算即可。如果小于20次，直接模拟

代码：

#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
#define INF 0x7fffffff
typedef long long ll;
bool G[105][105];

int main()
{
    int r,c,k;
    ll cnt=0;
    string s;
    cin>>r>>c>>k;
    int num=k>20?20:k;
    for(int i=0;i<r;i++){
        cin>>s;
        for(int j=0;j<c;j++){
            if(s[j]=='#'){
                G[i+20][j+20]=1;
                for(int p=-num;p<=num;p++)
                for(int q=-num;q<=num;q++)
                    G[i+20+p][j+20+q]=1;
            }
        }
    }
    int minr=INF,minc=INF,maxr=0,maxc=0;
    for(int i=20-num;i<r+20+num;i++){
        for(int j=20-num;j<c+20+num;j++){
            if(G[i][j]){
                cnt++;
                minr=min(minr,i);
                minc=min(minc,j);
                maxr=max(maxr,i);
                maxc=max(maxc,j);
            }
        }
    }
    ll ans=1;
    if(cnt && k>20){
        ll h=maxr-minr+1,w=maxc-minc+1;
        ll loss=h*w-cnt;
        ans*=h+(k-num<<1);
        ans*=w+(k-num<<1);
        printf("%lld\n",ans-loss);
    }else printf("%lld\n",cnt);
    return 0;
}

H - Historic Exhibition（贪心）

题目链接
在这里插入图片描述
1.题目大意：给出若干底座和若干花瓶，底座有两头，即两个直径，但花瓶只有一个直径。现在规定只有花瓶直径和底座完全匹配才能放上去。问所有花瓶能不能都放在对应底座上

2.最重要的条件是，底座的上下直径相差最多为1。对所有底座分为上下直径相同和不同的两部分，第二部分只存较小的直径。接下来要看花瓶如何分了，对所有的花瓶按直径排序，如果有第一部分的花瓶则直接匹配，否则应先看第二部分有没有花瓶直径减一的底座，接着再看有没有当前花瓶直径的底座。都没有的话就是impossible。证明：如果有直接减一的底座，前面可能较小直径的花瓶匹配的第一部分，而第二部分仍有它对应底座，那么就将该底座匹配给直径大1的花瓶，这样保证了所有直径的花瓶都会匹配

代码：

#include <iostream>
#include <algorithm>
#include <stack>
#include <tr1/unordered_map>
using namespace std;
const int maxn=1e4+10;
int ans[maxn];
struct node{
    int val,id;
    bool operator < (const node& p) const {
        return val==p.val?id<p.id:val<p.val;
    }
}v[maxn];
tr1::unordered_map<int,stack<int> > mp1,mp2;
int main()
{
    int n,m,a,b;
    ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
    cin>>n>>m;
    for(int i=1;i<=n;i++){
        cin>>a>>b;
        if(a==b) mp1[a].push(i);
        else mp2[min(a,b)].push(i);
    }
    for(int i=1;i<=m;i++){
        cin>>v[i].val;
        v[i].id=i;
    }
    int flag=1;
    sort(v+1,v+m+1);
    for(int i=1;i<=m;i++){
        if(!mp1[v[i].val].empty()){
            ans[v[i].id]=mp1[v[i].val].top();
            mp1[v[i].val].pop();
        }else if(!mp2[v[i].val-1].empty()){
            ans[v[i].id]=mp2[v[i].val-1].top();
            mp2[v[i].val-1].pop();
        }else if(!mp2[v[i].val].empty()){
            ans[v[i].id]=mp2[v[i].val].top();
            mp2[v[i].val].pop();
        }else{
            cout<<"impossible"<<endl;
            flag=0;
            break;
        }
    }
    if(flag){
        for(int i=1;i<=m;i++)
            cout<<ans[i]<<endl;
    }
    return 0;
}

J - Jazz it Up!（素数筛选+质因数分解）

题目链接
在这里插入图片描述
1.题目大意：给定n，问能否找到一个m，使得m*n不包含任何k²的因子(k>1)

2.先对数的范围内素数筛选，接着判断每一个质数是不是n的质因子，找一个不是它质因数的质数即可

代码：

#include <iostream>
#include <math.h>
#include <cstring>
using namespace std;
const int maxn=1e5+10;
bool isprime[maxn],vis[maxn];
int num,n,ans;

void init(){
    memset(isprime,true,sizeof(isprime));
    int m=sqrt(maxn+0.5);
    for(int i=2;i<=m;i++){
        if(isprime[i]){
            for(int j=i*i;j<=maxn;j+=i)
                isprime[j]=false;
        }
    }
}

void solve(int n){
    for(int i=2;i<=n;i++){
        if(!isprime[i]) continue;
        int d=n;
        if(d%i==0){
            vis[i]=1;
        }
    }
    for(int i=2;i<=n;i++){
        if(!vis[i] && isprime[i]){
            ans=i;
            break;
        }
    }
}

int main()
{
    ios::sync_with_stdio(0),cin.tie(0);
    init();
    cin>>n;
    memset(vis,0,sizeof vis);
    solve(n);
    cout<<ans<<endl;
    return 0;
}

Happig丶

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Benelux Algorithm Programming Contest 2019 计蒜客解(补)题报告

B - Breaking Branches（博弈论）题目链接1.题目大意：A和B两个人玩一个游戏，其中A先手。给出一个数字n，每个人每次必须将n或者其一部分分成两个整数，最后一个不能分的人算输，即最后一次分的人算赢，输出赢的人的名字。如果A赢还输出A最后一次分完形成的数字大小2.显然，当都分成1时，就是不可再分状态。对于2，分一次就成了两个1，肯定先手赢。对于3，只能分成1和2这一个状态，...
复制链接

扫一扫