Comet OJ - Contest #14

最新推荐文章于 2021-10-19 21:09:28 发布
最新推荐文章于 2021-10-19 21:09:28 发布
阅读量129 收藏
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Deep_Kevin/article/details/103016455
版权

正题

      我好菜啊第二题都可以调40分钟。

      Portal

      A

      这题很简单，暴力即可。

#include<bits/stdc++.h>
using namespace std;

int n;
long long a,b,r;

int main(){
	scanf("%d %lld %lld %lld",&n,&a,&b,&r);r*=r;
	long long x,y;
	int tot=0;
	for(int i=1;i<=n;i++){
		scanf("%lld %lld",&x,&y);
		if((x-a)*(x-a)+(y-b)*(y-b)<=r) tot++;
 	}
 	printf("%d\n",tot);
}

      B

      这题好烦啊，脑子非常乱，主要的做法就是找到一个三号点看一下最前面的两个点位置在哪里，最大化[2,3]两点的距离，或者找到一个四号点，看一下最前面的三个点在哪里，或者最大化[1,2]的距离，具体自己看看吧，写麻烦了。

#include<bits/stdc++.h>
using namespace std;

const int N=1000010;
int n,T;
char s[N];
int last[N][4],pre[N][4],ans;

int main(){
	scanf("%d",&T);
	while(T--){
		scanf("%d",&n);
		scanf("%s",s+1);ans=-1;
		last[0][0]=last[0][1]=last[0][2]=last[0][3]=0;
		pre[n+1][0]=pre[n+1][1]=pre[n+1][2]=pre[n+1][3]=0;
		for(int i=1;i<=n;i++){
			last[i][0]=last[i-1][0];last[i][1]=last[i-1][1];
			last[i][2]=last[i-1][2];last[i][3]=last[i-1][3];
			if(s[i]=='p' && !last[i][0]) last[i][0]=i;
			else if(s[i]=='i' && !last[i][1] && last[i][0]) last[i][1]=i;
			else if(s[i]=='n' && !last[i][2] && last[i][1]) last[i][2]=i;
			else if(s[i]=='k' && !last[i][3] && last[i][2]) last[i][3]=i;
		}
		for(int i=n;i>=1;i--){
			pre[i][0]=pre[i+1][0];pre[i][1]=pre[i+1][1];
			pre[i][2]=pre[i+1][2];pre[i][3]=pre[i+1][3];
			if(s[i]=='p' && !pre[i][0] && pre[i][1]) pre[i][0]=i;
			else if(s[i]=='i' && !pre[i][1] && pre[i][2]) pre[i][1]=i;
			else if(s[i]=='n' && !pre[i][2] && pre[i][3]) pre[i][2]=i;
			else if(s[i]=='k' && !pre[i][3]) pre[i][3]=i;
		}
		for(int i=1;i<=n;i++) 
			if(s[i]=='i' && last[i][0] && pre[i][2]) ans=max(ans,max(i-last[i][0]-1,pre[i][2]-i-1));
			else if(s[i]=='n' && last[i][1] && pre[i][3]) ans=max(ans,max(i-last[i][1]-1,pre[i][3]-i-1));
		printf("%d\n",ans);
	}
}

      C

      要是考场上没想出来就亏大了，首先我们考虑加入一个区间会使得在l这个位置上有一个开头，在r+1位置上会多出来一个开头，并且把[l,r+1]这段的所有开头都去掉，所以我们把一个区间画成一条[l,r+1]的线段和l,r+1两个黑点，那么最后的权值就是从上往下看，黑点的个数，除了第n+1位，注意，一开始就有询问[1,n]。那么一个黑点产生贡献当且仅当不选那些比它晚并且覆盖它的询问。容易发现暴力即可。

#include<bits/stdc++.h>
using namespace std;

int n,m;
long long ans=1;
struct interval{
	int x,y;
	long long t1,t2;
}p[2010];
const long long mod=20050321;

