Preface

最近恰好不知道做什么题，所以就按老叶要求做上面的比赛。

稍微看了下感觉难度适中，大部分题目偏向联赛难度，当然也有些题目打到了省选题的感觉（基本都是Div1的题）

这里就简单拿一些我做得动的题讲一下吧。排列顺序按照我做的顺序排（不一定按难度）

F 爬爬爬山

开的时候先看了一眼榜，发现这题过的人最多，那么肯定最可做

看了题目想了大概5min才出解吧，我感觉我水题秒的还是不够快啊

首先容易发现只有所有高度\(>h_1+k\)的山需要降低高度，那么我们可以直接拆点

入点和出点之前连这座山需要降低的高度的代价（不改就赋为\(0\)），然后无向图建边，出点连入点

然后不就是最短路了么，随便写个DJ就过了（乘法没开long longWA了2发）

CODE

#include<cstdio>

#include<cctype>

#include<queue>

#define RI register int

#define CI const int&

#define Tp template <typename T>

using namespace std;

typedef long long LL;

const int N=100005;

const LL INF=1e18;

struct edge

{

	int to,nxt; LL v;

}e[N*5]; int n,m,k,head[N<<1],cnt,h[N],x,y,z;

class FileInputOutput

{

	private:

		static const int S=1<<21;

		#define tc() (A==B&&(B=(A=Fin)+fread(Fin,1,S,stdin),A==B)?EOF:*A++)

		char Fin[S],*A,*B;

	public:

		Tp inline void read(T& x)

		{

			x=0; char ch; while (!isdigit(ch=tc()));

			while (x=(x<<3)+(x<<1)+(ch&15),isdigit(ch=tc()));

		}

		#undef tc

}F;

class SSSP

{

	private:

		struct data

		{

			int id; LL val;

			inline data(CI Id=0,const LL& Val=0)

			{

				id=Id; val=Val;

			}

			inline friend bool operator < (const data& A,const data &B)

			{

				return A.val>B.val;

			}

		}; priority_queue <data> small; int all; bool vis[N<<1]; LL dis[N<<1];

	public:

		#define to e[i].to

		inline void Dijkstra(void)

		{

			RI i; for (i=2,all=n<<1;i<=all;++i) dis[i]=INF;

			small.push(data(1,0)); while (!small.empty())

			{

				int now=small.top().id; small.pop();

				if (vis[now]) continue; vis[now]=1;

				for (i=head[now];i;i=e[i].nxt)

				if (!vis[to]&&dis[to]>dis[now]+e[i].v)

				small.push(data(to,dis[to]=dis[now]+e[i].v));

			}

			printf("%lld",dis[all]);

		}

		#undef to

}G;

inline void add(CI x,CI y,const LL& z)

{

	e[++cnt]=(edge){y,head[x],z}; head[x]=cnt;

}

inline LL sqr(CI x)

{

	return x<0?0:1LL*x*x;

}

int main()

{

	//freopen("CODE.in","r",stdin); freopen("CODE.out","w",stdout);

	RI i; for (F.read(n),F.read(m),F.read(k),i=1;i<=n;++i) F.read(h[i]);

	for (i=1;i<=n;++i) add(i,n+i,sqr(h[i]-h[1]-k)); for (i=1;i<=m;++i)

	F.read(x),F.read(y),F.read(z),add(n+x,y,z),add(n+y,x,z);

	return G.Dijkstra(),0;

}

J 夺宝奇兵

其实并不是很适合二开的题目，但是先看到这题感觉不错就先写了，然后调一个边界花了半个多小时

先讲一下Div2版本的做法，我们可以枚举所有村民的宝物最大值，然后把大于这个值的村民的物品低价都拿了

然后如果不够怎么办，在剩下的里面拿小的知道超过这个最大值即可

但是这样复杂度\(O(nm)\)，无法在Div1中通过

那么我们考虑优化，其实思想还是一样的，由于物品一共只有\(m\)个，我们可以想象对于每个人的物品按价格从小到大从上到下放置，那么我们倒序枚举最大值，那些物品是不是一个一层一层被取走的感觉

我们在维护被取走的物品的个数和总价值的同时，由于可能要有补足，所以要动态维护剩下的物品里的前\(k\)小值和

