Codeforces Bubble Cup 8 - Finals [Online Mirror] 解题报告

最新推荐文章于 2020-03-18 22:25:49 发布
最新推荐文章于 2020-03-18 22:25:49 发布
阅读量903 收藏
点赞数
分类专栏： 解题报告 文章标签： Codeforces
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/squee_spoon/article/details/48273969
版权

D Tablecity

        从一头往另一头扫一遍，再逆着回来就好了。因为贼每走一步，横坐标的奇偶性都会改变。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

int i;
int main(){
	printf("2000\n");
	for (i=1;i<=1000;i++) printf("%d 1 %d 2\n",i,i);
	for (i=1000;i>0;i--) printf("%d 1 %d 2\n",i,i);
	return 0;
}

H Bots

        每走一步，树增加了一层，节点数是上一层的2倍。但是到了第n+1层开始，就会出现红/蓝边数量达到n的情况，这样的节点不能翻倍，计算一下组合数把这种情况减去就行了。算组合数的时候递推计算，用到了逆元。

#include <iostream> 
#include <cstdio> 
#include <algorithm> 
#include <set>
#include <vector>
#include <string.h>
using namespace std; 

#define ll long long

const int mod=1000000007;

void ExEuclid(ll a,ll b,ll &x,ll &y,ll &q){    
    if(b==0){    
        x=1;y=0;q=a;    
        return;    
    }    
    ExEuclid(b,a%b,y,x,q);    
    y-=x*(a/b);    
}    
    
ll inv(ll num){    
    ll x,y,q;    
    ExEuclid(num,mod,x,y,q);    
    if(q==1)return (x+mod)%mod;    
}  

int main(){
	int n;
	while(cin>>n){
		ll ans=1;
		ll cur=1;
		ll C=1;
		for(int i=1;i<=n*2;i++){
			cur*=2;
			cur%=mod;
			if(i>n){
				cur-=2*C;
				cur+=mod;
				cur+=mod;
				cur%=mod;
				C*=i;
				C%=mod;
				C*=inv(i-n);
				C%=mod;
			}
			ans+=cur;
			ans%=mod;
		}
		cout<<ans<<endl;
	}
	return 0;
}

F Bulbo

        首先有一个可以推出来的结论，你只移动到输入数据中出现的那些位置，可以得到最优解（不需要移动到数据中没有出现的位置去）。所以就可以用离散化+dp+滚动数组来解决了。dp(i,j)表示第i轮时，位置在j（离散化后）的最优解（第一维滚动只开2）。注意状态转移时，本应是多个状态转移到一个状态，这样复杂度太高会超时，需要利用递推维护多个状态的最优值，一次性转移到一个状态。

        顺便说一下，后来发现这个题可以贪心，每次维护一个范围，每次开始前移动到这个范围内，灯亮，花费为最少。

#include <iostream> 
#include <cstdio> 
#include <algorithm> 
#include <set>
#include <vector>
#include <string.h>
using namespace std; 

#define ll long long

const int mod=1000000007;
ll INF=1000000000000000000LL;

int l[5010];
int r[5010];
ll dp[2][100010];
int pos[100010];
int k;

int main(){
	int n,x;
	while(cin>>n>>x){
		memset(dp,-1,sizeof(dp));
		
		ll ans=INF;
		k=0;
		pos[k++]=x;
		for(int i=1;i<=n;i++){
			scanf("%d%d",&l[i],&r[i]);
			pos[k++]=l[i];
			pos[k++]=r[i];
		}
		sort(pos,pos+k);
		k=unique(pos,pos+k)-pos;
		
		for(int i=0;i<k;i++){
			dp[0][i]=abs(x-pos[i]);
		}
		
		for(int i=1;i<=n;i++){
			ll part2=INF;
			for(int j=0;j<k;j++){
				dp[i%2][j]=INF;
				ll part1=0;
				if(pos[j]<l[i]){
					part1=l[i]-pos[j];
				}else if(pos[j]>r[i]){
					part1=pos[j]-r[i];
				}
				
				if(j>0){
					part2=min(part2+pos[j]-pos[j-1],dp[(i-1)%2][j]);
				}else{
					part2=dp[(i-1)%2][j];
				}
				dp[i%2][j]=min(dp[i%2][j],part1+part2);
			}
			part2=INF;
			for(int j=k-1;j>=0;j--){
				ll part1=0;
				if(pos[j]<l[i]){
					part1=l[i]-pos[j];
				}else if(pos[j]>r[i]){
					part1=pos[j]-r[i];
				}
				if(j<k-1){
					part2=min(part2+pos[j+1]-pos[j],dp[(i-1)%2][j]);
				}else{
					part2=dp[(i-1)%2][j];
				}
				dp[i%2][j]=min(dp[i%2][j],part1+part2);
			}
		}
		for(int i=0;i<k;i++){
			ans=min(ans,dp[n%2][i]);
		}	
		cout<<ans<<endl;
	}
	return 0;
}