int main(){
	scanf("%d %d",&n,&m);
	p[0].t1=1;p[0].x=1;
	long long tot=1;
	for(int i=1;i<=m;i++){
		scanf("%d %d",&p[i].x,&p[i].y);p[i].y++;
		(ans+=tot)%=mod;p[i].t1=tot;
		if(p[i].y<=n) (ans+=tot)%=mod,p[i].t2=tot;
		for(int j=0;j<i;j++){
			if(p[j].x<p[i].x || p[i].y<p[j].x) (ans+=p[j].t1)%=mod,(p[j].t1*=2)%=mod;
			if(p[j].y<p[i].x || p[i].y<p[j].y) (ans+=p[j].t2)%=mod,(p[j].t2*=2)%=mod;
		}
		(tot*=2)%=mod;
		printf("%lld\n",ans);
	}
}

      D

      首先考虑不断加入一个区间，并且把它覆盖，区间的交的和是O(n)的，考虑一次加入最多新产生两个区间就可以了。

      考虑把询问按右端点时间从小到大排序。

      我们对于一个每一个区间的交，记录一下上次覆盖这个位置是什么时候，单点加就好了，在那个时间减去原本的贡献，在这个时间加上新的贡献就好了，容易证明这个是正确的。

      可惜的就是第二题花太多时间了导致这一题晚了8分钟AC。

#include<bits/stdc++.h>
#define ls now<<1
#define rs now<<1|1
using namespace std;

const int N=500010;
struct interval{
	int x,y,c,id;
	bool operator<(const interval q)const{
		return y<q.y;
	}
}p[N],X,Y;
set<interval> S;
set<interval>::iterator it;
long long sum[N*3];
struct ques{
	int x,y,id;
	bool operator<(const ques q)const{
		return y<q.y;
	}
}q[N];
long long ans[N];
int n,m,Q;

void add(int now,int x,long long t,int l,int r){
	sum[now]+=t;
	if(l==r) return ;
	int mid=(l+r)/2;
	if(x<=mid) add(ls,x,t,l,mid);
	else add(rs,x,t,mid+1,r);
}

long long get_sum(int now,int x,int y,int l,int r){
	if(x==l && y==r) return sum[now];
	int mid=(l+r)/2;
	if(y<=mid) return get_sum(ls,x,y,l,mid);
	else if(mid<x) return get_sum(rs,x,y,mid+1,r);
	else return get_sum(ls,x,mid,l,mid)+get_sum(rs,mid+1,y,mid+1,r);
}

int main(){
	scanf("%d %d %d",&n,&m,&Q);
	for(int i=1;i<=n;i++) scanf("%d %d %d",&p[i].x,&p[i].y,&p[i].c);
	for(int i=1;i<=Q;i++) scanf("%d %d",&q[i].x,&q[i].y),q[i].id=i;
	sort(q+1,q+1+Q);
	int now=0;
	S.insert((interval){1,m,0,0});
	for(int i=1;i<=Q;i++){
		while(now<q[i].y){
			now++;
			it=S.lower_bound((interval){0,p[now].x,0,0});
			while(it!=S.end()){
				X=*it;
				if(p[now].y<X.x) break;
				if(X.x<=p[now].x && p[now].y<=X.y){
					S.erase(it);
					if(X.y>p[now].y) S.insert((interval){p[now].y+1,X.y,X.c,X.id});
					if(X.x<p[now].x) S.insert((interval){X.x,p[now].x-1,X.c,X.id});
				}
				else if(p[now].x<=X.x && X.y<=p[now].y) S.erase(it);
				else{
					S.erase(it);
					if(X.x<p[now].x) S.insert((interval){X.x,p[now].x-1,X.c,X.id});
					else S.insert((interval){p[now].y+1,X.y,X.c,X.id});
				}
				if(X.id) add(1,X.id,-1ll*X.c*(min(p[now].y,X.y)-max(p[now].x,X.x)+1),1,n);
				add(1,now,1ll*p[now].c*(min(p[now].y,X.y)-max(p[now].x,X.x)+1),1,n);
				it=S.lower_bound((interval){0,p[now].x,0,0});
			}
			S.insert((interval){p[now].x,p[now].y,p[now].c,now});
		}
		ans[q[i].id]=get_sum(1,q[i].x,q[i].y,1,n);
	}
	for(int i=1;i<=Q;i++) printf("%lld\n",ans[i]);
}

      E

      这题就很简单了，直接缩点DAG上更新答案就可以了。

      只是别忘了Tarjan要用tf标记。

