AtCoder Beginner Contest 343（A,B,C,D,E,F）

比赛链接

CE是暴力，D是数据结构题，F是线段树。这场的E比较有意思，其他的感觉有点水。

A - Wrong Answer

题意：

给你两个数 $A, B$ $(0\le A,B\le 9)$ ，返回一个个位数，使得它不等于 $A + B$ 。

思路：

看一下 $A + B$ 等不等于 $0$ ，如果不等于就直接输出 $0$ ，如果正好等于就随便找个其他数输出即可。

code：

#include <iostream>
#include <cstdio>
using namespace std;

int a,b;

int main(){
	cin>>a>>b;
	if(a+b==0)cout<<9<<endl;
	else cout<<0<<endl;
	return 0;
}

B - Adjacency Matrix

题意：

给你一个 $N$ 个点的无向图和 $N\times N$ 的邻接矩阵。问每个点的邻接点有哪些。

思路：

因为是无向图，所以邻接矩阵是对称的，我们把第 $i$ 行或者第 $i$ 列看成 $i$ 的出边都没有问题。假如第 $i$ 行上的某个位置 $A_{i,j}=1$ 就说明 $i\rightarrow j$ 有一条边，就相当于 $j$ 是 $i$ 的一个邻接点，我们直接遍历第 $i$ 行就能找到 $i$ 的所有邻接点了。

code：

#include <iostream>
#include <cstdio>
using namespace std;

int n;

int main(){
	cin>>n;
	for(int i=1;i<=n;i++){
		for(int j=1,t;j<=n;j++){
			cin>>t;
			if(t==1)cout<<j<<" ";
		}
		cout<<endl;
	}
	return 0;
}

C - 343

题意：

给你一个数 $N$ $(1\le N\le 10^{18})$ ，问不超过 $N$ 的最大立方数同时是回文数的数是什么。

思路：

不难发现，如果这个数是立方数，那么它最多只有 $10^6$ 种可能，再在其中找到回文数即可。而判断回文最多只需要判断 $18$ 位，所以直接暴力枚举就能找到所有可能的立方数且是回文数的数。

code：

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
typedef long long ll;

ll n;

bool check(ll x){
	string s=to_string(x);
	int len=s.length();
	for(int i=0;i<len/2;i++)
		if(s[i]!=s[len-i-1])
			return false;
	return true;
}

int main(){
	cin>>n;
	ll ans;
	for(ll i=1;i*i*i<=n;i++)
		if(check(i*i*i))
			ans=i*i*i;
	
	cout<<ans<<endl;
	return 0;
}

D - Diversity of Scores

题意：

有 $N$ 个人， $T$ 次修改操作，一开始所有人分数都是 $0$ 。

每次修改操作形如 a b ，表示将第 $a$ 个人的分数加上 $b$ 。

问每次修改后，有多少种不同的分数。

思路：

用 $ma p$ 记录每种分数有几个人，每次修改结束后看一下 $ma p$ 中有几种分数就行了。

code：

#include <iostream>
#include <cstdio>
#include <map>
using namespace std; 
const int maxn=2e5+5;
typedef long long ll;

int n,t;
ll a[maxn];

int main(){
	cin>>n>>t;
	map<ll,int> mp;
	mp[0]=n;
	for(int i=1,idx,b;i<=t;i++){
		cin>>idx>>b;
		mp[a[idx]]--;
		if(mp[a[idx]]==0)mp.erase(a[idx]);
		a[idx]+=b;
		mp[a[idx]]++;
		cout<<mp.size()<<endl;
	}
	return 0;
}

E - 7x7x7

题意：

在三维直角坐标系中有两个边长为 $7$ 的正六面体（就是立方体）。我们用立方体左下角的点的坐标描述一个立方体的位置，具体来说，就是用 $C (a, b, c)$ 描述 $(a\le x\le a+7)\wedge (b\le y\le b+7)\wedge (c\le z\le c+7)$ 的立方区域。

用 $a_1,b_1,c_1,a_2,b_2,c_2,a_3,b_3,c_3$ 描述三个正方体的位置，其中第 $i$ 个立方体的位置为 $C_i=(a_i,b_i,c_i)$ 。并且 $|a_1|,|b_1|,|c_1|,|a_2|,|b_2|,|c_2|,|a_3|,|b_3|,|c_3|\le 100$ 。

定义：

在 $C_1,C_2,C_3$ 中只包含在一个立方体内部的体积为 $V_1$ 。
在 $C_1,C_2,C_3$ 中只包含在两个立方体内部的体积为 $V_2$ 。
在 $C_1,C_2,C_3$ 中包含在三个立方体内部的体积为 $V_3$ 。