B Bribes

        首先为了迅速求得树上许多点对之间的距离，需要使用nlogn的在线LCA（倍增法）。然后需要知道每条单向边被逆行了多少次，这时可用打标记的方法，起点+1终点-1，又由于它是树型结构，统计时用dfs。最后的计算利用了等比数列求和公式和快速幂。

#include <iostream> 
#include <cstdio> 
#include <algorithm> 
#include <set>
#include <vector>
#include <string.h>
using namespace std; 

#define ll long long

const int mod=1000000007;
ll INF=1000000000000000000LL;

#define max_size 100010  

ll Quick_Pow(ll a,ll n){ 
    ll ret=1;  
    ll temp=a%mod;  
    while (n){  
        if (n&1) ret=ret*temp%mod;  
        temp=temp*temp%mod;  
        n>>=1;  
    }  
    return ret;  
}  

int d[max_size],p[max_size][18];  
int head[max_size];  
int cnt;

int a[max_size];
int b[max_size];
int x[max_size];
bool downpoint[max_size];
bool uppoint[max_size];
int downres[max_size];
int upres[max_size];
bool vis2[max_size];

struct Edge{  
    int v;  
    int pre;  
}eg[max_size];  
  
void add(int x,int y){ 
    eg[cnt].v=y;  
    eg[cnt].pre=head[x];  
    head[x]=cnt++;  
}  
  
void dfs(int k){ 
    int m,x,i,j;  
    for(i=head[k];i!=0;i=eg[i].pre){  
        x=eg[i].v;  
        p[x][0]=k;  
        m=k;  
        d[x]=d[k]+1;  
        for(j=0;p[m][j]!=0;j++){  
            p[x][j+1]=p[m][j];
            m=p[m][j];  
        }  
        dfs(x);  
    }  
}  
  
int find_lca(int x,int y){  
    int m,k;  
    if(x==y)return x;  
    if(d[x]<d[y]){  
        m=x;  
        x=y;  
        y=m;  
    }  
    m=d[x]-d[y];  
    k=0;  
    while(m){
        if(m&1)  
        x=p[x][k];  
        m>>=1;  
        k++;  
    }  
    if(x==y)return x;  
    k=0;  
    while(x!=y){  
        if(p[x][k]!=p[y][k]||p[x][k]==p[y][k]&&k==0){  
            x=p[x][k];  
            y=p[y][k];  
            k++;  
        }  
        else{  
            k--;  
        }  
    }  
    return x;  
}

struct oriEdge{
    int v;
    int flag;
    oriEdge(int v,int flag):v(v),flag(flag){
    }
    oriEdge(){
    }
};

vector<oriEdge> E[max_size];  
bool vis[max_size];  
int siz[max_size];  
int predfs(int u){
    vis[u]=1;  
    int sz=E[u].size();  
    siz[u]=1;  
    for(int i=0;i<sz;i++){  
        int v=E[u][i].v;  
        if(!vis[v]){  
            if(E[u][i].flag==0){
                downpoint[v]=1;
            }
            if(E[u][i].flag==1){
                uppoint[v]=1;
            }
            add(u,v);  
            siz[u]+=predfs(v);  
        }  
    }  
    return siz[u];  
}  

ll ans=0;
int downcnt[max_size];
int upcnt[max_size];
void dfs2(int k){
	downcnt[k]+=downres[k];
    upcnt[k]+=upres[k];
    for(int i=head[k];i!=0;i=eg[i].pre){  
        int x=eg[i].v;
        dfs2(x);
        downcnt[k]+=downcnt[x];
        upcnt[k]+=upcnt[x];
    }
    if(uppoint[k]){
		ans+=Quick_Pow(2,upcnt[k])-1;
		ans+=mod;	ans%=mod;
	}
	if(downpoint[k]){
		ans+=Quick_Pow(2,downcnt[k])-1;
		ans+=mod;	ans%=mod;
	}
} 