#include<bits/stdc++.h>
using namespace std;

const int N=200010,M=500010;
struct edge{
	int y,next,c;
}s[M];
int first[N],n,m,mmin[N],mmax[N],d1[N],d2[N],T,dfn[N],low[N],op=0,where[N],ans[N],in[N];
int sta[N],top=0,q,len;
bool tf[N];
queue<int> Q;
vector<edge> E[N];
void ins(int x,int y,int c){s[++len]=(edge){y,first[x],c};first[x]=len;}
void inss(int x,int y,int c){E[x].push_back((edge){y,0,c});in[y]++;}

void Tarjan(int x){
	low[x]=dfn[x]=++op;
	sta[++top]=x;tf[x]=true;
	for(int i=first[x];i!=0;i=s[i].next) {
		int y=s[i].y;
		if(!dfn[y]) Tarjan(y),low[x]=min(low[x],low[y]);
		else if(tf[y]) low[x]=min(low[x],dfn[y]);
	}
	if(low[x]==dfn[x]){
		d1[++T]=mmin[T]=1e9,d2[T]=mmax[T]=0;ans[T]=-1e9;
		while(1){
			int now=sta[top];top--;
			where[now]=T;tf[now]=false;
			if(now==x) break;
		}
	}
}

void Top_sort(){
	Q.push(where[1]);
	while(!Q.empty()){
		int x=Q.front();Q.pop();
		for(int i=0;i<E[x].size();i++){
			int y=E[x][i].y,c=E[x][i].c;
			ans[y]=max(ans[y],max(max(d2[y],c)-mmin[x],mmax[x]-min(d1[y],c)));
			ans[y]=max(ans[y],max(d2[y]-c,c-d1[y]));
			ans[y]=max(ans[y],max(ans[x],0));
			mmax[y]=max(mmax[y],max(c,mmax[x]));
			mmin[y]=min(mmin[y],min(c,mmin[x]));
			in[y]--;
			if(!in[y]) Q.push(y);
		}
	}
}

int main(){
	scanf("%d %d %d",&n,&m,&q);
	int x,y,c;ans[0]=-1e9;
	for(int i=1;i<=m;i++){scanf("%d %d %d",&x,&y,&c);ins(x,y,c);};
	Tarjan(1);
	for(x=1;x<=n;x++) if(dfn[x])
		for(int i=first[x];i!=0;i=s[i].next) 
			if(where[s[i].y]!=where[x]) inss(where[x],where[s[i].y],s[i].c);
			else d1[where[x]]=mmin[where[x]]=min(mmin[where[x]],s[i].c),d2[where[x]]=mmax[where[x]]=max(mmax[where[x]],s[i].c),ans[where[x]]=max(ans[where[x]],mmax[where[x]]-mmin[where[x]]);
	Top_sort();
	while(q--){
		scanf("%d",&x);
		if(ans[where[x]]==-1e9) printf("-1\n");
		else printf("%d\n",ans[where[x]]);
	}
}

      F

      有两种思路，一种就是按题解所说的，用一棵可持久化线段树优化建边，在开始的时候加入一个原节点，在结束的时候加入一个无用的节点就可以了，然后剩下的就是Tarjan找割点。

      我的想法就是把一条横线段看成[r,x]-[l+n,x]，然后一个竖线段相当于向[x,l]-[x+n,r]的横线段连边，具体就是建两棵KDT就可以了，时间复杂度垃圾了一些O(n\sqrt n)

      没代码。

     

