Educational Codeforces Round 72 (Rated for Div. 2) A--E

RANK:1868       1702 -13→ 1689  

最近cf打的太差了。感觉还是前面题不稳。导致难题没时间想，简单题又不快。。排名自然很低

A:

先把智力点到比力量高1以上。

点不到 就输出-1；

然后要分奇偶

当c是偶数时，

有c+1种分配，其中 c/2,c/2是零界点。智力c/2以上，都是可行的。再考虑c/2一下，每少点一点智力，智力和力量差多2.

所以要看智力比力量初始高多少（如果低，先点到智力多1）.每多2，可以向下少点一点智力，即多一种方案。

注意方案上限时c+1。就因为这里wa了。。。

然后奇数同理分析即可

//KX
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef double db;
const int M = 1e5+7;
#define ls o*2
#define rs o*2+1
#define pb push_back
int main()
{
	int t;
	cin>>t;
	while(t--)
	{
		int a,b,c;
		cin>>a>>b>>c;
		if(a+c<=b)
		{
			puts("0");
			continue;
		}
		if(a<=b)
		{
			c-=(b+1-a),a=b+1;
		}
		int w=a-b;
		int f=(c+1)/2;
		if(c%2==0)
		{
			f++;
			printf("%d\n",min(f+(w-1)/2,c+1));
		}
		else
		{
			printf("%d\n",min(f+w/2,c+1));
		}
	}
  	return 0;
}

B：

简单题。。我刚开始当成每种拳法只能用一次了。。。耽搁很长时间。

后来发现每种拳法不是只用一次，慌忙写了一发被HACK了。。。。。

直接找到攻击头最多的拳法。然后找的攻击消灭头数减去增长头数最大的。先用这拳法打到斩杀线 ，然后斩杀即可。

细节就是。。攻击最大的无法斩杀，而且所有攻击消灭均不大于增长的。不能战胜。

或者，攻击最大的直接斩杀。

然后就是正常的先到斩杀线再斩杀。

//KX
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef double db;
const int M = 100+7;
#define ls o*2
#define rs o*2+1
#define pb push_back
struct node
{
	int d,h,c;
}a[M];
bool cmp(node a,node b)
{
	return a.c>b.c;
}
int main()
{
	int t;
	cin>>t;
	while(t--)
	{
		int n,x;
		cin>>n>>x;
		int ma=0,id;
		for(int i=1;i<=n;i++)
		{
			scanf("%d%d",&a[i].d,&a[i].h);
			ma=max(ma,a[i].d);
			a[i].c=a[i].d-a[i].h;
		}
		sort(a+1,a+1+n,cmp);
		if(a[1].c<=0&&ma<x)
		{
		   puts("-1");
		   continue;
		}
		if(a[1].c>x||ma>=x)
		{
			puts("1");
			continue;
		}
		int w=a[1].c;
		x-=ma;
		int num = x/w +1;
		if(x%w!=0)num++;
		printf("%d\n",num);
	}
  	return 0;
}

C：水题。1后面30位就到1e9了。。所以我们只用判20位就够了。

暴力即可

//KX
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef double db;
const int M = 2e5+7;
#define ls o*2
#define rs o*2+1
#define pb push_back
char s[M];
int main()
{
	int t;
	cin>>t;
	while(t--)
	{
		scanf("%s",s);
		int len=strlen(s);
		int n0=0,n1=0;
		int ans=0;
		for(int i=0;i<len;i++)
		{
			if(s[i]=='0')
			n0++,n1=0;
			else
			{
				int now=0;
				for(int j=i;j<=i+20;j++)
				{
					if(j>=len)break;
					now*=2;
					if(s[j]=='1')
					now++;
					if(n0+j-i+1>=now)
					ans++;
				}
				n0=0;
				n1++;
			}
		}
		printf("%d\n",ans);
	}
  	return 0;
}

D:

首先  最多只用2种颜色，因为有环只需要2种颜色就能让环内不完全同色。

所以有2种做法：

1：先说我写的，先建完图，枚举所有边，以这条边指向点dfs，如果碰到了起始点，说明成环，那么指向起始点的所有边染色2.

且删除（判断是否染色，染色就不走）。枚举玩所有即可。、

或者你在建图的时候，每加边之前，判断指向点能不能到起始点，如果能这条边染2，且不加，否则加这条边。复杂度一样，不过时间理论时上面的一半。

2.第二种方法就很骚了。首先拓扑判有无环，无环直接全1.

有环的话，所有边，u->v.其中u<v的全部染1，u>v的全部染2.

正确性显然，成环的结点一定从a开始，再到a。由于结点编号都不相同，所以必然呈波浪状。

肯定保证环内不完全同色。