int main(){
    int n;
    while(cin>>n){
        cnt=1;
        for(int i=1;i<n;i++){
            scanf("%d%d%d",&a[i],&b[i],&x[i]);
            if(!x[i])E[a[i]].push_back(oriEdge(b[i],2)); 
            else E[a[i]].push_back(oriEdge(b[i],1)); 
            if(!x[i])E[b[i]].push_back(oriEdge(a[i],2)); 
            else E[b[i]].push_back(oriEdge(a[i],0)); 
        }
        predfs(1);
        dfs(1);
        
        int k;
        cin>>k;
        int Last=1;
        
        for(int i=1;i<=k;i++){
            int s;
            scanf("%d",&s);
            int LCA=find_lca(Last,s);
            ll cur=0;
            
            if(Last!=LCA){
                upres[Last]++;
                upres[LCA]--;
            }
            if(s!=LCA){
                downres[s]++;
                downres[LCA]--;
            }
            Last=s; 
        }
        dfs2(1);
        cout<<ans<<endl;
    }
    return 0;
}

G Run for beer

        注意题目给的数据范围，边的长度最长是9，但是每多经过一个点，速度变为1/10。也就是说，需要经过尽可能少的点。另外，边长度可以是0，也就是说，如果最后经过了一系列长度为0的边，是不会增加时间的。我的做法是多次bfs，先找出哪些点到终点可以全是0边，然后在这些点中，找一个离起点最近的，再贪心找到路径。实现比较挫，bfs了好多次，也跪了好多次，最后才过。。。

#include <iostream> 
#include <cstdio> 
#include <algorithm> 
#include <set>
#include <stack>
#include <vector>
#include <queue>
#include <string.h>
using namespace std; 

#define ll long long

const int INF = 1000000000;

const int maxm=100010;
const int maxn=100010;

int head[maxn];
int pre[maxm<<1];
int from[maxm<<1];
int to[maxm<<1];
int len[maxm<<1];
int vis[maxn];
int tote;
int k;
int lv[maxn];
int _lv[maxn];
bool finish[maxn];
bool finish2[maxn];
int cost[maxn];
int lvcost[maxn];
int fa[maxn];
int _fa[maxn];

void init(){
	memset(head,-1,sizeof(head));
	tote=0;
	k=0;
}

void addedge(int u,int v,int l){
	to[tote]=v;	from[tote]=u;	len[tote]=l;
	pre[tote]=head[u];
	head[u]=tote++;
	//
	to[tote]=u;	from[tote]=v;	len[tote]=l;
	pre[tote]=head[v];
	head[v]=tote++;
}

int ans[maxn];
int path[maxn];

void clearQueue(queue<int> &que){
	while(que.size())que.pop();
}


int print(int u){
	
	int re=0;
	if(!finish[u])printf("%d",cost[u]);
	if(u)re=print(from[fa[u]])+1;
	
	path[k++]=u;
	return re;
}

