noip 2018 模拟赛18

最新推荐文章于 2024-04-01 23:03:43 发布
最新推荐文章于 2024-04-01 23:03:43 发布
阅读量316 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 离线赛-总结 文章标签： 组合数 高精度 树的直径 基环树 线段树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Caristra/article/details/83855342
本文精选三道算法竞赛题目，包括求特定二进制数、构造最小树直径及寻找图中最佳点，深入解析题意，提供高效算法解决方案，涵盖组合数、树形结构与环图处理等核心技巧。

T1T_1T1​——num(2032）

Description:
求第nnn个刚好有kkk个111的二进制正整数。
n≤1030,2≤k≤20n\le10^{30},2\le k\le20n≤1030,2≤k≤20，答案长度不超过100010001000

Solution:

  • 比较常规的组合数，对于每一位iii，我们判断Cn−1i−1C_{n-1}^{i-1}Cn−1i−1​是否大于当前的值即可。
  • 再套一个高精度。

Code:

#include<bits/stdc++.h>
using namespace std;
#define REP(i,f,t) for(int i=(f),i##_end_=(t);i<=i##_end_;++i)
#define SREP(i,f,t) for(int i=(f),i##_end_=(t);i<i##_end_;++i)
#define DREP(i,f,t) for(int i=(f),i##_end_=(t);i>=i##_end_;--i)
#define ll long long
template<class T>inline bool chkmin(T&x,T y){return x>y?x=y,1:0;}
template<class T>inline bool chkmax(T&x,T y){return x<y?x=y,1:0;}
template<class T>inline void rd(T&x){
	x=0;char c;
	while((c=getchar())<48);
	do x=(x<<1)+(x<<3)+(c^48);
	while((c=getchar())>47);
}

const int N=302;

int K;

#define L 255
#define P 10000
 
struct Big{
    int num[L],len;
    Big(){
        memset(num,0,sizeof(num));
        len=1;
    }
    void Rd(){
        char A[N];
        scanf("%s",A);
        int SL=strlen(A);
        len=0;
        for(int i=SL-1,res;res=0,i>=0;num[len++]=res,i-=4){
            if(i>=3)for(int j=i-3;j<=i;j++)res=(res<<1)+(res<<3)+(A[j]^48);
            else for(int j=0;j<=i;j++)res=(res<<1)+(res<<3)+(A[j]^48);
        }
    }
    void Pr(){
      	if(!num[len-1]){putchar("0");return;}
        printf("%d",num[len-1]);
        DREP(i,len-2,0)printf("%04d",num[i]);       
    }
    Big operator +(const Big &a)const{
        Big b;
        b.len=max(len,a.len);
        REP(i,0,b.len-1){
            int &B=b.num[i];
            B+=num[i]+a.num[i];
            if(B>=P)B-=P,b.num[i+1]++;
        } 
        if(b.num[b.len])b.len++;
        return b;
    }
    Big operator+(int a){
        Big b;
        b.len=len;
        REP(i,0,len-1){
            int &B=b.num[i];
            B+=num[i]+a%P;
            if(B>=P)b.num[i+1]++,B-=P;
            a/=P;
        }
        if(b.num[b.len])b.len++;
        return b;
    }
    bool operator<=(const Big &a)const{
        if(len!=a.len)return len<a.len;
        DREP(i,len-1,0) if(num[i]!=a.num[i]) return num[i]<a.num[i];
        return 1;
    }
}n,now,tmp,C[N][22];
int pos[30];

int get(int k){
	for(int i=k;;i++){
		tmp=C[i-1][k-1];
		if(n<=now+tmp) return i;
		else now=now+tmp;
	}
}

int main(){
//	freopen("num.in","r",stdin);
//	freopen("num.out","w",stdout);
	n.Rd();
	scanf("%d",&K);
	
	C[0][0]=C[0][0]+1;
	REP(i,1,300){
		C[i][0]=C[i][0]+1;
		REP(j,1,min(20,i)) C[i][j]=C[i-1][j-1]+C[i-1][j];
	}
	
	SREP(i,0,K) pos[i]=get(K-i); 
    pos[K]=0;
    SREP(i,0,K){
		putchar('1');
        while(pos[i]-1>pos[i+1])pos[i]--,putchar('0');
    }
    putchar('\n');
	
	return 0;
}

T2T_2T2​——dreaming

Description:

有nnn个点mmm条边的图，现在加n−1−mn-1-mn−1−m条长度为LenLenLen的边使之变为一棵树，求树的直径的最小值。
n≤105n\le10^5n≤105

Solution:

  • 比较裸的题了…
  • 初始，我们预处理出每个树的直径，求出直径上最佳的中点midmidmid(d=min{max{dis[mid],dis[R]−dis[mid]}}d=min\{max\{dis[mid],dis[R]-dis[mid]\}\}d=min{max{dis[mid],dis[R]−dis[mid]}})，拿这些中点来连边。
  • 最优的连边策略，一定是拿拥有最长的ddd的中点与其它中点建边。
  • 建完边后再求一遍直径即为答案。

Code:

#include<bits/stdc++.h>
using namespace std;
#define REP(i,f,t) for(int i=(f),i##_end_=(t);i<=i##_end_;++i)
#define SREP(i,f,t) for(int i=(f),i##_end_=(t);i<i##_end_;++i)
#define DREP(i,f,t) for(int i=(f),i##_end_=(t);i>=i##_end_;--i)
#define ll long long
template<class T>inline bool chkmin(T&x,T y){return x>y?x=y,1:0;}
template<class T>inline bool chkmax(T&x,T y){return x<y?x=y,1:0;}
template<class T>inline void rd(T&x){
	x=0;char c;
	while((c=getchar())<48);
	do x=(x<<1)+(x<<3)+(c^48);
	while((c=getchar())>47);
}

const int N=1e5+2,INF=0x3f3f3f3f;

int n,m;
ll Len;

int qwq,head[N];
struct edge{
	int to,nxt;
	ll w;
}E[N<<1];
void addedge(int x,int y,ll z){E[qwq]=(edge){y,head[x],z};head[x]=qwq++;}
#define EREP(x) for(int i=head[x];~i;i=E[i].nxt)

struct p100{
	
	ll dis[N];
	int fa[N];
	ll Mn[N];// 每个小树的 min{max{dis[L][mid],dis[mid][R]}} 
	int rt[N],cnt;// 每个小树的中点 
	
	bool vis[N];
	
	int Id;
	ll Mx;
	
	void dfs1(int x,int f,ll d){
		if(chkmax(Mx,d)) Id=x;
		vis[x]=1;
		EREP(x){
			int y=E[i].to;
			if(y==f)continue;
			dfs1(y,x,d+E[i].w);
		}
	}
	
	void dfs2(int x,int f,ll d){
		if(chkmax(Mx,d)) Id=x;
		fa[x]=f;
		dis[x]=d;
		EREP(x){
			int y=E[i].to;
			if(y==f)continue;
			dfs2(y,x,d+E[i].w);
		}
	}
	
	void solve(){
		REP(i,1,n) if(!vis[i]) {
			Id=Mx=-1;
			dfs1(i,0,0);
			rt[++cnt]=Id;//L
			Mx=-1;
			dfs2(Id,0,0);//R
			int R=Id,L=rt[cnt],mid=R;
			Mn[cnt]=INF;
			if(L==R) Mn[cnt]=0;
			while(mid!=L){
				if(chkmin(Mn[cnt],max(dis[mid],dis[R]-dis[mid])))rt[cnt]=mid;
				mid=fa[mid];
			}
		}
		
		ll mx1=-1;
		int Rt1=-1;
		
		REP(i,1,cnt)if(chkmax(mx1,Mn[i])) Rt1=rt[i];
		
		REP(i,1,cnt){
			if(Rt1==rt[i])continue;
			addedge(Rt1,rt[i],Len);
			addedge(rt[i],Rt1,Len);
		}
		
		Mx=Id=-1;
		dfs1(1,0,0);
		Mx=-1;
		dfs2(Id,0,0);
		printf("%lld\n",Mx);
		
	}
}p2;

int main(){
//	freopen("dreaming.in","r",stdin);
//	freopen("dreaming.out","w",stdout);
	rd(n),rd(m),rd(Len);
	memset(head,-1,sizeof head);
	REP(i,1,m){
		int a,b,c;
		rd(a),rd(b),rd(c);
		++a,++b;
		addedge(a,b,c);
		addedge(b,a,c);
	}
	
	p2.solve();
	return 0;
}

T3T_3T3​——foodshop

Description:

有nnn个点，nnn条边的图，求一个点，使得这个点到其它的点的最大距离最小（注意：这个点可以在边上）。
n≤105,Li≤109n\le10^5,L_i\le10^9n≤105,Li​≤109

Solution:

  • 因为它是一个nnn个点nnn条边的图。
  • 那么它是一个基环树。
  • 首先，一定会先考虑分类讨论。我们优先解决环上。
  • 对于点在环上时，我们可以发现，最大距离一定是环上与该点对立的点的距离+对立点的子树的最大深度，且这种对立点至多会有2个。
  • 那么考虑对立点有2个时，发现这两个对立点之间的边使无用的，即可以删除。
  • 那么由此启发，我们可以枚举一条环边删除，那么答案即为剩下的这棵树的直径除2。
  • 但枚举环边，这样复杂度是Θ(n2)\Theta(n^2)Θ(n2)的。
  • 那么我们考虑数据结构来优化。
  • 对于一条要删除的环边(k,k+1)(k,k+1)(k,k+1)，我们找直径，由两次dfs找直径启发，我们从kkk点向左找最远距离的点，再从该点找最远的距离，同理，从k+1k+1k+1点向右找。
  • 那么由环上距离，我们知道Dist(i,j)=mx[i]+mx[j]+{dis[j]−dis[i],i≤jLen−dis[j]+dis[i],i&gt;jDist(i,j)=mx[i]+mx[j]+\begin{cases} dis[j]-dis[i],i\le j \\ Len-dis[j]+dis[i],i&gt;j\end{cases}Dist(i,j)=mx[i]+mx[j]+{dis[j]−dis[i],i≤jLen−dis[j]+dis[i],i>j​
  • 我们可以考虑线段树来维护环上每个点到其它点的最大距离。
  • 这样复杂度就是Θ(nlog⁡n)\Theta(n\log n)Θ(nlogn)

Code:

#include<bits/stdc++.h>
using namespace std;
#define REP(i,f,t) for(int i=(f),i##_end_=(t);i<=i##_end_;++i)
#define SREP(i,f,t) for(int i=(f),i##_end_=(t);i<i##_end_;++i)
#define DREP(i,f,t) for(int i=(f),i##_end_=(t);i>=i##_end_;--i)
#define ll long long
template<class T>inline bool chkmin(T&x,T y){return x>y?x=y,1:0;}
template<class T>inline bool chkmax(T&x,T y){return x<y?x=y,1:0;}
template<class T>inline void rd(T&x){
	x=0;char c;
	while((c=getchar())<48);
	do x=(x<<1)+(x<<3)+(c^48);
	while((c=getchar())>47);
}

const int N=2e5+2;

int n;

int qwq,head[N];
struct edge{
	int to,nxt;
	ll w;
}E[N<<1];
void addedge(int x,int y,ll z){E[qwq]=(edge){y,head[x],z};head[x]=qwq++;}
#define EREP(x) for(int i=head[x];~i;i=E[i].nxt)

int dfn[N],low[N],tim;
int stk[N<<1],top;
bool vis[N];

int chain[N],len;
bool belong[N];

ll ans;

void tarjan(int x,int f){
	dfn[x]=low[x]=++tim;
	stk[++top]=x;
	bool flag=1;
	EREP(x){
		int y=E[i].to;
		if(y==f and flag){flag=0;continue;}
		if(!dfn[y]) tarjan(y,x),chkmin(low[x],low[y]);
		else chkmin(low[x],dfn[y]);
	}
	if(dfn[x]==low[x]){
		if(stk[top]!=x){
			do {
				chain[++len]=stk[top];
				belong[stk[top]]=1;
			}while(x!=stk[top--]); 
		}
		else top--;
	}
}

struct p70{
	
	bool mark[N<<1];
	ll Mx,Id;
	
	void dfs1(int x,int f,ll d){
		if(chkmax(Mx,d)) Id=x;
		EREP(x){
			if(mark[i])continue;
			if(E[i].to!=f) dfs1(E[i].to,x,d+E[i].w);
		}
	}
	
	void dfs2(int x,int f,ll d){
		if(chkmax(Mx,d)) Id=x;
		EREP(x){
			if(mark[i])continue;
			if(E[i].to!=f) dfs2(E[i].to,x,d+E[i].w); 
		}
	}
	
	void solve(){
		
		ans=1e18;
		
		REP(p,1,len){
			int x=chain[p],y=chain[p%len+1];
			EREP(x){
				if(E[i].to==y) {
					mark[i]=mark[i^1]=1;
					
					Mx=Id=-1;
					dfs1(1,0,0);
					Mx=-1;
					dfs2(Id,0,0);
					
					chkmin(ans,Mx);
					
					mark[i]=mark[i^1]=0;
				}
			}
		}
		
		printf("%.1lf\n",1.0*ans/2);
	}
}p1;

ll dep[N<<1],dis[N],sum[N<<1];
ll mx[N],Sum[N];

ll Dist(int x,int d){
	if(!~x) return -1e18;
	return dep[x]+((d==1)?-sum[x]:sum[x]);
}

struct p100{
	
	ll dfs(int x,int f,ll d,int id){
		chkmax(dep[id],d);
		mx[x]=Sum[x]=0;
		EREP(x){
			int y=E[i].to;
			if(y==chain[id%len+1]) dis[id]=E[i].w;
			if(y==f or belong[y])continue;
			ll t=dfs(y,x,d+E[i].w,id)+E[i].w;
			chkmax(Sum[x],mx[x]+t);
			chkmax(mx[x],t);
		}
		return mx[x];
	}
	

	struct Tree{
		#define lson L,mid,p<<1
		#define rson mid+1,R,p<<1|1
		#define family tree[p],tree[p<<1],tree[p<<1|1]
		 
		struct node{
			int L,R;
			int id1,id2;
			ll mx1,mx2;
		}tree[N<<2];
		
		void Up(node &A,node L,node R){
			if(L.mx1>R.mx1)A.mx1=L.mx1,A.id1=L.id1;
			else A.mx1=R.mx1,A.id1=R.id1;
			if(L.mx2>R.mx2)A.mx2=L.mx2,A.id2=L.id2;
			else A.mx2=R.mx2,A.id2=R.id2;
		}
		
		void build(int L,int R,int p){
			tree[p].L=L,tree[p].R=R;
			if(L==R){
				tree[p].mx1=Dist(L,1);
				tree[p].mx2=Dist(L,2);
				tree[p].id1=tree[p].id2=L;
				return; 
			} 
			int mid=(L+R)>>1;
			build(lson),build(rson);
			Up(family); 
		}
		
		int query(int L,int R,int p,int op){
			if(L>R)return -1;
			if(tree[p].L==L and tree[p].R==R) return op==1?tree[p].id1:tree[p].id2;
			int mid=(tree[p].L+tree[p].R)>>1;
			if(R<=mid) return query(L,R,p<<1,op);
			else if(L>mid) return query(L,R,p<<1|1,op);
			else {
				int l=query(lson,op),r=query(rson,op);
				return Dist(l,op)>Dist(r,op)?l:r; 
			}
		}
		
	}T; 

	void solve(){
		REP(i,1,len){
			dfs(chain[i],0,0,i);
			sum[i]=sum[i-1]+dis[i-1];
		}
		
		REP(i,1,len){
			dep[i+len]=dep[i];
			if(i>1) sum[i+len]=sum[i+len-1]+dis[i-1];
			else sum[i+len]=sum[len]+dis[len];
		}
		
		ans=1e18;
		
		T.build(1,len<<1,1);
		
		REP(i,1,len){
			int l1=T.query(i,i+len-1,1,1);
			int l2=T.query(i,i+len-1,1,2);
			int tmp;
			ll Mx=0;
			
			if(l1==l2){
				int r1=T.query(i,l1-1,1,1);
				tmp=T.query(l1+1,i+len-1,1,1);
				if(Dist(tmp,1)>Dist(r1,1))r1=tmp;
				
				int r2=T.query(i,l2-1,1,2);
				tmp=T.query(l2+1,i+len-1,1,2);
				if(Dist(tmp,2)>Dist(r2,2))r2=tmp;
				
					
				Mx=Dist(l1,1)+Dist(r2,2);
				chkmax(Mx,Dist(l2,2)+Dist(r1,1));
			}
			else Mx=Dist(l1,1)+Dist(l2,2);
			chkmin(ans,Mx);
		}
		REP(i,1,n) chkmax(ans,Sum[i]);
		
		printf("%.1lf\n",1.0*ans/2);
	}
}p2;

int main(){
//	freopen("foodshop.in","r",stdin);
//	freopen("foodshop.out","w",stdout);
	rd(n);
	memset(head,-1,sizeof head);
	REP(i,1,n){
		int a,b;ll c;
		rd(a),rd(b),rd(c);
		addedge(a,b,c);
		addedge(b,a,c);
	}
	
	tarjan(1,0);

	if(n<=3000) p1.solve();
	else p2.solve();
	
	return 0;
}
10.19 noip 模拟题 【NOIP2018模拟赛2018.10.19】
chang_yl的博客
10-19 564
今天也才改出来一道题orz，大坑最近要填，，， 今天题目难度适中，暴力都打出来了，但是第二题“spfa死了”。 于是今天就改出来了第一题和去练了下dijkstra+堆优化。。。于是时间不够用orz。。 ------------------------------------------------------------------------------------------------...
NOIP2018模拟赛 HDU 4630 No Pain No Game 2018 10 9 T1
01232012的博客
10-10 273
难度：NOIP+ 算法：离线+树状数组 简述题意： 1.1 题目描述 给定一个长度为n 的排列a1; a2; a3; :::; an, 现在有Q 个询问，每次询 问区间[l,r] 内任意选取两个不同的数字能够得到的gcd 的最大值。 1.2 输入 一行两个整数n;Q 接下来一行是一个长度为n 的排列。 1.3 输出 如题目描述所述 1.4 样例输入1 10 5 8 2 4 9 5 7...
[20180824] noip模拟赛 Challenge
aoping9329的博客
08-26 128
线段树？分块大法好 1 #include <bits/stdc++.h> 2 using namespace std; 3 typedef long long ll; 4 //#define ll int 5 const int N = 2e5 + 10; 6 7 int n, m, a[N]; 8 ...
蓝桥杯第1593题——二进制问题
最新发布
Ares_moran的博客
04-01 824
那么比111更大的数即代表着第一个数一定填1，在第二个区间中，我们是在第一个数填1的情况下，考虑第三个数不填1的排列数，即剩下1个位置填2个1满足要求——dp[1][2]。这样分的理由是，第一个数不填1，考虑剩下3个位置填3个1的方法总数，这不就正好是在000~111这个长度为3的二进制序列中填3个1的排列总数吗，即dp[3][3]。第三个区间考虑在第一个位置和第三个位置都填1的情况下，第四个位置不填1的情况，那么就要加上在剩下0个位置填1个1的组合数——dp[0][1]。输出一个整数表示答案。
求不小于N且二进制串包含K个1的最小的数字
04-01 437
给定正整数N，求一个最小正整数M（M>=N），使得M中连续1的个数不小于K。 输入格式：N K 其中N为大整数，只能进行字符串处理 首先要把N化为二进制串，考察这个二进制串的最后K位； 直接把这个二进制串的最后K位改成1就完了？不行，例如N=1011，K=3，此时M为1110，而不是1111 也就是说，要考虑倒数第K+1位，如果是1，那么将K个1左移，右面置0 再考虑倒数第K+2位...
【NOIP模拟赛】盟主的忧虑
聂泽宇的blog
09-24 244
题解： 显然任意所求路径就只经过一条密道，然后呢，画图发现就是一个个环，然后可以用并查集来维护属于一个环或者是直接赋值 #include<bits/stdc++.h> using namespace std; long long read() { long long num=0; char ch=getchar(); while(ch>'9'||ch<'0') { ...
[noip模拟赛]午餐
weixin_30907935的博客
10-30 205
https://www.zybuluo.com/ysner/note/1325779 题面 一共有\(n\)个人,林先森知道开始时只有\(1\)号会毒瘤算法。林先森了解到很多人一起吃过 午餐;具体地,有\(m\)条信息,其中第\(j\)条信息描述\(u_j\)和\(v_j\)在\([L_j,R_j]\)区间中的某一天一起吃 了午餐。若此时\(u_j\)或\(v_j\)中的一个人会毒瘤算法...
【NOIP2018模拟赛2018.10.18】轻功
Stupid_Computer的博客
10-18 413
题目 Description 题目背景： 尊者神高达进入了基三的世界，作为一个 mmorpg 做任务是必不可少的，然而跑地图却令人十分不爽。好在基三可以使用轻功，但是尊者神高达有些手残，他决定用梅花桩练习轻功。 题目描述： 一共有 n 个木桩，要求从起点（0）开始，经过所有梅花桩，恰好到达终点 n,尊者神高达一共会 k 种门派的轻功，不同门派的轻功经过的梅花桩数不同，花费时间也不同。但是尊者神高达...
【NOIP2018模拟赛19.8.23】capacitor
您敲代码的姿势很像菜虚鲲
08-23 284
题目 根据两个方案，倒着推导，由可以得到：a
NOIP2018普及组&提高组官方测试数据
11-20
在压缩包“NOIP_评测数据”中，包含了各个级别的测试数据文件，选手可以通过模拟运行自己的程序，将输出与官方提供的答案进行比对，以此来检查程序的正确性。此外，这些数据还可以作为调试和优化程序的依据，帮助...
NOIP2018普及组试题及测试数据
07-31
《NOIP2018普及组试题及测试数据》是一份专门为NOIP（全国青少年信息学奥林匹克联赛）2018年普及组参赛者准备的重要资料。NOIP是中国计算机学会组织的一项面向初中生的信息学竞赛，旨在激发青少年对计算机科学的兴趣...
2018/3/18 noip模拟赛 20分
weixin_30510153的博客
03-18 137
T1 dp，特别裸特别简单，我放弃了写了个dfs。 T2 树归，特别裸特别简单，我不会写。 T3 贪心二分不知道什么玩意儿反正不会写就对了。 我是个智障 转载于:https://www.cnblogs.com/137shoebills/p/8595504.html...
文本分类——NLV算法研究与实现
知更鸟的博客
11-07 6531
内容提要1 引言2 NLV算法理论2.1 训练模型2.2 分类模型3 NLV算法实现3.1 算法描述4 实验及性能评估4.1 实验设计4.1.1 实验环境4.1.2 数据集4.1.3 实验目标4.1.4 关于预处理4.2 实验说明4.3 实验结果4.3.1 选参前提实验4.3.2 NLV分类实验4.3.3 分类对比实验5 分析总结 1 引言   分类器的分类效率是衡量分类器性能的一项重要指标。为了...
2017.10.7离线赛总结
Caristra的博客
10-07 511
第1题：S数 题意：定义S(x)为x每位上的数字和。eg：S(123)=1+2+3=6;S(22)=2+2=4 如果S(x*x)=S(x)*S(x) 则称x为S数，如x=22，S(x)=4,S(x*x)=S(484)=16;所以22是一个S数。 求[L,R]范围内S数的个数。数据范围： 80%,R<=10^5; 100%,R<=10^9。思路：当时只打了暴力（然而暴力数组炸了），打表找规
2017.10.6离线赛总结
Caristra的博客
10-06 495
2017.10.6离线赛总结
2018.9.11离线赛 by Isrothy
Caristra的博客
09-13 379
T1——jsr(3910) Description: 给你一个初始数字AAA,和目标数字BBB.你需要按照以下操作将AAA变为BBB. 数字xxx的二进制式(可以有前导000)下,将000,111的位置任意排列.再令x+1x+1x+1. 求最少次数的操作将AAA变为BBB.若无解,输出−1−1-1. A,B≤1018A,B≤1018A,B \le 10^{18} Solution: ...
2017.10.3离线赛总结
Caristra的博客
10-04 349
第1题：写书 题意：(…)总而言之，输入n，计算1~n每个数字位数的总和(n<=10^9)虽然是水题，但考试时做的还是太慢了， 现在回忆一下，当时只想着把数切分，再来打个小表。(还虚的要对拍) 然而，这题推公式也是很容易的…第2题：LR棋盘 题意: 有一个长度为1*n的棋盘，有一些棋子在上面，标记为L和R。 每次操作可以把标记为L的棋子，向左移动一格，把标记为R的棋子，向右移动一格，前提
POI 2014 切题记
Caristra的博客
09-26 345
POI 2014 Salad Bar Description: 有一个长度为nnn的字符串，每一位只会是ppp或jjj。你需要取出一个子串SSS（从左到右或从右到左一个一个取出），使得不管是从左往右还是从右往左取，都保证每时每刻已取出的ppp的个数不小于j的个数。你需要最大化∣S∣|S|∣S∣。 n≤106n \le 10^6n≤106 Solution: 先从左到右扫一遍得到以每个点为左端点，...
温岭中学第三次noip2011模拟赛详细回顾
3. 全国信息学奥林匹克联赛（noip）和竞赛准备的知识点：解释了noip的背景，以及模拟赛与noip之间的联系，模拟赛在准备noip中的作用和重要性。 4. 压缩包文件管理的知识点：解释了压缩包文件及其常见操作，如何处理...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值