CCPC-Wannafly Winter Camp Day1部分题目解析

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(mlog 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(15log 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,'
'); F.write(x,' ');
			F.write(y,'
'); continue;
		}
		F.write(2,'
'); if ((x&1)&&(y&1))
		{
			F.write(2,' '); F.write(y-2,'
');
			F.write(x-2,' '); F.write(2,'
'); 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],'
');
				F.write(2,' '); F.write(x-prime[i],'
'); break;
			} else
			{
				F.write(prime[i],' '); F.write(y-2,'
');
				F.write(x-prime[i],' '); F.write(2,'
'); 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(nlog 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的话由于(cle 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骗衣服了？感觉这比赛没什么人打啊，有些题策不太动啊