JOI 2020 Final 题解

最新推荐文章于 2021-11-16 17:25:31 发布
最新推荐文章于 2021-11-16 17:25:31 发布
阅读量1.8k 收藏 1
点赞数
分类专栏： 合辑
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/rose_max/article/details/104282428
版权

前言

好久没更。来更一篇
竟然直接ak了…

loj#3252. 「JOI 2020 Final」只不过是长的领带

考虑去除后的匹配方式，将两个序列排序

注意到如果存在 i < j i<j i<j满足匹配的位置 c i > c j c_i>c_j ci​>cj​，由于此时满足 b i < b j , a c i > a c j b_i<b_j,a_{c_i}>a_{c_j} bi​<bj​,aci​​>acj​​，所以将两个交换一定不劣

故可以证明直接排序后 b i b_i bi​配对 a i a_i ai​是最优的，预处理前缀后缀 m a x max max即可

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
#include<queue>
#include<vector>
#include<ctime>
#include<map>
#include<bitset>
#include<set>
#define LL long long
#define mp(x,y) make_pair(x,y)
#define pll pair<long long,long long>
#define pii pair<int,int>
using namespace std;
inline LL read()
{
	LL f=1,x=0;char ch=getchar();
	while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
	while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
	return x*f;
}
int stack[20];
template<typename T>inline void write(T x)
{
	if(x<0){putchar('-');x=-x;}
    if(!x){putchar('0');return;}
    int top=0;
    while(x)stack[++top]=x%10,x/=10;
    while(top)putchar(stack[top--]+'0');
}
template<typename T>inline void pr1(T x){write(x);putchar(' ');}
template<typename T>inline void pr2(T x){write(x);putchar('\n');}
const int MAXN=200005;
int a[MAXN],n;pii b[MAXN];
int pre[MAXN],suf[MAXN],ans[MAXN];
int main()
{
	n=read();
	for(int i=1;i<=n+1;i++)b[i]=mp(read(),i);sort(b+1,b+1+n+1);
	for(int i=1;i<=n;i++)a[i]=read();sort(a+1,a+1+n);
	for(int i=1;i<=n;i++)pre[i]=max(pre[i-1],max(b[i].first-a[i],0));
	for(int i=n;i>=1;i--)suf[i]=max(suf[i+1],max(b[i+1].first-a[i],0));
	for(int i=1;i<=n+1;i++)ans[b[i].second]=max(pre[i-1],suf[i]);
	for(int i=1;i<=n+1;i++)pr1(ans[i]);puts("");
	return 0;
}

loj#3253. 「JOI 2020 Final」JJOOII 2

考虑等价于求头尾相距最短的 K K K级 J O I JOI JOI 串，可以考虑使用几个单调指针右移来获得答案

处理一下每个位置作为第 K K K个 J J J，第 2 K 2K 2K个 O O O，第 3 K 3K 3K个 I I I时前面第一个 J J J最近的位置在哪里