给你 $V_1,V_2,V_3$ ，问可行的一组 $a_1,b_1,c_1,a_2,b_2,c_2,a_3,b_3,c_3$ 。

思路：

乍一看根本无从下手，但是看到数据范围很小，感觉应该是个比较暴力的做法。

先想两个立方体的情况。如果两个立方体有相交，那么相交的区域的上边界应该是两个立方体的上边界的较小值（也就是靠下的那个边界）。同理，相交区域的下边界应该是两个立方体下边界的较大值（也就是靠上的那个边界）。相交区域的左边界应该是两个立方体左边界的较大值。相交区域的右边界应该是两个立方体右边界的较小值。相交区域的前边界应该是两个立方体前边界的较大值。相交区域的后边界应该是两个立方体后边界的较小值。

这样只要知道了两个立方体的位置，就可以 $O (1)$ 地得到相交区域的位置，也就得到了这个区域的体积。显然的如果算出来的上边界低于下边界，那么就说明不存在这个相交区域，同理，右边界要大于左边界，后边界要大于前边界。而对于三个立方体的相交区域我们也可以这样得到。

因此我们只要知道了三个立方体的位置，就可以算出两两相交的区域体积，和三个立方体的相交区域，根据容斥的思想可以很容易算出它们的 $V_1,V_2,V_3$ 。

但是如何确定这三个立方体的位置呢，根据相对论，如果有一种可行的三立方体位置那么我们可以把中间那个立方体的左下角点位置放在原点。前面说了数据范围很小，某个立方体要么和一个立方体相交，要么就相离。而相离的话，离多远都可以，那么不如就让它贴着前一个立方体。这样的话，三个立方体就算一起贴着，点能遍及到的位置就只有 ${(x,y,z)|-7\le x\le 7,-7\le y\le 7,-7\le z\le 7}$ 。总的点的可能不会超过 $15^3=3375$ ，暴力枚举两个立方体的点的位置时间复杂度也就是 $1 e 7$ ，完全能跑。所以暴力就完了。

这里把中间那个立方体放在原点可以考虑到所有相对位置的情况。而把一边的立方体放在原点有可能会漏掉一部分情况，就像下面那个写法。所以三维的还是把中间的模型放在原点比较好。

code：

#include <iostream>
#include <cstdio>
using namespace std;

int v1,v2,v3;

inline int gv(int x1,int y1,int z1,int x2,int y2,int z2){
	int xl,xu,yl,yu,zl,zu;
	xl=max(x1,x2);
	xu=min(x1,x2)+7;
	yl=max(y1,y2);
	yu=min(y1,y2)+7;
	zl=max(z1,z2);
	zu=min(z1,z2)+7;
	if(xl<xu && yl<yu && zl<zu)return (xu-xl)*(yu-yl)*(zu-zl);
	else return 0;
}
inline int gv(int x1,int y1,int z1,int x2,int y2,int z2,int x3,int y3,int z3){
	int xl,xu,yl,yu,zl,zu;
	xl=max(max(x1,x2),x3);
	xu=min(min(x1,x2),x3)+7;
	yl=max(max(y1,y2),y3);
	yu=min(min(y1,y2),y3)+7;
	zl=max(max(z1,z2),z3);
	zu=min(min(z1,z2),z3)+7;
	if(xl<xu && yl<yu && zl<zu)return (xu-xl)*(yu-yl)*(zu-zl);
	else return 0;
}

int main(){
	cin>>v1>>v2>>v3;
	for(int x1=-7,tot=1029,ab,bc,ac,abc,V1,V2,V3;x1<=15;x1++)
		for(int y1=-7;y1<=15;y1++)
			for(int z1=-7;z1<=15;z1++)
				for(int x2=-7;x2<=15;x2++)
					for(int y2=-7;y2<=15;y2++)
						for(int z2=-7;z2<=15;z2++){
							ab=gv(0,0,0,x1,y1,z1);
							bc=gv(x1,y1,z1,x2,y2,z2);
							ac=gv(0,0,0,x2,y2,z2);
							abc=gv(0,0,0,x1,y1,z1,x2,y2,z2);
							V3=abc;
							V2=ab+bc+ac-3*V3;
							V1=tot-2*(ab+bc+ac-abc)+abc;
							if(V1==v1 && V2==v2 && V3==v3){
								printf("Yes\n%d %d %d %d %d %d %d %d %d\n",0,0,0,x1,y1,z1,x2,y2,z2);
								return 0;
							}
						}
	puts("No");
	return 0;
}

