Codeforces Round #608 (Div. 2) 题解
- 前言
- A. Suits
  - 题意
  - 做法
  - 程序
- B. Blocks
  - 题意
  - 做法
  - 程序
- C. Shawarma Tent
  - 题意
  - 做法
  - 程序
- D. Portals
  - 题意
  - 做法
  - 程序
- E. Common Number
  - 题意
  - 做法
  - 程序
- 结束语

Codeforces Round #608 (Div. 2) 题解

前言

题目链接：仅仅只是为了方便以题目作为关键字能查找到我的题解而已（逃

Codeforces 1271A

重要：没有F的题解，想看F题题解的神仙们可以走了

A. Suits

题意

给你$a$条领带，$b$条围巾、$c$件背心、$d$件夹克，有以下两种套装：

一条领带、一件夹克，花费$e$元
一条围巾、一件背心、一件夹克，花费$f$元

求出最多可以卖多少钱（不能单卖）。（奸商）

做法

依题意可得：

假如有$i$种$e$元的套装，那么就是价格是$i \times e + min \{ d-i, b, c \} \times f$元，枚举即可（注意 $i$, $d-i$, $b$, $c$ 中不能出现负数）。

程序

#include<bits/stdc++.h>

using namespace std;

int a,b,c,d,e,f,ans;

int main(){

    ios::sync_with_stdio(false);

    cin.tie(0);

    cout.tie(0);

    cin>>a>>b>>c>>d>>e>>f;

    for(int i=0;i<=min(a,d);i++){//数据范围小，直接暴力枚举

        ans=max(ans,i*e+min((d-i),min(b,c))*f);

    }

    cout<<ans<<endl;

    return 0;

}

B. Blocks

FST的我真的是太菜了

题意

给你一排$n$个方块，每个方块有黑白两种颜色，每次操作可以反转两个相邻的方块的颜色，问能否$3n$次数内反转成一整排都是同一种颜色。

做法

假设序列反转成白色，那么从前到后跑一遍，如果当前方块不是白色就反转它和它后边的方块，最后一个方块如果跑完操作完是白色就OK。黑色同理，假设序列反转成黑色，那么从前到后跑一遍，如果当前方块不是黑色就反转它和它后边的方块，最后一个方块如果跑完操作完是黑色就OK。最后如果都不可以就输出$-1$了。

程序

#include<bits/stdc++.h>

using namespace std;

int n;

char s[205];

vector<int> op;

int main(){

    ios::sync_with_stdio(false);

    cin.tie(0);

    cout.tie(0);

    cin>>n;

    cin>>s+1;

    //假设全是白色：

    for(int i=1;i<n;i++){

        if(s[i]=='B'){

            s[i]='W';

            s[i+1]=s[i+1]=='W'?'B':'W';

            op.push_back(i);

        }

    }

    //判断最后一个方块：

    if(s[n]=='W'){

        cout<<op.size()<<endl;

        for(int i=0;i<op.size();i++){

            cout<<op[i]<<' ';

        }

        cout<<endl;

        return 0;

    }

    //假设全是黑色：（此时可以直接再操作同一个序列）

    for(int i=1;i<n;i++){

        if(s[i]=='W'){

            s[i]='B';

            s[i+1]=s[i+1]=='W'?'B':'W';

            op.push_back(i);

        }

    }

    //判断最后一个方块

    if(s[n]=='B'){

        cout<<op.size()<<endl;

        for(int i=0;i<op.size();i++){

            cout<<op[i]<<' ';

        }

        cout<<endl;

        return 0;

    }

    cout<<-1<<endl;

    return 0;

}

C. Shawarma Tent

比B简单

题意

给你一个平面直角坐标系（刚刚数学课学过诶），之后给你一座学校和$n$个学生的坐标（都是整点），问你在一个不同于学校的整点上建一个买Shawarma的帐篷，如果学生从学校到家的某一条神奇路径上经过就会买（当消费者傻子吗），问你最多会有几个学生买，和此时帐篷的坐标（任意一种坐标即可）（奸商）。

注：整点指横坐标、纵坐标都是整数的点。神奇路径是只能上下左右移动（平行于横轴或纵轴）的两点间的最短路径（长度就是两点间的曼哈顿距离）（两点间可能有多条）。

做法

显然的，距离学校越近，就会有越多学生从帐篷经过，所以只要枚举学校上下左右的四个点看哪个最优就可以了。

程序

#include<bits/stdc++.h>

using namespace std;

int n,sx,sy;

int x[200005],y[200005];

int l,r,u,d;

//l, r, u, d 分别表示左右上下的帐篷经过的学生个数

int main(){

    ios::sync_with_stdio(false);

    cin.tie(0);

    cout.tie(0);

    cin>>n>>sx>>sy;

    for(int i=1;i<=n;i++){

        cin>>x[i]>>y[i];

        if(x[i]>sx)r++;

        if(x[i]<sx)l++;

        if(y[i]>sy)u++;

        if(y[i]<sy)d++;

        //对于经过帐篷的学生计数

    }

    if(r>=l&&r>=r&&r>=u&&r>=d){

        cout<<r<<endl;

        cout<<sx+1<<' '<<sy<<endl;

    }else

    if(l>=l&&l>=r&&l>=u&&l>=d){

        cout<<l<<endl;

        cout<<sx-1<<' '<<sy<<endl;

    }else

    if(u>=l&&u>=r&&u>=u&&u>=d){

        cout<<u<<endl;

        cout<<sx<<' '<<sy+1<<endl;

    }else

    if(d>=l&&d>=r&&d>=u&&d>=d){

        cout<<d<<endl;

        cout<<sx<<' '<<sy-1<<endl;

    }

    //这里的u>=u之类只是方便copy&paste罢了

    return 0;

}