这个套路吧，一发值域线段树随便跑，复杂度\(O(m\log 10^9)\)

这里Div2的暴力懒得写了，所以直接上Div的CODE吧

#include<cstdio>

#include<cctype>

#include<vector>

#include<algorithm>

#define RI register int

#define CI const int&

#define Tp template <typename T>

using namespace std;

typedef long long LL;

const int N=100005,S=1e9;

int n,m,x,y,mx,cur,lim; LL ans=1e18,ret; vector <int> v[N],p[N];

class FileInputOutput

{

	private:

		static const int S=1<<21;

		#define tc() (A==B&&(B=(A=Fin)+fread(Fin,1,S,stdin),A==B)?EOF:*A++)

		char Fin[S],*A,*B;

	public:

		Tp inline void read(T& x)

		{

			x=0; char ch; while (!isdigit(ch=tc()));

			while (x=(x<<3)+(x<<1)+(ch&15),isdigit(ch=tc()));

		}

		#undef tc

}F;

class Segment_Tree

{

	private:

		static const int P=30;

		struct Segment

		{

			int ch[2],size; LL sum;

		}node[N*P]; int tot;

	public:

		int rt;

		#define lc(x) node[x].ch[0]

		#define rc(x) node[x].ch[1]

		#define Si(x) node[x].size

		#define S(x) node[x].sum

		inline void modify(int& now,CI val,CI opt,CI l=1,CI r=S)

		{

			if (!now) now=++tot; Si(now)+=opt; S(now)+=opt*val; if (l==r) return; int mid=l+r>>1;

			if (val<=mid) modify(lc(now),val,opt,l,mid); else modify(rc(now),val,opt,mid+1,r);

		}

		inline LL query(CI now,CI rk,CI l=1,CI r=S)

		{

			if (!now) return 0; if (l==r) return 1LL*l*rk; int mid=l+r>>1;

			return rk<=Si(lc(now))?query(lc(now),rk,l,mid):S(lc(now))+query(rc(now),rk-Si(lc(now)),mid+1,r);

		}

		#undef lc

		#undef rc

		#undef Si

		#undef S

}T;

inline bool cmp(CI x,CI y)

{

	return x>y;

}

inline void maxer(int& x,int y)

{

	if (y>x) x=y;

}

int main()

{

	//freopen("CODE.in","r",stdin); freopen("CODE.out","w",stdout);

	RI i,j; for (F.read(n),F.read(m),i=1;i<=m;++i)

	F.read(x),F.read(y),v[y].push_back(x),T.modify(T.rt,x,1);

	for (i=1;i<=n;++i) sort(v[i].begin(),v[i].end(),cmp),maxer(mx,v[i].size());

	for (i=1;i<=n;++i) for (lim=v[i].size(),j=0;j<lim;++j)

	p[j+1].push_back(v[i][j]); for (i=mx+1;~i;--i)

	{

		for (lim=p[i].size(),cur+=lim,j=0;j<lim;++j)

		T.modify(T.rt,p[i][j],-1),ret+=p[i][j]; LL cost;

		if (cur>=i) cost=ret; else cost=ret+T.query(T.rt,i-cur);

		if (cost<ans) ans=cost;

	}

	return printf("%lld",ans),0;

}

C 拆拆拆数

构造题？首先大力猜测答案不会很大！并顺手判掉\(n=1\)的情况

然后我首先想到了\(2\)于所有奇数互质，所以如果\(A,B\)都是奇数那么肯定可以分成\((A-2,2),(2,B-2)\)的形式

那有了偶数怎么办？还是利用上面的结论，由于这里的数都\(\ge 5\)，因此肯定可以分成奇质数+奇数的形式

奇数的话我们还是从\(B\)里找一个\(2\)和它配对，那么接下来就是找一个奇质数于\(B-2\)互质了

由于前\(15\)个质数的累计已经超过了\(10^{18}\)，所以我们大力枚举即可，复杂度最坏是单次\(O(15\log B)\)的

输出要注意一下，具体看CODE

#include<cstdio>

#include<cctype>

#define int long long

#define RI register int

#define CI const int&

#define Tp template <typename T>

using namespace std;

