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. Spring Boot 2.x （八）：日志框架的使用

    我们为啥要用日志? 最初我们开始接触Java的时候,我们通常会使用System.out.println()将我们想要知道的信息打印到控制台. 但是,如果在服务器上我们去运行我们的Java程序,这个时候 ...

  2. msf中exploit的web_delivery模块

    背景:目标设备存在远程文件包含漏洞或者命令注入漏洞,想在目标设备上加载webshell,但不想在目标设备硬盘上留下任何webshell文件信息 解决思路:让目标设备从远端服务器加载webshell代码 ...

  3. [前端]css前端样式的模块化

    css样式文件结构( 模块划分的单入口 ) common|_ _ _ _ _ _reset.css|_ _ _ _ _ _common.css 公用样式 libs|_ _ _ _ _ _bootstr ...

  4. 基于 Docker 的微服务架构实践

    本文来自作者 未闻 在 GitChat 分享的{基于 Docker 的微服务架构实践} 前言 基于 Docker 的容器技术是在2015年的时候开始接触的,两年多的时间,作为一名 Docker 的 D ...

  5. 视频拉流 Linux安装FFmpeg

    1 下载最新源码包并解压 $ wget http://ffmpeg.org/releases/ffmpeg-3.1.3.tar.bz2 $ tar jxvf ffmpeg-.tar.bz2 2安装ya ...

  6. HTML中特殊符号

  7. 从.Net到Java学习第十篇——Spring Boot文件上传和下载

    从.Net到Java学习系列目录 图片上传 Spring Boot中的文件上传就是Spring MVC中的文件上传,将其集成进来了. 在模板目录创建一个新的页面 profile/uploadPage. ...

  8. iOS----------检测app进入后台或前台

    开发播放器的时候,经常需要检测app进入后台(暂停播放)或者进入前台(开始播放).方法非常简单. 1.检测app进入后台 // 在AppDelete实现该方法 - (void)applicationD ...

  9. 操作系统：修改VirtualBox for Mac的虚拟硬盘大小

    我安装的是Mac版的VirtualBox,不能从GUI上修改硬盘大小,但是实在是大小不够用了. 百度后得知,可以用命令行修改. 1.打开终端,输入sudo su,取得管理员权限 $ sudo su P ...

  10. Android预置Apk方法

    这一套8.0过时了 需要修改pms代码 否则apk会被pms删除掉 因为工作需要,经常要开发和合入系统App,所以在此开篇作为收集和记录Android合入系统应用的方法,以备日后查阅. 一.预置apk ...