int main(){
	init();
	
	int n,m;
	cin>>n>>m;
	
	for(int i=1;i<=m;i++){
		int u,v,l;
		scanf("%d%d%d",&u,&v,&l);
		addedge(u,v,l);
	}
	
	queue<int> que;
	que.push(0);	vis[0]=1;
	while(que.size()){
		int u=que.front();	que.pop();
		for(int i=head[u];~i;i=pre[i]){
			int v=to[i];
			if(vis[v])continue;
			vis[v]=1;
			lv[v]=lv[u]+1;
			que.push(v);
		}
	}
	
	clearQueue(que);
	memset(vis,0,sizeof(vis));
	que.push(n-1);	vis[n-1]=1;
	while(que.size()){
		int u=que.front();	que.pop();
		finish[u]=1;
		for(int i=head[u];~i;i=pre[i]){
			int v=to[i];
			if(len[i])continue;	//only 0 edge
			if(vis[v])continue;
			vis[v]=1;
			_lv[v]=_lv[u]+1;
			que.push(v);
			_fa[v]=i;
		}
	}
	
	int MIN=INF;
	for(int i=0;i<n;i++){
		if(finish[i]){
			MIN=min(MIN,lv[i]);
		}
	}
	
	for(int i=0;i<n;i++){
		if(lv[i]!=MIN){
			finish[i]=0;
		}
	}
	
	clearQueue(que);
	memset(vis,0,sizeof(vis));
	
	for(int i=0;i<n;i++){
		lvcost[i]=INF;
		if(finish[i]){
			que.push(i);
			vis[i]=1;
		}else{
			cost[i]=INF;
		}
	}
	lvcost[MIN]=0;

	while(que.size()){
		int u = que.front();	que.pop();
		if(lvcost[lv[u]]!=cost[u])continue;
		for(int i=head[u];~i;i=pre[i]){
			int v=to[i];
			if(lv[v]+1!=lv[u])continue;
			cost[v]=min(cost[v],len[i]);
			lvcost[lv[v]]=min(lvcost[lv[v]],cost[v]);
			if(vis[v])continue;
			vis[v]=1;
			que.push(v);
		}
	}
	
	clearQueue(que);
	memset(vis,0,sizeof(vis));
	que.push(0);	vis[0]=1;
	while(que.size()){
		int u=que.front();	que.pop();
		if(finish[u]){
			finish2[u]=1;
		}
		for(int i=head[u];~i;i=pre[i]){
			if(len[i]!=cost[u])continue;
			int v=to[i];
			if(vis[v])continue;
			vis[v]=1;
			que.push(v);
			fa[v]=i;
		}
	}

	int MIN2=INF;
	int target=-1;
	for(int i=0;i<n;i++){
		if(finish2[i]){
			if(_lv[i]<MIN2){
				MIN2=_lv[i];
				target=i;
			}
		}
	}

	if(print(target)==0){
		printf("0");
	}
	printf("\n");
	
	int cur=target;
	if(cur!=n-1)while(1){
		cur=from[_fa[cur]];
		path[k++]=cur;
		if(cur==n-1)break;
	}
	cout<<k<<endl;
	for(int i=0;i<k;i++){
		printf("%d ",path[i]);
	}
	return 0;
}