const int prime[15]={3,5,7,11,13,17,19,23,29,31,37,41,43,47,51};

int t,x,y;

class FileInputOutput

{

	private:

		static const int S=1<<21;

		#define tc() (A==B&&(B=(A=Fin)+fread(Fin,1,S,stdin),A==B)?EOF:*A++)

		#define pc(ch) (Ftop<S?Fout[Ftop++]=ch:(fwrite(Fout,1,S,stdout),Fout[(Ftop=0)++]=ch))

		char Fin[S],Fout[S],*A,*B; int Ftop,pt[25];

	public:

		Tp inline void read(T& x)

		{

			x=0; char ch; while (!isdigit(ch=tc()));

			while (x=(x<<3)+(x<<1)+(ch&15),isdigit(ch=tc()));

		}

		Tp inline void write(T x,const char& ch)

		{

			if (!x) return (void)(pc('0'),pc(ch)); RI ptop=0;

			while (x) pt[++ptop]=x%10,x/=10; while (ptop) pc(pt[ptop--]+48); pc(ch);

		}

		inline void Fend(void)

		{

			fwrite(Fout,1,Ftop,stdout);

		}

		#undef tc

		#undef pc

}F;

inline int gcd(CI x,CI y)

{

	return y?gcd(y,x%y):x;

}

signed main()

{

	//freopen("CODE.in","r",stdin); freopen("CODE.out","w",stdout);

	for (F.read(t);t;--t)

	{

		F.read(x); F.read(y);

		if (gcd(x,y)==1)

		{

			F.write(1,'\n'); F.write(x,' ');

			F.write(y,'\n'); continue;

		}

		F.write(2,'\n'); if ((x&1)&&(y&1))

		{

			F.write(2,' '); F.write(y-2,'\n');

			F.write(x-2,' '); F.write(2,'\n'); continue;

		}

		bool flag=0; if (x&1) { int t=x; x=y; y=t; flag=1; }

		for (RI i=0;i<15;++i) if (gcd(prime[i],y-2)==1)

		{

			if (flag)

			{

				F.write(y-2,' '); F.write(prime[i],'\n');

				F.write(2,' '); F.write(x-prime[i],'\n'); break;

			} else

			{

				F.write(prime[i],' '); F.write(y-2,'\n');

				F.write(x-prime[i],' '); F.write(2,'\n'); break;

			}

		}

	}

	return F.Fend(),0;

}

E 流流流动

这些题目名都是什么鬼？感觉这题分析成分更大一些。。。

首先那个连边方式你如果有一定数学基础的话很容易发现这个转移方式就是角谷猜想的形式。

乍一看角谷猜想是必然成环的，所以我开始就认为这种成环的东西不好做

不够如果你仔细读题的话会发现\(i=1\)的时候是不建边的，所以角谷猜想的关键步骤——以\(1\)为中转循环就被打破了

所以其实这个图是一个森林的形式，然后就是对每个联通块做一个简单DP即可。

CODE

#include<cstdio>

#define RI register int

#define CI const int&

using namespace std;

const int N=105;

struct edge

{

	int to,nxt;

}e[N<<1]; int n,head[N],cnt,a[N],b[N],f[N][2],ans; bool vis[N];

inline void addedge(CI x,CI y)

{

	e[++cnt]=(edge){y,head[x]}; head[x]=cnt;

	e[++cnt]=(edge){x,head[y]}; head[y]=cnt;

}

inline int min(CI a,CI b)

{

	return a<b?a:b;

}

inline int max(CI a,CI b)

{

	return a>b?a:b;

}

#define to e[i].to

inline void DP(CI now,CI fa)

{

	f[now][0]=0; f[now][1]=a[now]; vis[now]=1;

	for (RI i=head[now];i;i=e[i].nxt) if (to!=fa)

	{

		DP(to,now); f[now][0]+=max(f[to][0],f[to][1]);

		f[now][1]+=max(f[to][0],f[to][1]-b[min(now,to)]);

	}

}

#undef to

int main()