//KX
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef double db;
const int M = 1e4+7;
#define ls o*2
#define rs o*2+1
#define pb push_back
int cnt;
int head[M];
int ans[M];
struct EDGE
{
	int to,next,id;
}edge[M];
void add(int x,int y,int id)
{
	edge[++cnt].to=y;
	edge[cnt].next=head[x];
	edge[cnt].id=id;
	head[x]=cnt;
}
int vis[M];
bool f;
int z=0;
void dfs(int x,int u)
{
	if(vis[x])return;
	vis[x]=1;
	for(int i=head[x];i;i=edge[i].next)
	{
		int v=edge[i].to;
		if(ans[edge[i].id]==2)continue;
//		printf("     %d -> %d    %d\n",x,v,u);
		if(v==u)ans[edge[i].id]=2;
		dfs(v,u);
	}
}
int u[M],v[M];
int main()
{
	int n,m;
	cin>>n>>m;
	for(int i=1;i<=m;i++)
	{
		scanf("%d%d",&u[i],&v[i]);
		add(u[i],v[i],i);
	}
	int mx=1;   
	for(int i=1;i<=m;i++)
	{
		memset(vis,0,sizeof(vis));
		for(int j=head[u[i]];j;j=edge[j].next)
		{
			int to=edge[j].to;
			if(to==v[i])
			{
				if(ans[edge[i].id]!=2)
					dfs(v[i],u[i]);
				break;
			}
		}
		//puts("ok");
		if(vis[u[i]])mx=2;
	}
	printf("%d\n",mx);
	for(int i=1;i<=m;i++)
	{
		printf("%d ",ans[i]==2?2:1);
	}
  	return 0;
}

E：

给你n个数，

2个操作

1 x y：把第x个数变为y

2 x y：查询x-y区间内，点集和最小的不平衡点集。

不平衡点集，就是这个集合内说有数相加得到的结果，每一位，在原来各个数，对应位都有出现。

很明显，相加，按位加一定不能进位，一旦进位，下一位必须进位才能满足，，然后就无限循环，一定不满足/

如果不进位的话，一定是，1个数的这位不为0，其他均为0，才能满足，否则一定不满足。

而且。题目要求点集和最小，我们发现，点集不平衡只需要2个即可。多了没必要，即2个数，某位均不为0就行。

综上所述：我们发现，

只在区间中，每一位进行处理，找到这一位均不为0的最小的2个数。

比如：1230 450 607 89

现在询问1-4区间。

个位：89，607。

十位：450，89.

百位：450，607

千位：1230，INF；

万位：INF,INF

…………

每一位都构成了不平衡点集，且是这一位满足条件，和最小的点集。

相加去最小即可。

结果肯定是450+89。

//KX
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef double db;
const int M = 2e5+7;
const ll INF = 2e9+7;
#define ls o*2
#define rs o*2+1
#define pb push_back
#define m (l+r)/2
struct node
{
	int mn[10],mc[10];
	node()
	{
		for(int i=0;i<10;i++)mn[i]=mc[i]=INF;
	}
}tr[M<<2];
node operator +(node a,node b)
{
	node tmp;
	for(int i=0;i<10;i++)
	{
		tmp.mn[i]=min(a.mn[i],b.mn[i]);
		if(a.mn[i]<b.mn[i])
			tmp.mc[i]=min(a.mc[i],b.mn[i]);
		else 
			tmp.mc[i]=min(a.mn[i],b.mc[i]);
	}
	return tmp;
}
void up(int o,int l,int r,int x,int y)
{
	if(l==r)
	{
		for(int i=0;i<10;i++)tr[o].mn[i]=tr[o].mc[i]=INF;
		for(int z=y,i=0;i<10;i++,z/=10)
			if(z%10)tr[o].mn[i]=y;
		return;
	}
	if(x<=m)up(ls,l,m,x,y);
	else up(rs,m+1,r,x,y);
	tr[o]=tr[ls]+tr[rs];
}
node qu(int o,int l,int r,int x,int y)
{
	if(x<=l&&r<=y)return tr[o];
	if(y<=m)return qu(ls,l,m,x,y);
	if(x>m)return qu(rs,m+1,r,x,y);
	return qu(ls,l,m,x,y)+qu(rs,m+1,r,x,y);
}
int main()
{
	int n,q,x;
	cin>>n>>q;
	for(int i=1;i<=n;i++)
		scanf("%d",&x),up(1,1,n,i,x);
	while(q--)
	{
		int c,x,y;
		scanf("%d%d%d",&c,&x,&y);
		if(c==1)up(1,1,n,x,y);
		else 
		{
			node tmp=qu(1,1,n,x,y);
			ll ans=INF;
			for(int i=0;i<10;i++)
				ans=min(ans,(ll)tmp.mn[i]+tmp.mc[i]);
			if(ans>=INF)puts("-1");
			else printf("%lld\n",ans);
		}
	}
  	return 0;
}