所有操作都不难使用单调指针维护

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
#include<queue>
#include<vector>
#include<ctime>
#include<map>
#include<bitset>
#include<set>
#define LL long long
#define mp(x,y) make_pair(x,y)
#define pll pair<long long,long long>
#define pii pair<int,int>
using namespace std;
inline LL read()
{
	LL f=1,x=0;char ch=getchar();
	while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
	while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
	return x*f;
}
int stack[20];
template<typename T>inline void write(T x)
{
	if(x<0){putchar('-');x=-x;}
    if(!x){putchar('0');return;}
    int top=0;
    while(x)stack[++top]=x%10,x/=10;
    while(top)putchar(stack[top--]+'0');
}
template<typename T>inline void pr1(T x){write(x);putchar(' ');}
template<typename T>inline void pr2(T x){write(x);putchar('\n');}
const int MAXN=200005;
char ch[MAXN];
int n,K,f[MAXN];
int main()
{
	n=read();K=read();scanf("%s",ch+1);
	for(int i=1,cnt=0,j=0;i<=n;i++)if(ch[i]=='J')
	{
		++cnt;if(cnt==1)j=i;
		if(cnt>K){do{++j;}while(ch[j]!='J');--cnt;}
		if(cnt==K)f[i]=j;
	}
	for(int i=1,cnt=0,j=0,mx=0;i<=n;i++)if(ch[i]=='O')
	{
		++cnt;if(cnt==1)while(j!=i)mx=max(mx,f[j++]);
		if(cnt>K)
		{
			do
			{
				++j;
				if(ch[j]=='J')mx=max(mx,f[j]);
			}while(ch[j]!='O');--cnt;
		}if(cnt==K)f[i]=mx;
	}
	for(int i=1,cnt=0,j=0,mx=0;i<=n;i++)if(ch[i]=='I')
	{
		++cnt;
		if(cnt==1)for(;j!=i;++j)if(ch[j]=='O')mx=max(mx,f[j]);
		if(cnt>K)
		{
			do
			{
				++j;
				if(ch[j]=='O')mx=max(mx,f[j]);
			}while(ch[j]!='I');--cnt;
		}if(cnt==K)f[i]=mx;
	}int ans=999999999;
	for(int i=1;i<=n;i++)if(ch[i]=='I'&&f[i]!=0)ans=min(ans,i-f[i]+1-3*K);
	pr2(ans==999999999?-1:ans);
	return 0;
}

loj#3254. 「JOI 2020 Final」集邮比赛 3

拆环为段，考虑做 f l , r , k , 0 / 1 f_{l,r,k,0/1} fl,r,k,0/1​表示已经走完了 [ l , r ] [l,r] [l,r]这一段，中间收获了 k k k个点，并且现在在左端点/右端点的最小时间

转移显然可以 O ( 1 ) O(1) O(1)往两侧扩展，于是复杂度 O ( n 3 ) O(n^3) O(n3)

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
#include<queue>
#include<vector>
#include<ctime>
#include<map>
#include<bitset>
#include<set>
#define LL long long
#define mp(x,y) make_pair(x,y)
#define pll pair<long long,long long>
#define pii pair<int,int>
using namespace std;
inline LL read()
{
	LL f=1,x=0;char ch=getchar();
	while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
	while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
	return x*f;
}
int stack[20];
template<typename T>inline void write(T x)
{
	if(x<0){putchar('-');x=-x;}
    if(!x){putchar('0');return;}
    int top=0;
    while(x)stack[++top]=x%10,x/=10;
    while(top)putchar(stack[top--]+'0');
}
template<typename T>inline void pr1(T x){write(x);putchar(' ');}
template<typename T>inline void pr2(T x){write(x);putchar('\n');}
const int MAXN=205;
int f[2*MAXN][2*MAXN][MAXN][2],n,a[2*MAXN],T[2*MAXN],L;
void chkmin(int &x,int y){x=x<y?x:y;}
int dis(int x,int y){return abs(a[x]-a[y]);}
bool ok(int u,int TT){return T[u]>=TT;}
int main()
{
	memset(f,63,sizeof(f));int INF=f[0][0][0][0];
	n=read();L=read();
	for(int i=1;i<=n;i++)a[i+n]=read(),a[i]=-(L-a[i+n]);
	for(int i=1;i<=n;i++)T[i+n]=T[i]=read();
	for(int i=1;i<=2*n;i++)f[i][i][T[i]>=abs(a[i])][0]=abs(a[i]);
	for(int l=1;l<n;l++)for(int x=1;x+l-1<=2*n;x++)
	{
		int y=x+l-1;
		for(int k=0;k<=l;k++)for(int u=0;u<2;u++)if(f[x][y][k][u]!=INF)
		{
			int now=(u==0?x:y);
			if(x-1&&dis(now,x-1)<=INF)chkmin(f[x-1][y][k+ok(x-1,f[x][y][k][u]+dis(now,x-1))][0],f[x][y][k][u]+dis(now,x-1));
			if(y+1<=2*n&&dis(now,y+1)<=INF)chkmin(f[x][y+1][k+ok(y+1,f[x][y][k][u]+dis(now,y+1))][1],f[x][y][k][u]+dis(now,y+1));
		}
	}
	for(int k=n;k>=0;k--)for(int x=1;x+k-1<=2*n;x++)for(int y=x+k-1;y<=2*n;y++)
		if(f[x][y][k][0]!=INF||f[x][y][k][1]!=INF)
			return pr2(k),0;
	pr2(0);
	return 0;
}