{

	RI i; for (scanf("%d",&n),i=1;i<=n;++i) scanf("%d",&a[i]);

	for (i=1;i<=n;++i) scanf("%d",&b[i]); for (i=2;i<=n;++i)

	if (i&1) { if ((3*i+1<=n)) addedge(i,3*i+1); } else addedge(i,i>>1);

	for (i=1;i<=n;++i) if (!vis[i]) DP(i,0),ans+=max(f[i][0],f[i][1]);

	return printf("%d",ans),0;

}

I 起起落落

比较神的一道题，肝了一个晚上才出来233

首先容易想到一个暴力的DP，令\(f_i\)表示以\(i\)为结尾的答案，那么显然有转移：

\[f_i=\sum_{j<i} [p_j>p_i](f_j+1)\sum_{j<k<i} [p_k<p_i]
\]

这个可以直接往前枚举\(j\)的时候顺带算出\([p_k<p_i]\)的个数，\(O(n^2)\)可以过Div2的范围

那么考虑优化，注意到\(p\)其实是一个排列，所以我们可以很方便地用权值线段树（怎么又是它）来维护答案

用一个思想，我们在计算贡献是先把它全部算上去，然后到后面在减去多算的贡献。

具体地，我们在枚举一个数的时候，先把它当做\(i\)算一遍答案，然后在当作\(z\)给后面的数加上次数，最后在当作\(j\)更新当前答案

这样只需要写一个奇怪的线段树即可维护答案了，复杂度\(O(n\log n)\)

CODE

#include<cstdio>

#include<cctype>

#define RI register int

#define CI const int&

#define Tp template <typename T>

using namespace std;

const int N=100005,mod=1e9+7;

int n,x,ans,cur;

class FileInputOutput

{

    private:

        static const int S=1<<21;

        #define tc() (A==B&&(B=(A=Fin)+fread(Fin,1,S,stdin),A==B)?EOF:*A++)

        char Fin[S],*A,*B;

    public:

        Tp inline void read(T& x)

        {

            x=0; char ch; while (!isdigit(ch=tc()));

            while (x=(x<<3)+(x<<1)+(ch&15),isdigit(ch=tc()));

        }

        #undef tc

}F;

inline void inc(int& x,CI y)

{

	if ((x+=y)>=mod) x-=mod;

}

inline int sum(CI x,CI y)

{

	int t=x+y; return t>=mod?t-mod:t;

}

class Segment_Tree

{

	private:

		struct Segment

		{

			int base,val,tag;

		}node[N<<2];

		#define B(x) node[x].base

		#define V(x) node[x].val

		#define T(x) node[x].tag

		inline void pushup(CI now)

		{

			B(now)=sum(B(now<<1),B(now<<1|1)); V(now)=sum(V(now<<1),V(now<<1|1));

		}

		inline void pushdown(CI now)

		{

			if (!T(now)) return; inc(T(now<<1),T(now)); inc(V(now<<1),1LL*T(now)*B(now<<1)%mod);

			inc(T(now<<1|1),T(now)); inc(V(now<<1|1),1LL*T(now)*B(now<<1|1)%mod); T(now)=0;

		}

	public:

		#define TN CI now=1,CI l=1,CI r=n

		#define O beg,end

		inline int queryval(CI beg,CI end,TN)

		{

			if (beg<=l&&r<=end) return V(now); int mid=l+r>>1,ret=0; pushdown(now);

			if (beg<=mid) inc(ret,queryval(O,now<<1,l,mid));

			if (end>mid) inc(ret,queryval(O,now<<1|1,mid+1,r)); return ret;

		}

		inline int querybase(CI beg,CI end,TN)

		{

			if (beg<=l&&r<=end) return B(now); int mid=l+r>>1,ret=0; pushdown(now);

			if (beg<=mid) inc(ret,querybase(O,now<<1,l,mid));

			if (end>mid) inc(ret,querybase(O,now<<1|1,mid+1,r)); return ret;

		}

		inline void modify(CI beg,CI end,CI val,TN)

		{

			if (beg<=l&&r<=end) return (void)(inc(T(now),val),inc(V(now),1LL*val*B(now)%mod));

			int mid=l+r>>1; pushdown(now); if (beg<=mid) modify(O,val,now<<1,l,mid);

			if (end>mid) modify(O,val,now<<1|1,mid+1,r); pushup(now);

		}

		#undef O