Deep_Kevin
关注
【Comet OJ - Contest #14 E 飞翔的小鸟】【图论】
beginend
11-12 237
题意 给一个nnn个点mmm条边的有向图，对每个点xxx求从111到xxx的所有路径中边权极差最大是多少。 n≤200000,m≤500000n\le200000,m\le500000n≤200000,m≤500000 分析 先缩点，这样新图里的点也有了点权。 假设先经过最小值再经过最大值，那么枚举经过最大值之前经过的最后一条边，预处理fxf_xfx​表示走到xxx经过的最大权值，就可以知道每一条...
[Comet OJ - Contest #6 E]字符串
时光真疯狂, 我一路执迷于匆忙.
07-11 350
Description 给出一个长度为n的字符串S，定义f(S)为S的所有n∗(n+1)/2n*(n+1)/2n∗(n+1)/2个子串，两两求LCP的和 对于每个i，求出f(S[i…n])，答案对998244353取模 n<=200000 Solution log^2的做法有很多这里就不一一说了 数据结构学傻了.jpg 先考虑两个后缀l和r的所有前缀互相匹配的答案，显然只和后缀长度和LCP有...
[Comet OJ - Contest #6 ]简要题解？
时光真疯狂, 我一路执迷于匆忙.
06-29 547
图游戏 n-1-m的奇偶性 #include <cstdio> #include <cstring> #include <algorithm> #define fo(i,a,b) for(int i=a;i<=b;i++) #define fd(i,a,b) for(int i=a;i>=b;i--) using namespace std; in...
Comet OJ - Contest #8 符文能量
newhonor
08-10 323
https://www.cometoj.com/contest/58/problem/C?problem_id=2760 思路：手动模拟发现无论从哪里开始结果一样； dp[i][j][k]表示第i个元组j（0/1）变不变化，k表示变化的连续段次数（0/1）； #include <iostream> #include <cstring> #include <a...
Comet OJ - Contest #4（数论+推公式）
without的博客
05-26 325
PS：做这道题的时候开始公式推错了，就一直wrong，哎，还是太菜了。 题解： #include <cstdio> using int64 = long long; int main() { int T; scanf("%d", &T); for (int cas = 1; cas <= T; ++cas) { int64 l, r, k; ...
Comet OJ(Contest #14)-飞翔的小鸟【tarjan】
QuantAsk
10-19 166
正题 题目链接:https://www.cometoj.com/contest/73/problem/E?problem_id=4124 题目大意 给出nnn个点mmm条边的一张有向图，边有边权，qqq次询问从点111走到点xxx的所有路径（可以重复经过任何点包括点xxx）中极差最大是多少。 1≤n≤2×105,1≤m≤5×1051\leq n\leq 2\times 10^5,1\leq m\leq 5\times 10^51≤n≤2×105,1≤m≤5×105 解题思路 首先肯定要tarjantar
Comet OJ(Contest #8)-C符文能量【dp】
QuantAsk
08-10 284
正题 题目链接:https://cometoj.com/contest/58/problem/C?problem_id=2760 题目大意 若干个数对(ai,bi)(a_i,b_i)(ai​,bi​)，总价值为 ∑i=1n−1bi∗ai+1\sum_{i=1}^{n-1}b_i*a_{i+1}i=1∑n−1​bi​∗ai+1​ 然后可以选择一段区间的二元组将(ai,bi)(a_i,b_i)(ai...
Comet OJ - Contest #1
weixin_30621919的博客
04-18 86
　　A：随便怎么暴力。 #include<bits/stdc++.h> using namespace std; #define ll long long #define N 25 char getc(){char c=getchar();while (c!='.'&&c!='#') c=getchar();return c;} int gcd(int ...
Comet OJ - Contest #0 D 战术安排 dfs
Reflect的博客
04-06 260
https://www.cometoj.com/contest/34/problem/D?problem_id=1476 思路： 为了预防超时（虽然感觉直接写dfs并不会超时），可以有以下两个剪枝： 1.若已知当前情况肯定不会比之前得到的最优答案更优，剪枝 2.可行性剪枝 0≤x,y,z≤180 两个点需要注意： 1.若第1题ab一起做60min，第二题bc一起做60min，第三题ac...
Comet OJ - Contest #14 (D,E,F)
这个博客已经搬到了：zhongyuwei.github.io
11-11 215
D - 转转的数据结构题 题意 有一个长度为mmm的整数序列。初始所有元素都是000。 有一个长度为nnn的操作序列，每个操作形如(l,r,v)(l,r,v)(l,r,v)，表示将序列中的下标在[l,r][l,r][l,r]的元素的值赋为vvv。 有qqq次询问，每次给出x,yx,yx,y，表示只进行编号在[x,y][x,y][x,y]的操作所得到的序列的所有元素的和。询问之间是独立的。 n,m,...
Comet OJ - Contest #5 迫真树 长链剖分
beginend
06-27 283
题意 给一棵n个节点的树，点有点权，要求选出若干个点，使得这些点的权值和不超过m且删掉这些点后森林的直径最小。 n≤105n\le10^5n≤105 分析 很容易想到二分答案后dp，设fx,if_{x,i}fx,i​表示节点x为根的子树，满足子树内的直径不超过二分的答案mid，且从x开始的最长链长度为i的方案。 合并子树的时候，讨论加入新子树后是否更新从x出发的最长链来转移即可。 发现i的数量级为...
【Comet OJ - Contest #15 E 栈的数据结构题】【离线+线段树】
beginend
11-23 243
题意 有nnn个栈，编号为111到nnn，有以下三种操作： 1、对编号在[l,r][l,r][l,r]中的每个栈执行push(v)push(v)push(v)操作。 2、对编号为[l,r][l,r][l,r]中的每个栈执行pop()pop()pop()操作。 3、查询某个栈中从栈顶开始第kkk个元素。 n,q≤2∗105n,q\le2*10^5n,q≤2∗105 分析 注意到对于某个询问，找到在它...
Comet OJ - Contest #3——棋盘
不想起标题
10-13 96
题目链接 题目描述 小猫有一个 2\times N2×N 的棋盘，每一个格子放着一个黑棋子或白棋子。 小熊觉得小猫的棋盘不够好看，想要把棋盘上的一部分白棋子替换成黑棋子，使得所有黑棋子都能够在仅允许上下左右四个方向走，且仅经过黑棋子在的格子的情况下两两互相到达。 小熊想知道至少要将多少个白棋子替换成黑棋子。 注意：不能将黑棋子替换成白棋子。 输入描述 第一行有一个正整数 NN (1 \le N \...
【Comet OJ - Contest #15 G 孤独的吉姆 6】【图论】
beginend
11-23 375
题意 给一个nnn个点mmm条边的简单无向连通图，要删掉一些边，使得度数为奇数的点尽可能多。输出长度为mmm的010101串，000表示删掉第iii条边，111表示不删，要求输出字典序最大的方案。 n≤6∗105,m≤9∗105n\le6*10^5,m\le9*10^5n≤6∗105,m≤9∗105 分析 比赛结束后几分钟调过了这题，错失了AK的大好机会。 对于两个能够互相到达的点，我们可以通过对...
win64 CC2022.zip
09-21
SmartTools InDesign插件
深度学习课程的课程设计-------基于ResNet优化模型的阿尔茨海默症的识别.zip
09-21
深度学习是机器学习的一个子领域，它基于人工神经网络的研究，特别是利用多层次的神经网络来进行学习和模式识别。深度学习模型能够学习数据的高层次特征，这些特征对于图像和语音识别、自然语言处理、医学图像分析等应用至关重要。以下是深度学习的一些关键概念和组成部分： 1. **神经网络（Neural Networks）**：深度学习的基础是人工神经网络，它是由多个层组成的网络结构，包括输入层、隐藏层和输出层。每个层由多个神经元组成，神经元之间通过权重连接。 2. **前馈神经网络（Feedforward Neural Networks）**：这是最常见的神经网络类型，信息从输入层流向隐藏层，最终到达输出层。 3. **卷积神经网络（Convolutional Neural Networks, CNNs）**：这种网络特别适合处理具有网格结构的数据，如图像。它们使用卷积层来提取图像的特征。 4. **循环神经网络（Recurrent Neural Networks, RNNs）**：这种网络能够处理序列数据，如时间序列或自然语言，因为它们具有记忆功能，能够捕捉数据中的时间依赖性。 5. **长短期记忆网络（Long Short-Term Memory, LSTM）**：LSTM 是一种特殊的 RNN，它能够学习长期依赖关系，非常适合复杂的序列预测任务。 6. **生成对抗网络（Generative Adversarial Networks, GANs）**：由两个网络组成，一个生成器和一个判别器，它们相互竞争，生成器生成数据，判别器评估数据的真实性。 7. **深度学习框架**：如 TensorFlow、Keras、PyTorch 等，这些框架提供了构建、训练和部署深度学习模型的工具和库。 8. **激活函数（Activation Functions）**：如 ReLU、Sigmoid、Tanh 等，它们在神经网络中用于添加非线性，使得网络能够学习复杂的函数。 9. **损失函数（Loss Functions）**：用于评估模型的预测与真实值之间的差异，常见的损失函数包括均方误差（MSE）、交叉熵（Cross-Entropy）等。 10. **优化算法（Optimization Algorithms）**：如梯度下降（Gradient Descent）、随机梯度下降（SGD）、Adam 等，用于更新网络权重，以最小化损失函数。 11. **正则化（Regularization）**：技术如 Dropout、L1/L2 正则化等，用于防止模型过拟合。 12. **迁移学习（Transfer Learning）**：利用在一个任务上训练好的模型来提高另一个相关任务的性能。 深度学习在许多领域都取得了显著的成就，但它也面临着一些挑战，如对大量数据的依赖、模型的解释性差、计算资源消耗大等。研究人员正在不断探索新的方法来解决这些问题。
机械设计课程设计说明书_带式输送机传送装置_西北工业大学.doc
最新发布
09-21
机械设计课程设计说明书_带式输送机传送装置_西北工业大学.doc
风格化欧洲城镇建筑场景模型：Modular European Town v1.1
09-21
使用 “模块化欧洲小镇” 包来改变你的游戏世界！这个套装提供了你设计一个充满活力的低多边形城市所需的一切。 套装包括： 模块化建筑：各种结构可创造多样化的建筑设计。 自然元素：树木、灌木丛和植物，以增加你的小镇的绿色景观。 基础设施：道路、人行道、边界和墙壁，以构建一个逼真的布局。 不同的道具：很多物品，如消防栓、路灯、咖啡馆桌椅、垃圾桶、长椅等等。 所有模型都采用低多边形美学制作，确保出色的性能和独特的视觉风格。这个套装非常适合所有平台上的游戏：移动设备、桌面电脑和虚拟现实。它易于使用且高度可定制，让你轻松构建自己独特的欧洲风格小镇。用 “模块化欧洲小镇” 将你的愿景变为现实！（解释说明：“lowpoly” 即低多边形，是一种在游戏和数字艺术中常用的风格，以较少的多边形数量来呈现模型，通常具有简洁的外观和较好的性能表现。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值