F - Second Largest Query

题意：

有一个 $N$ 个数的序列 $A_1,A_2,A_3,\dots,A_N$ 。

有 $Q$ 次操作，操作有两种：

1 p x：表示将 $A_p$ 赋值为 $x$ 。
2 l r：表示询问区间 $[l, r]$ 的次大值的个数。

思路：

这种问法一眼线段树，主要是如何维护次大值。

在两个区间进行合并的时候，有可能成为次大值的可能是左区间的最大值，次大值，右区间的最大值次大值。所以每个区间我们要维护区间最大值和次大值。而询问的是次大值的个数，所以我们最大值和次大值的个数也要维护。

写起来情况讨论比较麻烦，其他还好。

code：

#include <iostream>
#include <cstdio>
using namespace std;
const int maxn=2e5+5;

int n,q;

struct segment_tree{
	#define ls p<<1
	#define rs p<<1|1
	
	int n;
	struct Node{
		int m1,m2,c1,c2;
		Node(int m1=0,int m2=0,int c1=0,int c2=0):m1(m1),m2(m2),c1(c1),c2(c2){};
	}tr[maxn<<2];
	
	Node merge_Node(Node a,Node b){
		Node t;
		if(a.m1==b.m1){
			t.m1=a.m1;
			t.c1=a.c1+b.c1;
			if(a.m2==b.m2){
				t.m2=a.m2;
				t.c2=a.c2+b.c2;
			}
			else if(a.m2>b.m2){
				t.m2=a.m2;
				t.c2=a.c2;
			}
			else {
				t.m2=b.m2;
				t.c2=b.c2;
			}
		}
		else if(a.m1>b.m1){
			t.m1=a.m1;
			t.c1=a.c1;
			if(a.m2==b.m1){
				t.m2=a.m2;
				t.c2=a.c2+b.c1;
			}
			else if(a.m2>b.m1){
				t.m2=a.m2;
				t.c2=a.c2;
			}
			else {
				t.m2=b.m1;
				t.c2=b.c1;
			}
		}
		else {
			t.m1=b.m1;
			t.c1=b.c1;
			if(a.m1==b.m2){
				t.m2=a.m1;
				t.c2=a.c1+b.c2;
			}
			else if(a.m1>b.m2){
				t.m2=a.m1;
				t.c2=a.c1;
			}
			else {
				t.m2=b.m2;
				t.c2=b.c2;
			}
		}
		return t;
	}
	
	void print(int p,int l,int r){
		printf("%2d:[%d,%d] %d %d|%d %d\n",p,l,r,tr[p].m1,tr[p].c1,tr[p].m2,tr[p].c2);
		if(l==r)return;
		int mid=(l+r)>>1;
		print(ls,l,mid);
		print(rs,mid+1,r);
	}
	void print(){
		print(1,1,n);
	}
	
	void build(int p,int l,int r){
		if(l==r){
			cin>>tr[p].m1;
			tr[p].c1=1;
			return;
		}
		int mid=(l+r)>>1;
		build(ls,l,mid);
		build(rs,mid+1,r);
		tr[p]=merge_Node(tr[ls],tr[rs]);
	}
	void build(int _n){
		n=_n;
		build(1,1,n);
	}
	
	void mdy(int p,int l,int r,int idx,int x){
		if(l==r){
			tr[p].m1=x;
			return;
		}
		int mid=(l+r)>>1;
		if(idx<=mid)mdy(ls,l,mid,idx,x);
		else mdy(rs,mid+1,r,idx,x);
		tr[p]=merge_Node(tr[ls],tr[rs]);
	}
	Node query(int p,int l,int r,int L,int R){
		if(L<=l && r<=R){
			return tr[p];
		}
		int mid=(l+r)>>1;
		if(R<=mid)return query(ls,l,mid,L,R);
		else if(L>mid)return query(rs,mid+1,r,L,R);
		else return merge_Node(query(ls,l,mid,L,R),query(rs,mid+1,r,L,R));
	}
	
	int opt(int op,int a,int b){
		if(op==1)mdy(1,1,n,a,b);
		else {
			return query(1,1,n,a,b).c2;
		}
		return 0;
	}
	
	#undef ls
	#undef rs
}tr;

int main(){
	cin>>n>>q;
	tr.build(n);
//	tr.print();
//	puts("");
	for(int i=1,op,a,b;i<=q;i++){
		cin>>op>>a>>b;
		if(op==2)cout<<tr.opt(op,a,b)<<endl;
		else tr.opt(op,a,b);
//		tr.print();
//		puts("");
	}
	return 0;
}