		inline void updata(CI pos,CI mb,CI mv,TN)

		{

			if (l==r) return (void)(inc(B(now),mb),inc(V(now),mv)); int mid=l+r>>1; pushdown(now);

			if (pos<=mid) updata(pos,mb,mv,now<<1,l,mid); else updata(pos,mb,mv,now<<1|1,mid+1,r); pushup(now);

		}

		#undef TN

		#undef B

		#undef V

		#undef T

}T;

int main()

{

	//freopen("CODE.in","r",stdin); freopen("CODE.out","w",stdout);

	RI i; for (F.read(n),i=1;i<=n;++i)

	{

		F.read(x); inc(ans,cur=T.queryval(x+1,n)); T.modify(x+1,n,1);

		T.updata(x,cur+1,sum(-T.querybase(x+1,n),mod));

	}

	return printf("%d",ans),0;

}

A 机器人

一个大力分类讨论的题，WA了快一页才过去

其实主要就是两种大的情况：\(B\)区要走以及\(B\)区不走

不走的情况很简单，就走一条线段即可，要走的最远点可以直接搞出来

然后考虑要走的情况，其实肯定就是一个矩形，我们在\(A,B\)的所有点中找到两个端点即可

但是大坑点来了，如果直接这么做就会忽略一种情况：出发点在最优矩形的外面！

然后经过一波分析，容易得出直接走到矩形是最优的走法，所以要特判一下

注意各种细节，写的时候脑子一定要清醒

CODE

#include<cstdio>

#include<cctype>

#include<algorithm>

#define RI register int

#define CI const int&

#define Tp template <typename T>

using namespace std;

const int N=100005;

int n,r,m,k,s,p[2][N],cnt[2],sp[N],cnt_sp,x,y,mi=1e9,mx,pmi,pmx;

class FileInputOutput

{

    private:

        static const int S=1<<21;

        #define tc() (A==B&&(B=(A=Fin)+fread(Fin,1,S,stdin),A==B)?EOF:*A++)

        char Fin[S],*A,*B;

    public:

        Tp inline void read(T& x)

        {

            x=0; char ch; while (!isdigit(ch=tc()));

            while (x=(x<<3)+(x<<1)+(ch&15),isdigit(ch=tc()));

        }

        #undef tc

}F;

inline void miner(int& x,CI y)

{

	if (y<x) x=y;

}

inline void maxer(int& x,CI y)

{

	if (y>x) x=y;

}

int main()

{

	//freopen("CODE.in","r",stdin); freopen("CODE.out","w",stdout);

	RI i; for (F.read(n),F.read(r),F.read(m),F.read(k),F.read(s),i=1;i<=r;++i)

	F.read(x),F.read(y),p[y][++cnt[y]]=x; sp[1]=1; sp[cnt_sp=2]=n;

	for (i=1;i<=m;++i) F.read(x),sp[++cnt_sp]=x;

	sort(sp+1,sp+cnt_sp+1); cnt_sp=unique(sp+1,sp+cnt_sp+1)-sp-1;

	sort(p[0]+1,p[0]+cnt[0]+1); sort(p[1]+1,p[1]+cnt[1]+1);

	if (cnt[0]) miner(mi,p[0][1]),maxer(mx,p[0][cnt[0]]);

	if (cnt[1]) miner(mi,p[1][1]),maxer(mx,p[1][cnt[1]]);

	pmx=lower_bound(sp+1,sp+cnt_sp+1,mx)-sp; pmx=sp[pmx];

	pmi=upper_bound(sp+1,sp+cnt_sp+1,mi)-sp-1; pmi=sp[pmi];

	if (!cnt[1])

	{

		if (mx<=s) pmx=s; if (mi>=s) pmi=s;

		return printf("%d",pmx-pmi<<1),0;

	}

	int cur=(pmx-pmi<<1)+(k<<1);

	if (s<pmi) cur+=(pmi-s<<1); if (s>pmx) cur+=(s-pmx<<1);

	return printf("%d",cur),0;

}

B 吃豆豆（only for Div2）

我太菜了所以只会这题Div2的做法，Div1的感觉可以大小步DP，总之肯定有什么规律

Div2的话由于\(c\le 1018\)，所以我们直接大力DP，以颜色为状态转移感觉不是很好策，所以我们以时间为状态