loj#3255. 「JOI 2020 Final」奥运公交

枚举哪条边发生了置换

考虑我们需要求出的是 S → T S\rightarrow T S→T的最短路，可以分为两种来讨论。第一种是必须经过反转的边，第二种是必须不经过翻转的边。对于边 ( x , y , c ) (x,y,c) (x,y,c)，我们需要求出的是 S S S到 y y y不经过 ( x , y , c ) (x,y,c) (x,y,c)的最短路，以及 x x x到 T T T不经过 ( x , y , c ) (x,y,c) (x,y,c)的最短路。还有 S S S直接到 T T T不经过 ( x , y , c ) (x,y,c) (x,y,c)的最短路。考虑使用最短路树来进行计算，显然若一条边不在最短路树上，那么删去他后所有点的最短路不变。否则我们可以直接暴力对整张图跑一次最短路来求的全新的最短路数组

对于 T → S T\rightarrow S T→S的最短路，如上一般讨论即可。由于最短路树边数在 O ( n ) O(n) O(n)级别，所以这个算法的复杂度为 O ( n K ) O(nK) O(nK)，其中 K K K是最短路的复杂度。发现图是稠密图，于是直接跑 O ( n 2 ) O(n^2) O(n2)的 d i j k s t r a dijkstra dijkstra即可在 O ( n 3 ) O(n^3) O(n3)的时间内解决这个问题

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
#include<queue>
#include<vector>
#include<ctime>
#include<map>
#include<bitset>
#include<set>
#define LL long long
#define mp(x,y) make_pair(x,y)
#define pll pair<long long,long long>
#define pii pair<int,int>
using namespace std;
inline LL read()
{
	LL f=1,x=0;char ch=getchar();
	while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
	while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
	return x*f;
}
int stack[20];
template<typename T>inline void write(T x)
{
	if(x<0){putchar('-');x=-x;}
    if(!x){putchar('0');return;}
    int top=0;
    while(x)stack[++top]=x%10,x/=10;
    while(top)putchar(stack[top--]+'0');
}
template<typename T>inline void pr1(T x){write(x);putchar(' ');}
template<typename T>inline void pr2(T x){write(x);putchar('\n');}
const int MAXN=205;
const int INF=1e9;
int n,m;
struct edge{int x,y,c,d,next;}E[2*MAXN*MAXN];
struct Graph2
{
	edge a[2*MAXN*MAXN];int len,last[MAXN];
	int dist[MAXN],vis[MAXN],prek[MAXN],is[2*MAXN*MAXN];
	void ins(int x,int y,int c,int d){len++;a[len].x=x;a[len].y=y;a[len].c=c;a[len].d=d;a[len].next=last[x];last[x]=len;}
	void dij(int S)
	{
		memset(dist,63,sizeof(dist));dist[S]=0;
		for(int T=1;T<=n;T++)
		{
			int x=0;for(int i=1;i<=n;i++)if(!vis[i]&&(!x||dist[i]<dist[x]))x=i;vis[x]=1;
			for(int k=last[x];k;k=a[k].next)
			{
				int y=a[k].y;
				if(dist[y]>dist[x]+a[k].c)dist[y]=dist[x]+a[k].c,prek[y]=k;
			}
		}
		for(int i=1;i<=n;i++)is[prek[i]]=1;
	}
}G1,G2,G3,G4;
struct Graph1
{
	vector<pii> vec[MAXN];
	int dist[MAXN],vis[MAXN];
	void init(){for(int i=1;i<=n;i++)vec[i].clear(),dist[i]=INF,vis[i]=0;}
	void ins(int x,int y,int c){vec[x].emplace_back(mp(y,c));}
	void dij(int S)
	{
		dist[S]=0;
		for(int T=1;T<=n;T++)
		{
			int S=0;for(int i=1;i<=n;i++)if(!vis[i]&&(!S||dist[i]<dist[S]))S=i;
			vis[S]=1;for(auto p:vec[S])dist[p.first]=min(dist[p.first],dist[S]+p.second);
		}
	}
}newG1,newG2,newG3,newG4;
int work1(int id)
{
	if(!G1.is[id])return 1;
	newG1.init();
	for(int i=1;i<=m;i++)if(i!=id)newG1.ins(E[i].x,E[i].y,E[i].c);
	newG1.dij(1);return 5;
}
int work2(int id)
{
	if(!G2.is[id])return 2;
	newG2.init();
	for(int i=1;i<=m;i++)if(i!=id)newG2.ins(E[i].y,E[i].x,E[i].c);
	newG2.dij(n);return 6;
}
int work3(int id)
{
	if(!G3.is[id])return 3;
	newG3.init();
	for(int i=1;i<=m;i++)if(i!=id)newG3.ins(E[i].y,E[i].x,E[i].c);
	newG3.dij(1);return 7;
}
int work4(int id)
{
	if(!G4.is[id])return 4;
	newG4.init();
	for(int i=1;i<=m;i++)if(i!=id)newG4.ins(E[i].x,E[i].y,E[i].c);
	newG4.dij(n);return 8;
}
int gi(int o,int x)
{
	if(o==1)return G1.dist[x];
	else if(o==2)return G2.dist[x];
	else if(o==3)return G3.dist[x];
	else if(o==4)return G4.dist[x];
	else if(o==5)return newG1.dist[x];
	else if(o==6)return newG2.dist[x];
	else if(o==7)return newG3.dist[x];
	else return newG4.dist[x];
}
int main()
{
	n=read();m=read();
	for(int i=1;i<=m;i++)E[i].x=read(),E[i].y=read(),E[i].c=read(),E[i].d=read();
	for(int i=1;i<=m;i++)
	{
		G1.ins(E[i].x,E[i].y,E[i].c,E[i].d);//1正 
		G2.ins(E[i].y,E[i].x,E[i].c,E[i].d);//n反 
		G3.ins(E[i].y,E[i].x,E[i].c,E[i].d);//1反 
		G4.ins(E[i].x,E[i].y,E[i].c,E[i].d);//n正 
	}G1.dij(1);G2.dij(n);G3.dij(1);G4.dij(n);LL ans=G1.dist[n]+G4.dist[1];
	for(int i=1;i<=m;i++)
	{
		int f1=work1(i),f2=work2(i),f3=work3(i),f4=work4(i);
		LL D1=min(gi(f1,n),gi(f1,E[i].y)+gi(f2,E[i].x)+E[i].c);
		LL D2=min(gi(f4,1),gi(f4,E[i].y)+gi(f3,E[i].x)+E[i].c);
		ans=min(ans,D1+D2+E[i].d);
	}if(ans<=INF)pr2(ans);
	else pr2(-1);
	return 0;
}