D. Portals

题面好长啊，真的不想翻译

题意

你要攻下$n$座城市。一开始你有$k$个士兵。攻下第$i$个城市，你需要$a_i$个士兵（进攻时不损失士兵），攻下后你会抓$b_i$个壮丁扩充你的队伍，攻下后你可以派一个士兵来防守，防守会使得你的分数增加$c_i$，损失一个士兵。防守有两种方式：

你可以防守你所在的第$i$个城市
有$m$个单向的传送门，从$u$到$v$，如果你在$u$，可以派兵防守$v$（必须是直接被传送门连接的城市）

你必须从第$1$座一直攻克到第$n$座城市，如果不能攻克全部城市，你就输了，输出$-1$，如果能赢，求出最大的分数。

做法

贪心的做，计算$req_i = max \{ a_{i+1} , req_{i+1} - b_{i+1} \} | req_n = 0$代表在第$i$个城市攻克并有$b_i$士兵加入后，你完成游戏最少需要的士兵。之后就会有部分士兵空出，第$i$个城市新空出士兵个数记为$fr_i$，然后用大根堆来分派士兵到城市就好了。

此时，第$i$个城市的可以守卫它的最后一个城市记为$def_i$，从$1$到$i$的空闲士兵显然都可以守卫它（空闲士兵可以跟着你到下一个城市）。

程序

#include<bits/stdc++.h>

using namespace std;

int n,m,k;

int a[5005],b[5005],c[5005],fr[5005];

vector<int> g[5005];//无用数组

int def[5005],req[5005];

priority_queue<pair<int,int> > pq;

int ans;

int main(){

    ios::sync_with_stdio(false);

    cin.tie(0);

    cout.tie(0);

    cin>>n>>m>>k;

    for(int i=1;i<=n;i++){

        cin>>a[i]>>b[i]>>c[i];

        def[i]=i;

    }

    for(int i=1;i<=m;i++){

        int u,v;

        cin>>u>>v;

        g[u].push_back(v);//无用语句

        def[v]=max(def[v],u);

    }

    for(int i=n;i>=1;i--){

        req[i]=max(a[i+1],req[i+1]-b[i+1]);cerr<<i<<' '<<req[i]<<endl;

    }

    //计算req[i]

    int cur=k;

    for(int i=1;i<=n;i++){

        if(cur<a[i]){

            cout<<-1<<endl;

            return 0;

        }

        cur+=b[i];

    }

    //↑判断是否能赢↑

    cur=k;

    for(int i=1;i<=n;i++){

        cur+=b[i];

        fr[i]=cur-req[i];cur=req[i];

        pq.push(make_pair(c[i],i));

    }

    //计算fr[i],初始化以重量为第一关键字降序排列的堆

    while(!pq.empty()){

        int val=pq.top().first,x=pq.top().second;

        pq.pop();

        int y=def[x];

        while(!fr[y]&&y>0)y--;

        if(y==0)continue;

        fr[y]--;//贪心地选择最后一个能选的城市的空闲士兵

        ans+=val;

    }

    cout<<ans<<endl;

    return 0;

}

E. Common Number

题意

做到E的人应该都知道吧。。。而且题面很简短我就不写了（逃

做法

定义$k_i$为包含$i$的路径的个数。

首先，奇数和偶数分开考虑，你会发现同一个$n$，同为奇数或偶数时，$y$变大了$k_y$肯定变小，所以具有单调性，可以二分。

我们再来看对于单个的数，如何计算包含它的路径条数：

把路径的计算反过来想，可以得出在路径的反推中，只有偶数可以加一，而所有数都可以乘二。记录有多少个可以通过这种方式得到的数就可以了。但是这样太慢了，所以我们需要一个更快的方法：

通过观察得出，乘二的次数相同时，从最小可达值（只乘过二）到最大可达值（每次乘二后都加一），之间的所有数都是可以达到的，那么我们只要计算最小值和最大值就好了，复杂度--。由于乘二肯定比加一增长得快，所以对于每一种乘以二的次数，把这个区间的长度加到路径条数就可以了。

程序

#include<bits/stdc++.h>

using namespace std;

typedef long long ll;

ll n,k;

bool check(ll m){

    ll l=m,r=m,res=0;

    if(!(m&1)){r++;}//当m是偶数时给r增加1

    for(int i=1;;i++){//其实i没有什么用

        res+=min(n,r)-l+1;//添加区间长度到返回值

        //for(int j=l;j<=min(r,n);j++)cerr<<j<<' ';

        l<<=1;

        r=(r<<1)+1;//计算下一个l和r

        if(l>n)break;//当l大于n时就没有计算的必要了，直接退出

    }//cerr<<endl;

    return res>=k;

}

int main(){

    ios::sync_with_stdio(false);

    cin.tie(0);

    cout.tie(0);

    cin>>n>>k;

    //for(int i=1;i<=n;i++)check(i);

    ll l=1,r=(n+1)/2,m,ans;//二分奇数

    while(l<=r){

        m=(l+r)>>1;

        if(check(2*m-1)){

            ans=2*m-1;

            l=m+1;

        }else{

            r=m-1;

        }

    }

    l=1;r=n/2;//二分偶数

    while(l<=r){

        m=(l+r)>>1;

        if(check(2*m)){

            ans=max(ans,2*m);//由于ans已经取了奇数的值，所以这里是max

            l=m+1;

        }else{

            r=m-1;

        }

    }

    cout<<ans<<endl;

    return 0;

}

结束语

点个在看吧！

很抱歉不会F题不能帮到部分人，所以我（逃