令\(f_{i,j,k}\)表示时间\(k\)在\(i,j\)时最多能得到多少糖果，转移的话分四个方向移动和不动转移一下即可

一边打麻将一边写的，随便搞了搞也过了233

CODE

#include<cstdio>

#include<cctype>

#include<cstring>

#define RI register int

#define CI const int&

#define Tp template <typename T>

using namespace std;

const int N=15,C=1100;

int n,m,c,t[N][N],f[N][N][N*C],sx,sy,tx,ty,ans;

class FileInputOutput

{

    private:

        static const int S=1<<21;

        #define tc() (A==B&&(B=(A=Fin)+fread(Fin,1,S,stdin),A==B)?EOF:*A++)

        char Fin[S],*A,*B;

    public:

        Tp inline void read(T& x)

        {

            x=0; char ch; while (!isdigit(ch=tc()));

            while (x=(x<<3)+(x<<1)+(ch&15),isdigit(ch=tc()));

        }

        #undef tc

}F;

inline void maxer(int& x,CI y)

{

	if (y>x) x=y;

}

inline void miner(int& x,CI y)

{

	if (y<x) x=y;

}

int main()

{

	//freopen("CODE.in","r",stdin); freopen("CODE.out","w",stdout);

	RI i,j,k; for (F.read(n),F.read(m),F.read(c),i=1;i<=n;++i)

	for (j=1;j<=m;++j) F.read(t[i][j]); F.read(sx); F.read(sy);

	F.read(tx); F.read(ty); memset(f,167,sizeof(f));

	for (f[sx][sy][0]=0,k=0;k<=10*c;++k) for (i=1;i<=n;++i) for (j=1;j<=m;++j)

	{

		if (i-1>=1) maxer(f[i-1][j][k+1],f[i][j][k]+((k+1)%t[i-1][j]?0:1));

		if (i+1<=n) maxer(f[i+1][j][k+1],f[i][j][k]+((k+1)%t[i+1][j]?0:1));

		if (j-1>=1) maxer(f[i][j-1][k+1],f[i][j][k]+((k+1)%t[i][j-1]?0:1));

		if (j+1<=m) maxer(f[i][j+1][k+1],f[i][j][k]+((k+1)%t[i][j+1]?0:1));

		maxer(f[i][j][k+1],f[i][j][k]+((k+1)%t[i][j]?0:1));

	}

	for (k=0;k<=10*c;++k) if (f[tx][ty][k]>=c) { ans=k; break; }

	return printf("%d",ans),0;

}

Postscript

据说镜像赛Rank前10就送T恤，感觉如果现场打的话可能可以切出\(4,5\)题吧

所以就可以到Div1骗衣服了？感觉这比赛没什么人打啊，有些题策不太动啊