loj#3256. 「JOI 2020 Final」火灾

考虑我们维护每个人在每一时间段会变为什么。那么如果从 i i i变到 i + 1 i+1 i+1，这个会如何变化

如果将是什么划为序列 T T T，那么相当于先将所有 T i T_i Ti​向后移动一位，然后所有位置对 a i a_i ai​取 m a x max max

不难发现取 m a x max max的一定是一段前缀，所以可以考虑使用单调栈维护。这样询问是单点的东西我们就会做了。但是发现我们需要是询问一段区间，还需要将每个东西的 T T T序列给直接求和起来…似乎十分的不可做

先将询问拆分为 ( l − 1 , T ) (l-1,T) (l−1,T)与 ( r , T ) (r,T) (r,T)，此时显然只需要将一个前缀的 T T T序列求和起来再单点求值即可。问题在于这个求和。发现对于一段极长相同区间 ( l , r , T i ) (l,r,T_i) (l,r,Ti​)，假设他在此后的任意时刻均不会被覆盖的话，假定在某个时刻他移动到了某个 i i i的后面，那么对于这个原本 i > r i>r i>r的位置的贡献显然是 ( r − l + 1 ) × T i (r-l+1)\times T_i (r−l+1)×Ti​，已经在区间中的贡献则为 ( i − l + 1 ) × T i (i-l+1)\times T_i (i−l+1)×Ti​