squee_spoon
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Bubble Cup 8 - Finals [Online Mirror]
ZZ_AC的博客
09-06 609
D. Tablecity time limit per test1 second memory limit per test256 megabytes inputstandar
Bubble Cup 8 - Finals [Online Mirror] H.Bots · 组合数
Yubing792289314的博客
03-14 302
题解 #include <bits/stdc++.h> using namespace std; typedef long long ll; const int N = 2e6 + 10; const int mod = 1e9 + 7; ll n, m, K; ll qpow(ll a, ll b) { ll res = 1; while (b) { ...
Bubble Cup 8 - Finals [Online Mirror] F.Bulbo · 贪心
Yubing792289314的博客
03-14 204
题解 题意：n轮游戏，每轮有一个区间的灯泡亮起，一开始人处在x的位置上，每轮游戏开始之前可以移动位置，代价是 ∣poxnew−posold∣|pox_{new}-pos_{old}|∣poxnew​−posold​∣ ，每轮游戏花费的代价是当前位置到最近的灯泡的距离，问n轮游戏后最小代价和 Bubble Cup 8 finals F. Bulbo (575F) #include <bi...
Bubble Cup 8 - Finals [Online Mirror] - A.Fibonotci【分段+ST表】
Mr.Phoebe的专栏
09-07 680
因为 sis_i为近似周期序列，而且告诉你了mm个位置以及数字。 那么就将序列分成mm段，每一段用一个ST表来维护区间矩阵乘积 然后注意一些细节，比如mm段分段如果两个不周期位置连续，以及最后一个段等等。想法还是比价明显的，但是确实不好写….#include<bits/stdc++.h> using namespace std; const int MAXN=50005; int MOD; st
Codeforces Bubble Cup 8 - Finals [Online Mirror]H. Bots 数学
weixin_34356138的博客
09-06 110
H. Bots Time Limit: 1 Sec   Memory Limit: 256 MB 题目连接 http://codeforces.com/contest/575/problem/H Description Sasha and Ira are two best friends. But they aren’t just friends...
Bubble Cup 11（Codeforces 1045） 简要题解
DZYO的博客
09-27 378
传送门 Last chance 可以连两个的肯定可以增广，剩下的线段树优化见图跑网络流。 输出方案可以dfs反向边来退流。
codeforces-user:---
05-09
这个项目可能是用来展示Codeforces用户的个人信息、竞赛成绩、解题记录等。 在深入探讨可能包含的内容之前，我们需要了解HTML的基本元素。HTML由一系列的标签组成，如`<html>`、`<head>`、`<body>`、`<title>`等，...
Codeforces-177A1-Good-Matrix-Elements
04-15
【标题】：“Codeforces-177A1-Good-Matrix-Elements” 是一个编程挑战，源自著名的在线编程竞赛平台Codeforces。这个问题涉及到数组处理和简单的数学逻辑，主要使用C++语言来解决。 【描述】：问题的核心在于寻找...
Codeforces-1497A-Meximization
03-18
【标题】"Codeforces-1497A-Maximization" 是一场编程竞赛中的一个问题，主要涉及算法设计和C++编程。在这个问题中，参赛者需要编写一个程序，执行特定的“最大化”操作，可能涉及到数组处理和数学优化。 【描述】...
a2oj-codeforces-div2c-ladder-solutions
05-09
a2oj-codeforces-div2c-ladder-solutions 我的A2online梯子裁判解决方案div2c codeforces
Codeforces 185A - Plant 全测试点49个
08-13
Codeforces 185A - Plant 全测试点49个 Codeforces 是一个在线编程平台，提供了大量的编程题目和比赛。其中，185A - Plant 是一个经典的题目，要求编写一个程序来解决植物生长的问题。 在这个题目中，输入是一个...
Codeforces Bubble Cup 8 - Finals [Online Mirror] F. Bulbo DP
weixin_34106122的博客
09-06 148
F. Bulbo Time Limit: 1 Sec   Memory Limit: 256 MB 题目连接 http://codeforces.com/contest/575/problem/F Description Bananistan is a beautiful banana republic. Beautiful women in b...
Bubble Cup X - Finals [Online Mirror] G. Bathroom terminal · 枚举
Yubing792289314的博客
03-18 151
题解
Bubble Cup X - Finals [Online Mirror] G. Bathroom terminal（STL）
so_so_y的博客
09-04 359
DescriptionSmith wakes up at the side of a dirty, disused bathroom, his ankle chained to pipes. Next to him is tape-player with a hand-written message “Play Me”. He finds a tape in his own back pocket.
Bubble Cup X - Finals [Online Mirror]
weixin_30532837的博客
09-04 108
来自FallDream的博客，未经允许，请勿转载，谢谢。 组了个菜鸡队打cf上的ACM比赛 比较快做完了8题但是菜的抠脚罚时巨多，所以最后被顶到了19名（居然没出首页） 自己的号自从上次疯狂掉分就没动过了，感觉像是红名橙名大佬中的一股清流。 A.奇怪的贪心，我写了一发结果挂了，题解见大爷博客 B.dp方程很容易列出来，然后写个矩阵乘法就行了。 C.每个点的位置决定了两边的白色小...
Bubble Cup X - Finals [Online Mirror] B. Neural Network country 矩阵快速幂加速转移
weixin_30437847的博客
09-08 129
B. Neural Network country time limit per test 2 seconds memory limit per test 256 megabytes Due to the recent popularity of the Deep learning new countries are starting to look like Neu...
Bubble Cup 8 finals F. Bulbo (575F)
weixin_30877227的博客
12-04 138
题意： 给定初始位置，查询n次区间，每次查询前可以花费移动距离的代价来移动， 查询时需要花费当前位置到区间内最近的点的距离，求最小代价。 1<=n<=5000，1<=所有位置<=10^9 题解： 可以用O(n^2)的暴力DP碾过去… 不过实际上可以O(n)贪心。 贪心的想法是比较明显的，就是每次找最近的，需要考虑的就是移动不移动。 比如有多个连续的在当...
图论+DFS——Bubble Cup 9 - Finals [Online Mirror] E
FeBr2的博客
09-12 515
题目链接： http://codeforces.com/contest/717/problem/E 参考链接： http://codeforces.com/contest/717/submission/20538605 分析： 给出n个节点，和n个节点的颜色 1：黑色， -1： 粉红。再给出n-1条边，从1出发，每经过一个节点，节点的颜色将会变成另外一种。求一条路径，将所有的节点都变成黑色。
CodeForces Bubble Cup 11 - Finals [Online Mirror, Div. 2] F题
cloudy_happy的博客
09-23 276
Splitting money time limit per test 1 second memory limit per test 256 megabytes input standard input output standard output After finding and moving to the new planet that supports human lif...
Codeforces VK Cup 2016 - Round 1 (Div. 2 Edition)
热门推荐
A Cube Master
04-01 2万+
A. Bear and Reverse Radewoosh　　按要求计算一下即可。#include <bits/stdc++.h>#define ll long longusing namespace std;int p[111]; int t[111];int main(){ int n,c; cin>>n>>c; for(int i=1;i<=n;i++){
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值