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 虚拟机内存划分,类加载过程以及对象的初始化

    涉及关键词: 虚拟机运行时内存 java内存划分 类加载顺序  类加载时机  类加载步骤  对象初始化顺序  构造代码块顺序 构造方法 顺序 内存区域   java内存图  堆 方法区 虚拟机栈 本地 ...

  2. 基本 SQL 之数据库及表管理

    上篇文章,我们基于『数据库』做了一个宏观上的介绍,你应当了解到数据库是在何种背景下,为了解决什么样的问题而诞生的,以及在具体实现下又可以划分哪些中类型. 非关系型数据库的种类很多,我们会在后续的篇章中 ...

  3. Spring基础系列--AOP织入逻辑跟踪

    原创作品,可以转载,但是请标注出处地址:https://www.cnblogs.com/V1haoge/p/9619910.html 其实在之前的源码解读里面,关于织入的部分并没有说清楚,那些前置.后 ...

  4. Nlog、Log4Net 的一个小扩展（增加自定义LEVEL）

    因公司ELK监控分析日志的需要,需要区分进程运行状态日志以及错误日志,以便能够根据日志级别(level)进行不同策略的预警,而现有的Nlog.Log4Net都没有Process这样的level,故针对 ...

  5. 解决虚拟机连接不上外网，不能互相ping通

    0.解决虚拟机连接不上外网,不能互相ping通 直接在linux系统下,编辑修改如下文件: //编辑文件/etc/sysconfig/network-scripts/ifcfg-eth0 [root@ ...

  6. C#工具:利用HttpClient调用WebApi

    可以利用HttpClient来进行Web Api的调用.由于WebA Api的调用本质上就是一次普通的发送请求与接收响应的过程, 所有HttpClient其实可以作为一般意义上发送HTTP请求的工具. ...

  7. [PHP] 适配器模式的日常使用

    适配器模式就是将一个类的接口方法转换成我希望用的另一个方法 , 下面是个常见的用处 class Session{ public $mc; public function __construct(){ ...

  8. 20190322-a标签、img标签、三列表、特殊字符实体、表格

    目录 1.a标签 a标签的属性 锚点 2.img标签 img标签的属性 图像热区 3.三列表 有序列表(Ordered List)     ol>li 无序列表(Unordered List)  ...

  9. Dynamics CRM项目实例之八：CRM 2015的产品系列，克隆，修订

    关注本人微信和易信公众号: 微软动态CRM专家罗勇,回复139或者20150106可方便获取本文,同时可以在第一时间得到我发布的最新的博文信息,follow me!       今天的博客主要是关于D ...

  10. Belgrade Azure 2019-2-11活动感悟

    这是<国外线下技术俱乐部建设>系列文章之一.   活动网址:https://www.meetup.com/Azure-UG-Srbija/events/258673179/ 活动内容:Az ...