所以我们考虑先给后面把贡献全部给算上了，在询问的时候减去所有还没有经过我这个地方的贡献。不难发现显然是连续一段的 ( r i − l i + 1 ) × T i (r_i-l_i+1)\times T_i (ri​−li​+1)×Ti​与一段的 ( i − l i + 1 ) × T i (i-l_i+1)\times T_i (i−li​+1)×Ti​

于是可以考虑使用维护所有位置不乘 i i i的所有系数和与乘上 i i i的所有系数和，在 p o p pop pop掉一段区间的时候直接将他对于后面的贡献全部减掉即可。所有操作都可以视作区间加与单点求值，可以使用树状数组差分后在小常数 n log ⁡ n n\log n nlogn的时间内解决这个问题

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
#include<queue>
#include<vector>
#include<ctime>
#include<map>
#include<bitset>
#include<set>
#define LL long long
#define mp(x,y) make_pair(x,y)
#define pll pair<long long,long long>
#define pii pair<int,int>
using namespace std;
inline LL read()
{
	LL f=1,x=0;char ch=getchar();
	while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
	while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
	return x*f;
}
int stack[20];
template<typename T>inline void write(T x)
{
	if(x<0){putchar('-');x=-x;}
    if(!x){putchar('0');return;}
    int top=0;
    while(x)stack[++top]=x%10,x/=10;
    while(top)putchar(stack[top--]+'0');
}
template<typename T>inline void pr1(T x){write(x);putchar(' ');}
template<typename T>inline void pr2(T x){write(x);putchar('\n');}
const int MAXN=200005;
struct ask
{
	int T,o,id;ask(){}
	ask(int _T,int _o,int _id){T=_T;o=_o;id=_id;}
};
vector<ask> vec[MAXN];
int n,m;
struct bittree
{
	LL bit[MAXN];
	int lowbit(int x){return x&-x;}
	void modify(int x,LL c){for(;x<=n;x+=lowbit(x))bit[x]+=c;}
	LL qry(int x){LL ret=0;for(;x>=1;x-=lowbit(x))ret+=bit[x];return ret;}
	void add(int l,int r,LL val){modify(l,val);modify(r+1,-val);}
}bi[2];//0 no*i 1 *i 
int a[MAXN];LL answer[MAXN];
int sta[MAXN],tp,L[MAXN],R;LL pres[MAXN];
void pop()
{
	int fl=L[tp]+R,fr=min(n,L[tp-1]-1+R);
	if(fl>n)return ;
	bi[0].add(fr+1,n,1LL*-(fr-fl+1)*sta[tp]);
	bi[0].add(fl,fr,1LL*(fl-1)*sta[tp]);bi[1].add(fl,fr,-sta[tp]);
}
int main()
{
	n=read()+1;m=read();
	for(int i=1;i<n;i++)a[i]=read();
	for(int i=1;i<=m;i++)
	{
		int T=read()+1,l=read(),r=read();
		vec[r].emplace_back(ask(T,1,i));vec[l-1].emplace_back(ask(T,-1,i));
	}L[0]=n+1;
	for(int i=1;i<n;i++)
	{
		while(tp&&sta[tp]<=a[i])pop(),--tp;
		if(!tp)
		{
			++tp;L[tp]=1-R;L[0]=n+1-R;sta[tp]=a[i];
			bi[1].add(1,n,sta[tp]);pres[tp]=1LL*n*sta[i];
		}
		else
		{
			int fl,fr;
			++tp;L[tp]=1-R;sta[tp]=a[i];
			fl=L[tp]+R,fr=min(n,L[tp-1]-1+R);
			bi[0].add(fr+1,n,1LL*(fr-fl+1)*sta[tp]);
			bi[0].add(fl,fr,1LL*-(fl-1)*sta[tp]);bi[1].add(fl,fr,sta[tp]);
			pres[tp]=pres[tp-1]+1LL*(L[tp-1]-L[tp])*sta[tp];
		}
		for(auto p:vec[i])
		{
			LL u1=bi[0].qry(p.T),u2=1LL*bi[1].qry(p.T)*p.T;
			int l=1,r=tp,num=-1;
			while(l<=r)
			{
				int mid=(l+r)/2;
				if(L[mid]+R<=p.T)num=mid,r=mid-1;
				else l=mid+1;
			}
			u1+=u2;
			u1-=pres[tp]-pres[num];u1-=1LL*(p.T-(L[num]+R))*sta[num];
			answer[p.id]+=u1*p.o;
		}++R;
	}
	for(int i=1;i<=m;i++)pr2(answer[i]);
	return 0;
}
Rose_max
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SSL集训 2021.07.19 提高B组 T3 「JOI 2020 Final」只不过是长的领带【贪心】
JA_yichao欢迎你 cnblogs账号：https://www.cnblogs.com/mayichao/
07-19 106
SSL集训
P7404 [JOI 2021 Final] とてもたのしい家庭菜園 4
weixin_46709784的博客
06-03 323
难度：3 看完李煜东书上的差分，来找了一道题来做，首先就是把序列上的区间操作转化为差分序列上的两点操作，然后它的题意，就是说找一个点，令左边，包含这个点，都是正数，这样左边递增，令右边都是负数，这样递减， 正好，差分序列的的操作就是一个加，一个减，统计一下，一个点左边至少需要加多少才能全正，统计一下点的右边至少减多少才能全变负，然后扫描一遍，按照下面的那个逻辑统计答案就可以了，然后考虑的时候左右两个端点的值是任意的，不需要复杂考虑 #include <bits/stdc++.h> #defin
LOJ 3252-3256. 「JOI 2020 Final」题解
sz_165394732的博客
03-04 411
题目链接 题解 如果知道那个不选，显然把a和b都降序，依次配对最优。对于每个不选的，答案都是前面一次配对和后面相间配对的最大值，记一下后缀最大值即可。 ...
【题解】LOJ3254：「JOI 2020 Final」集邮比赛 3
ModestCoder_的博客
12-04 360
原题传送门 发现n<=200n<=200n<=200，那么我们就可以想一个O(n3)O(n^3)O(n3)的dp 发现每次肯定是向左/右推进 可以令dp[i][j][k][0/1]dp[i][j][k][0/1]dp[i][j][k][0/1]表示向起点左边推进了iii个，右边推进了jjj个，总共收集到了kkk个邮票，现在在起点左/右边 直接转移 Code： #include <bits/stdc++.h> #define maxn 210 #define LL long lo
[JOI 2020 Final] 長いだけのネクタイ 题解
CMC_YXY的博客
07-19 157
[JOI 2020 Final] 長いだけのネクタイ Description Input Output Sample Input 样例 1 输入： 3 4 3 7 6 2 6 4 样例 2 输入： 5 4 7 9 10 11 12 3 5 7 9 11 Sample Output 样例 1 输出： 2 2 1 1 样例 2 输出： 4 4 3 2 2 2 Data Constraint 题解 好不容易模拟赛有一道签到题 首先可以显然证明，在拿掉一个领带后，将剩下的领带长度从大到小排序，把人本来戴着
【JOI 2020 Final】【LOJ3252】只不过是长的领带（贪心）
zxyoi_dreamer的博客（不定期诈尸）
03-21 332
传送门 全状态康复计划开始，先刷水题找手感 题解： 排序，考虑拿走第 kkk 个的时候前 k−1k-1k−1 个 A,BA,BA,B 一一对应，后面的位移一下对应，记录前后缀最大值即可。 代码： #include<bits/stdc++.h> #define ll long long #define re register #define cs const namespace I...
「JOI 2020 Final」奥运公交 题解
CMC_YXY的博客
07-21 294
「JOI 2020 Final」奥运公交 Description Input Output Sample Input 样例 1 输入： 4 5 1 2 4 4 1 3 2 1 4 3 1 2 4 1 6 1 2 4 2 5 样例 2 输入： 4 10 1 2 4 4 1 2 4 4 1 3 2 1 1 3 2 1 4 3 1 2 4 3 1 2 4 1 6 1 4 1 6 1 2 4 2 5 2 4 2 5 样例 3 输入： 4 4 1 2 0 4 1 3 0 1 4 3 0 2 4 1 0 1 样例
【JOI 2020 Final】【LOJ3256】火灾（扫描线）（树状数组）
zxyoi_dreamer的博客（不定期诈尸）
04-01 701
传送门 题解： 首先容易注意到询问可以查分为前缀询问。 然后注意到询问本质上就是求 [i−T,i][i-T,i][i−T,i] 的最大值之和。 一个比较直接的思路是考虑每个值在答案中出现了多少次，发现不好维护，不过这可以给我们一些启发。 考虑统计每个位置上值的变化量。 构造一个平面直角坐标系，横坐标表示序列中的下标，纵坐标表示时间，每个整点上有一个值表示 Sx(y)S_x(y)Sx​(y)。 初...
「JOI 2018 Final」毒蛇越狱 题解
Cherrt的博客
11-16 404
Description 传送门 Solution 这题神了。 为方便叙述，令 aia_iai​ 表示第 iii 只蛇的毒性，Fi=∑j∈iajF_i=\sum_{j \in i} a_jFi​=∑j∈i​aj​，Gi=∑i∈jajG_i=\sum_{i \in j}a_jGi​=∑i∈j​aj​，其中 x∈yx \in yx∈y 表示 xxx 是 yyy 的子集；令某次询问中 ? 有 xxx 个，0 有 yyy 个，1 有 zzz 个。 Part 1: 暴力 一种朴素的做法是，暴力枚举每个 ? 填上 000
【JOI 2020 Final】【LOJ3254】集邮比赛（DP）
zxyoi_dreamer的博客（不定期诈尸）
03-21 422
传送门 题解： 设 f[l][r][k][0/1]f[l][r][k][0/1]f[l][r][k][0/1] 表示已经经过了 1−l.r−n1-l.r-n1−l.r−n 的所有点，拿到了 kkk 枚邮票，当前停留在 l/rl/rl/r 的最少时间，转移 O(1)O(1)O(1) 即可，可以按长度滚动数组，不过 JOI 不卡常数。 代码（一丁点常数优化都没有的那种）： #include<...
【JOI 2020 Final】【LOJ3253】JJOOII（队列）
zxyoi_dreamer的博客（不定期诈尸）
03-21 511
传送门 题解： 用队列算一下每个位置向后找到哪里有 kkk 个指定字符，然后枚举开头O(1)O(1)O(1) 跳到结尾即可算出中间要删掉多少。 代码： #include<bits/stdc++.h> #define ll long long #define re register #define cs const using std::cerr; using std::cout;...
【题解】LOJ3252：「JOI 2020 Final」只不过是长的领带
ModestCoder_的博客
12-01 331
原题传送门 有一个很显然的贪心思想，都从小到大排序，然后直接两两配对就行了 证明： a<b c<d 一种方案，max(a-c,b-d,0) 另一种,max(a-d,b-c,0)=max(b-c,0) 发现一定是前一种方案更优 然后排好序后，每次就是扔掉一个aia_iai​ 那么配对情况就是 a1 a2 a3…ai-1,ai+1,…,an+1 b1 b2 b3…bi-1,bi,…,bn 对于每个bib_ibi​，求出ai−bi,ai+1−bia_i-b_i,a_{i+1}-b_iai​−b
【JZOJ 杂题选讲】火灾
Brute♂force
03-30 569
题目 题目描述 译自 JOI 2020 Final T5「火事 / Fire」 在 JOI 世界里有 个地区排成一条线。为了方便，我们将这些地区编号为 到 。突然，各个地区都起火了。在时刻 ，第 个区的火势大小为 。 此时（时刻 ），一阵风从 号地区一直吹到了 号地区。对于每两个相邻的地区，如果 时刻上风地区的火势比下风地区的强， 时刻下风地区的火势大小将变为 时刻上风地区的火势，否...
武汉ACM集训——贪心-7
miaomiaopu的blog
07-12 154
武汉ACM集训——贪心-7 洛谷 P6878 [JOI 2020 Final] JJOOII 2 题解 首先将字符串中各字母的下标按照字母种类分类存储。 接着依次遍历字母 J, O, I 当符合情况时，存储数据。 ans = min{ (右下标 - 左下标 + 1) - (3 x K) } AC代码 #include <bits/stdc++.h> using namespace std; const int maxn = 2e5 + 5; #define inf 0x3f3f3f3f int
2020全国高校计算机能力挑战赛C++决赛代码分享
RealCoder的博客
12-20 1217
样例均过 1.模拟 #include<iostream> #include<string> #include<vector> #include<map> #include<set> #include<stack> #include<unordered_map> #include<unordered_set> #include<algorithm> #include<iomanip> usi
【JOI 2020 Final】【LOJ3255】奥运公交（最短路）
zxyoi_dreamer的博客（不定期诈尸）
04-01 386
传送门 题解： 直接跑最短路，然后考虑翻转每一条边之后怎么快速算代价。 显然如果这条边不在 1−n1-n1−n 或者 n−1n-1n−1 的最短路上，直接考虑强行走过这条边的最短路就行了，可以通过记录最短路和次短路（要求前驱不同的最短路）来实现。 否则，这样的边只有 O(n)O(n)O(n) 条，直接重新跑 Dijkstra 即可。 由于图非常稠密，不用堆优化还好一点。 代码： #includ...
JOI 2018 Final 简要题解
Entropy Increaser 的博客
02-22 1097
题面见 https://loj.ac/problems/tag/196,205 T1 寒冬暖炉 考虑每两个客人之间的时间间隔 ΔTi−1\Delta T_i - 1ΔTi​−1，这 n−1n-1n−1 个关闭暖炉的机会中只能选择 n−kn - kn−k 个，故选择最大的 n−kn-kn−k 个。用 nth_element 即可 Θ(n)\Theta(n)Θ(n)。 #include &amp;lt;cst...
nodejs joi
最新发布
10-11
Joi 是一个用于 JavaScript 的强大的对象模型验证库。它可以用来验证和转换复杂的数据结构，如表单输入、API 请求和配置文件。Joi 提供了一组强大的验证规则和函数，可以轻松定义和应用对输入数据的验证逻辑。 Joi ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值