题目地址：http://acm.csust.edu.cn/contest/82
A 红黑树
最后得到的字符串只有两种情况
1.brbrbrbrbrb s1
2.rbrbrbrbrbr s2
所以我们只要把这两种情况的操作数算出来取较小的
具体怎么算呢
假设 该位为 b 并且 s1为 r cntb++
该位为 r 并且 s1为 b cntr++
操作数就为 max(cntb,cntr);
s2 同理
#include<iostream>
#include<cstdio>
#include<map>
#include<math.h>
#include<queue>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long ll;
const int maxn=5e3+7;
const int mod=1e9+7;
string s,s1,s2;
int main (){
int n,x1=0,x2=0,x3=0,x4=0;
cin>>n>>s;
int ans1=0,ans2=0;
for(int i=0;i<n;i++){
if(i%2==1) s1+='b',s2+='r';
else s1+='r',s2+='b';
}
for (int i=0;i<n;i++){
if(s[i]=='b'&&s1[i]=='r') x1++;
if(s[i]=='r'&&s1[i]=='b') x2++;
}
for (int i=0;i<n;i++){
if(s[i]=='b'&&s2[i]=='r') x3++;
if(s[i]=='r'&&s2[i]=='b') x4++;
}
printf ("%d\n",min(max(x1,x2),max(x3,x4)));
}
B厂里吃鸡王 (多源最短路)
题意：
大概就是你降落在任意一个点，求所有的k种装备到你的最短距离。通俗一点就是，你从起点出发，找到离你最近的装备1，然后传送回起点（传送不需要花费），接着找装备2…（菜鸡的我看了半天才懂）
看完这个题 我最原始的思路是 枚举这n个点，每个点跑一次最短路，然后在一件一件装备的取最小值（这样肯定会t）
然后看完lcjdl的题解，和听他解释了好久，我才知道这个怎么写。
我们观察到 装备数量最多就 100 种，那么我们可不可以把每种装备的点看成一个点，然后求这个点到所有1—n 的点的最短路呢。这样最多就是求 100次最短路了。
怎么把装备相同的点看成一个点呢 我们构造一个点（n+1），然后让这个点和所有装备为 i 的点 建立一条长为0的边，对n+1点跑最短路，就能达到想要的结果了，画个图看看应该就知道了。
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=1e5+7;
const int mod=1e9+7;
ll head[maxn],num=0,dis[maxn],ans[maxn],vis[maxn],vec[108][maxn],si[108];
struct exam{
ll to,w,next;
}e[maxn<<1];
void add(ll u,ll v,ll w){
e[num].next=head[u];
e[num].to=v;
e[num].w=w;
head[u]=num++;
}
void SPFA(ll u){
queue<ll >que;
memset(vis,0,sizeof(vis));
for(int i=0;i<maxn;i++) dis[i]=99999999;
dis[u]=0;
vis[u]=1;
que.push(u);
while(!que.empty()){
ll now=que.front();que.pop();
vis[now]=0;
for(int i=head[now];i!=-1;i=e[i].next){
if(dis[now]+e[i].w<dis[e[i].to]){
dis[e[i].to]=dis[now]+e[i].w;
if(!vis[e[i].to]){
que.push(e[i].to);
vis[e[i].to]=1;
}
}
}
}
}
int main (){
memset(head,-1,sizeof(head));
ll n,m,k,x,u,v;
cin>>n>>m>>k;
for(int i=1;i<=n;i++){
scanf("%lld",&x);
vec[x][si[x]++]=i;
}
for(int i=0;i<m;i++){
scanf("%lld%lld",&u,&v);
add(u,v,1);
add(v,u,1);
}
for(int i=1;i<=k;i++){
head[n+1]=-1;
for(int j=0;j<si[i];j++){
add(n+1,vec[i][j],0);
add(vec[i][j],n+1,0);
}
SPFA(n+1);
for(int i=1;i<=n;i++){
ans[i]+=dis[i];
}
}
for(int i=1;i<=n;i++){
if(ans[i]>999999) printf ("0 ");
else printf ("%lld ",ans[i]);
}
}
C.战域(优先队列)
首先初始值相同 也就是都是0次的时候是有一个初始值的，这里很容易错。然后就把第1次的花费减去第0次的花费放到优先队列里。然后一个一个取出来 更新答案 更新花费（第x+1次减第x次）后放回去就好了，循环m次。
#include<iostream>
#include<cstdio>
#include<map>
#include<math.h>
#include<queue>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long ll;
const int MAXN=1e6+7;
const int mod=1e9+7;
struct node{
int a,b,c,d,y;
bool operator >(node a) const { return d > a.d; }
}s1,s2;
int main (){
priority_queue<node, vector<node>, greater<node> >que;
struct node s1,s2;
int n,m,t=0;
ll ans=0;
scanf("%d%d",&n,&m);
for(int i=0;i<n;i++){
scanf("%d%d%d",&s1.a,&s1.b,&s1.c);
s1.y=1;
s1.d=s1.a+s1.b;
// printf ("***");
que.push(s1);
ans+=s1.c;
}
while(t<m){
s2=que.top();
que.pop();
ans+=s2.d;
s2.d=2*s2.a*s2.y+s2.a+s2.b;
s2.y++;
que.push(s2);
t++;
}
printf ("%lld\n",ans);
}
D 摆蔬菜2（二分）
先了解一下那啥 n包蔬菜的组合有 (2^n)-1;
然后我们就对重量排个序
从头开始 对每一包蔬菜找最大的合法区间 区间长度len
所以 答案就是 ans+=(2^len)-1;
这样当然是不太对的 因为我们算了很多重复的。所以每次加的时候 还要减去前面算过的。
举个例子 :
6 7
2 4 5 5 10 11
对 2 找合法区间 就是 [2 4 5 5] ans+=2^4-1;
对 4 找合法区间 就是 [4 5 5 10 11] ans+=2^5-1,但是[4,5,5]上一次已经算过了 所以ans -=2^3-1;
这时候 已经到达最右端了 直接 break .(可以想想为什么)
ps:注意减法取模（比赛的时候我就没注意，还好最后几十秒发现了，很刺激） 找合法区间记得二分 了解一下lower_bound
补充 一下 这题我其实想复杂了，听了大佬们的建议，可以简化操作：
同样是枚举每一个点 找最大合法区间，不同点在于计算：
对于 [2 4 5 5] 我们可以一定把2包括在子区间内 这样就变成了算 [4 5 5] 的可以为空的子集 也就是 2^(4-1);
所以答案就是 ans+=2^(len-1) 是不会重复的
代码:
#include<iostream>
#include<cstdio>
#include<map>
#include<math.h>
#include<queue>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long ll;
const int MAXN=1e6+7;
const int mod=1e9+7;
int a[MAXN];
long long poww(long long a,long long b){//快速幂
long long ans=1;
while(b>0){
if(b&1) ans=ans*a%mod;
a=a*a%mod;
b>>=1;
}
return ans;
}
int main (){
ll n,k,ans=0,rr=0;
scanf("%lld%lld",&n,&k);
for(int i=1;i<=n;i++){
scanf("%lld",&a[i]);
}
sort(a+1,a+n+1);
for(int i=1;i<=n;i++){
int l=i,r=n,mid;
while(l<r){
mid=(l+r)/2;
if(a[mid]<=a[i]+k) l=mid+1;
else r=mid;
}
if(l==n&&a[i]+k>=a[n]){
ans=(ans+(poww(2,l-i+1)-1-poww(2,rr-i+1)+1+mod)%mod)%mod;
break;
}
ans=(ans+(poww(2,l-i)-1-poww(2,rr-i+1)+1+mod)%mod)%mod;
rr=l-1;
}
printf ("%lld\n",ans);
return 0;
}
E 摆蔬菜1
听学长说是 单调队列 （我貌似还不会）
我是用 rmq+二分 写的
和上题类似 对每个点向右找最大合法区间 （应该是有单调性的）然后利用前缀和更新答案就好了
难点就在于怎么二分吧 我就先不放代码了
代码：
#include<iostream>
#include<cstdio>
#include<map>
#include<math.h>
#include<queue>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long ll;
const int MAXN=5e5+20;
ll a[MAXN],dpma[MAXN][32],dpmi[MAXN][32],pre[MAXN];
ll qa(int l, int r){
int k=log((r-l+1)*1.0)/log(2.0);
return max(dpma[l][k],dpma[r-(1<<k)+1][k]);
}
ll qi(int l,int r){
int k=log((r-l+1)*1.0)/log(2.0);
return min(dpmi[l][k], dpmi[r - (1 << k) + 1][k]);
}
int main (){
ll n,k,ans=0;
scanf("%lld%lld",&n,&k);
for(int i=1;i<=n;i++){
scanf("%lld",&a[i]);
dpma[i][0]=a[i],dpmi[i][0]=a[i];
pre[i]=pre[i-1]+a[i];
}
for(int j=1;(1<<j)<=n;j++){
for(int i=1;i+(1<<j)-1<=n;i++){
dpma[i][j]=max(dpma[i][j-1],dpma[i+(1<<(j-1))][j-1]);
dpmi[i][j]=min(dpmi[i][j-1],dpmi[i+(1<<(j-1))][j-1]);
}
}
for(int i=1;i<=n;i++){
int l=i,r=n,mid;
while(l<r-1){
mid=(l+r)/2;
if(qa(i,mid)-qi(i,mid)<=k){
l=mid;
}
else r=mid-1;
}
if(qa(i,l+1)-qi(i,l+1)<=k&&l+1<=n) ans=max(pre[l+1]-pre[i-1],ans);
ans=max(pre[l]-pre[i-1],ans);
}
printf ("%lld\n",ans);
return 0;
}
扫一扫
988
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