CCPC-Wannafly Winter Camp Day1部分题目解析的更多相关文章

  1. 2020 CCPC Wannafly Winter Camp Day1 C. 染色图

    2020 CCPC Wannafly Winter Camp Day1 C. 染色图 定义一张无向图 G=⟨V,E⟩ 是 k 可染色的当且仅当存在函数 f:V↦{1,2,⋯,k} 满足对于 G 中的任 ...

  2. 2020 CCPC Wannafly Winter Camp Day1 - I. K小数查询(分块)

    题目链接:K小数查询 题意:给你一个长度为$n$序列$A$,有$m$个操作,操作分为两种: 输入$x,y,c$,表示对$i\in[x,y] $,令$A_{i}=min(A_{i},c)$ 输入$x,y ...

  3. 2020 CCPC Wannafly Winter Camp Day1 Div.1&amp F

    #include<bits/stdc++.h> #define forn(i, n) for (int i = 0; i < int(n); i++) #define fore(i, ...

  4. CCPC Wannafly Winter Camp Div2 部分题解

    Day 1, Div 2, Prob. B - 吃豆豆 题目大意 wls有一个\(n\)行\(m\)列的棋盘,对于第\(i\)行第\(j\)列的格子,每过\(T[i][j]\)秒会在上面出现一个糖果, ...

  5. 2020 CCPC Wannafly Winter Camp Day2-K-破忒头的匿名信

    题目传送门 sol:先通过AC自动机构建字典,用$dp[i]$表示长串前$i$位的最小代价,若有一个单词$s$是长串的前$i$项的后缀,那么可以用$dp[i - len(s)] + val(s)$转移 ...

  6. 2020 CCPC Wannafly Winter Camp Day1-F-乘法

    题目传送门 sol:二分答案$K$,算大于$K$的乘积有多少个.关键在于怎么算这个个数,官方题解上给出的复杂度是$O(nlogn)$,那么计算个数的复杂度是$O(n)$的.感觉写着有点困难,自己写了一 ...

  7. 2019 wannafly winter camp day 3

    2019 wannafly winter camp day 3 J 操作S等价于将S串取反,然后依次遍历取反后的串,每次加入新字符a,当前的串是T,那么这次操作之后的串就是TaT.这是第一次转化. 涉 ...

  8. 2019 wannafly winter camp

    2019 wannafly winter camp Name Rank Solved A B C D E F G H I J K day1 9 5/11 O O O O O day2 5 3/11 O ...

  9. CCPC-Wannafly Winter Camp Day1 (Div2 ABCFJ) 待补...

    Day1 Div2 场外链接 按题目顺序~ A 机器人 传送门 题意:有两条平行直线A.B,每条直线上有n个点,编号为1~n.在同一直线上,从a站点到b站点耗时为两点间的距离.存在m个特殊站点,只有在 ...

随机推荐

  1. [ Java面试题 ]框架篇二

    1.Hibernate工作原理及为什么要使用Hibernate? 工作原理: 1.读取并解析配置文件 2.读取并解析映射信息,创建SessionFactory 3.打开Session 4.创建事务Tr ...

  2. es简单打造站内搜索

    最近挺忙的,在外出差,又同时干两个项目.白天一个晚上一个,特别是白天做的项目,马上就要上线了,在客户这里 三天两头开会,问题很多真的很想好好静下来怼代码,半夜做梦都能fix bugs~ 和客户交流真的 ...

  3. .net 用ajaxFileUpload 上传超过20M文件设置

    1.在web.config的 <system.web>  节点里面添加   <httpRuntime targetFramework="4.5.2"  execu ...

  4. ARM与FPGA通过spi通信设计2.spi master的实现

    这里主要放两个代码第一个是正常的不使用状态机的SPI主机代码:第二个是状态机SPI代码 1.不使用状态机:特权同学<深入浅出玩转FPGA>中DIY数码相框部分代码: /////////// ...

  5. linux学习笔记-linux主机上传下载文件至linux虚拟机的方法

    我的邮箱地址:zytrenren@163.com欢迎大家交流学习纠错! 1.上传文件 scp -r file 用户名@ip地址:目标目录 2.下载文件 scp -r 用户名@ip地址:文件 目标目录

  6. (最简单)红米手机5A的USB调试模式在哪里开启的方法

    当我们使用安卓手机链接Pc的时候,或者使用的有些APP比如我们公司营销小组当使用的APP引号精灵,之前使用的老版本就需要开启usb调试模式下使用,现当新版本不需要了,如果手机没有开启usb调试模式,P ...

  7. 从零学习Fluter(三):Flutter的路由跳转以及state的生命周期

    今天继续研究Flutter,我是在flutter1.0发布后,才玩flutter的,发现在此之前,许多人已经先发制人,玩起了flutter,不知不觉中,我已经被别人摔在了起跑线上,玩过flutter后 ...

  8. Visual Studio 无法记忆标签页、断点等的解决办法

    1.到工程目录删除*.suo文件 2.*.suo默认是隐藏的,需要打开查看隐藏文件的开关

  9. (办公)plug-in org.eclipse.jdt.ui was unable to load class org.eclipse.jdt.internal

    今天上午开发环境遇到这个问题,解决方案如下,(解决了之后,项目并没有丢失.) 因为Eclipse的这个plug-in org.eclipse.jdt.ui was unable to load cla ...

  10. 扩展1000!(n!)的尾数零的个数

    #include <stdio.h> #include <malloc.h> //计算1000!尾数零的个数 //扩展n!的尾数零的个数 //2^a * 5^b //obvio ...