WaWa的奇妙冒险（第十八周集训自闭现场）

这周并没有怎么刷题，大概切了几个水题，做个记录

洛谷 P1198 [JSOI2008]最大数

题意：查询末尾L个数字中的最大数，以及添加操作

思路：线段树模板题，敲一遍线段树秒过，水题时间

#include 
#define mid (l+r) >> 1;
#define lson rt << 1,l,m
#define rson rt << 1|1,m+1,r
using namespace std;
typedef long long ll;
const int N = 2e5+5;

ll tree[N << 2];

void pushup(int rt){
	tree[rt] = max(tree[rt << 1],tree[rt << 1|1]);
	return ;
}

void build(int rt,int l,int r){
	tree[rt] = 0;
	if(l == r) return ;
	int m = mid;
	build(lson);
	build(rson);
	return ;
}

void update(int rt,int l,int r,int val,int pos){
	if(l == r){
		tree[rt] = val;
		return ;
	}
	int m = mid;
	if(pos <= m) update(lson,val,pos);
	else update(rson,val,pos);
	pushup(rt);
	return ;
}

inline ll query(int rt,int l,int r,int L,int R){
	if(L <= l && r <= R) return tree[rt];
	int m = mid;
	ll ans = 0;
	if(L <= m) ans = max(ans,query(lson,L,R));
	if(R > m) ans = max(ans,query(rson,L,R));
	return ans;
}

inline ll read(){
	register ll s = 0,m = 1;
	register char ch = getchar();
	while(ch < '0' || ch > '9'){if(ch == '-') m = -1;ch = getchar();}
	while(ch >= '0' && ch <= '9'){s = (s<<1)+(s<<3)+(ch^48);ch = getchar();}
	return m*s;
}

int main()
{
	ll t = 0,m,d,ad,cnt = 0;
	char op;
	m = read();
	d = read();
	build(1,1,m);
	for(int i = 1;i <= m;++i){
		scanf(" %c",&op);
		ad = read();
		if(op == 'A'){
			ad = (ad+t) % d;
			update(1,1,m,ad,++cnt);
		}
		else{
			t = query(1,1,m,cnt-ad+1,cnt);
			printf("%lld\n",t);
		}
	}
	return 0;
} 

洛谷 P2023 [AHOI2009]维护序列

题意：实现区间乘法运算和加法运算

思路：线段树和二重标记，之前做过一点异或和改变值的，乘法和加法结合还真是第一次做，大概思考了一下，后来的乘法会对前面滞留的加法lazy标记产生影响，每次下推的时候先推乘法后推加法就完事了。。。，算是比较裸的线段树题目了

#include 
#define mid (l+r) >> 1;
#define ls rt << 1
#define rs rt << 1|1
#define lson ls,l,m
#define rson rs,m+1,r
using namespace std;
typedef long long ll;
const int N = 1e5+5;

ll tree[N << 2],add[N << 2],mul[N << 2];
ll p;

void pushup(int rt){
	tree[rt] = (tree[ls]%p+tree[rs]%p)%p;
	return ;
}

void pushdown(int rt,int ln,int rn){
	if(mul[rt] != 1){
		tree[ls] = (tree[ls]*mul[rt])%p;
		tree[rs] = (tree[rs]*mul[rt])%p;
		mul[ls] = (mul[ls]*mul[rt])%p;
		mul[rs] = (mul[rs]*mul[rt])%p;
		add[ls] = (add[ls]*mul[rt])%p;
		add[rs] = (add[rs]*mul[rt])%p;
		mul[rt] = 1;
	}
	if(add[rt]){
		tree[ls] = (tree[ls]+add[rt]*ln%p)%p;
		tree[rs] = (tree[rs]+add[rt]*rn%p)%p;
		add[ls] = (add[ls]+add[rt])%p;
		add[rs] = (add[rs]+add[rt])%p;
		add[rt] = 0;
	}
	return ;
}

void build(int rt,int l,int r){
	add[rt] = 0;
	mul[rt] = 1;
	if(l == r){
		scanf("%lld",&tree[rt]);
		return ;
	}
	int m = mid;
	build(lson);
	build(rson);
	pushup(rt);
	return ;
}

void update(int rt,int l,int r,int L,int R,int c,int op){
	if(L <= l && r <= R){
		if(op){
			tree[rt] = (tree[rt]+c*(r-l+1)%p)%p;
			add[rt] = (add[rt]+c)%p;
		}
		else{
			tree[rt] = (tree[rt]*c)%p;
			add[rt] = (add[rt]*c)%p;
			mul[rt] = (mul[rt]*c)%p;
		}
		return ;
	}
	int m = mid;
	pushdown(rt,m-l+1,r-m);
	if(L <= m) update(lson,L,R,c,op);
	if(R > m) update(rson,L,R,c,op);
	pushup(rt);
	return ;
}

inline ll query(int rt,int l,int r,int L,int R){
	if(L <= l && r <= R) return tree[rt];
	int m = mid;
	pushdown(rt,m-l+1,r-m);
	ll ans = 0;
	if(L <= m) ans = (ans+query(lson,L,R))%p;
	if(R > m) ans = (ans+query(rson,L,R))%p;
	return ans%p;
}

int main()
{
	ll c,t,g,m,n,op;
	scanf("%lld%lld",&n,&p);
	build(1,1,n);
	scanf("%lld",&m);
	while(m--){
		scanf("%lld%lld%lld",&op,&t,&g);
		if(op == 1 || op == 2){
			scanf("%lld",&c);
			update(1,1,n,t,g,c%p,op-1);
		}
		else printf("%lld\n",(query(1,1,n,t,g)+p)%p);
	}
	return 0;
} 

洛谷 P1111 修复公路

题意：问如何修复公路能在最短时间内通车。

思路：修复公路的时间可以看做是边的权值，直接跑一棵最小生成树即可，因为公路的修建是可以同时进行的，所以树的权值即是权值最大边的权值。

#include 
#define rg register
using namespace std;
typedef long long ll;
const int N = 1e5+5;

struct node{
	int u,v,t;
} e[N];
int pre[N];

bool comp(node a,node b){
	return a.t < b.t;
}

void init(int n){
	for(int i = 1;i <= n;++i) pre[i] = i;
	return ;
}

inline int find(int x){
	return pre[x] = pre[x] == x ?x :find(pre[x]);
}

inline ll kal(int n,int m){
	ll ans = 0;
	int cnt = 0;
	for(int i = 1;i <= m;++i){
		int u = find(e[i].u);
		int v = find(e[i].v);
		if(u != v){
			pre[u] = v;
			cnt++;
			ans = e[i].t;
		}
		if(cnt == n-1) break;
	}
	return cnt == n-1 ?ans :-1;
}

int main()
{
	int n,m;
	scanf("%d%d",&n,&m);
	init(n);
	for(int i = 1;i <= m;++i) scanf("%d%d%d",&e[i].u,&e[i].v,&e[i].t);
	sort(e+1,e+m+1,comp);
	printf("%lld\n",kal(n,m));
	return 0;
}

洛谷 P2320 [HNOI2006]鬼谷子的钱袋

题意：问鬼谷子的钱最少能分多少个钱袋，使所有的钱数都可以用加法获得。

思路：
（错误思路） 因为之前写过一个题目：问组成1到n最少要用几个数字，可以拆成二进制求解，所以原思路是二进制求解，多出来的分一个1再把剩下的加到2上，但这样实际上导致了同时用到1、2的情况无解。（但是代码能ac，数据太水了。。。）

（正确思路）可以发现，对于n可以有n/2内的数字相加得到，直接除二到除尽即可，对于奇数特判加1即可。

错误代码

#include 
#define rg register
using namespace std;
typedef long long ll;

vector <ll> ans;

int main()
{
	ll n,i = 0;
	scanf("%lld",&n);
	while(n >= (1 << i)){
		ans.push_back(1 << i);
		n -= (1 << i);
		i++;
	}
	
	if(n){
		if(n & 1) ans.push_back(n);
		else ans[1] += n-1,ans.push_back(1);
	}
	sort(ans.begin(),ans.end());
	printf("%d\n",ans.size());
	for(int i = 0;i < ans.size();++i) printf("%lld%c",ans[i],i == ans.size()-1 ?'\n' :' ');
	return 0;
}

正确代码

#include 
#define rg register
using namespace std;
typedef long long ll;

vector <ll> ans;

int main()
{
	ll n,i = 0;
	scanf("%lld",&n);
	while(n){
		if(n & 1) ans.push_back(n/2+1);
		else ans.push_back(n/2);
		n >>= 1;
	}
	sort(ans.begin(),ans.end());
	printf("%d\n",ans.size());
	for(int i = 0;i < ans.size();++i) printf("%lld%c",ans[i],i == ans.size()-1 ?'\n' :' ');
	return 0;
}

洛谷 P1199 三国游戏

题意：玩家先手选取，电脑会选择选取和玩家当前拥有武将默契值最高的武将（即破坏玩家的最佳组合），问玩家能否获胜以及能得到的最大默契度。

思路：刚开始以为是博弈论，推了一下发现，因为电脑只会无脑打断玩家的最佳组合，那玩家必然能得到默契度第二大的组合，第一大的已经被破坏，电脑选的武将的默契度必然比玩家低。所以这只是一道极度无脑的水题。。。

#include 
using namespace std;
const int N = 5e2+5;

vector <int> s[N];

int main()
{
	int v,n,ans = 0;
	scanf("%d",&n);
	for(int i = 1;i < n;++i){
		for(int j = i+1;j <= n;++j){
			scanf("%d",&v);
			s[i].push_back(v);
			s[j].push_back(v);
		}
	}
	
	for(int i = 1;i <= n;++i){
		sort(s[i].begin(),s[i].end(),greater<int>());
		ans = max(ans,s[i][1]);
	}
	printf("1\n%d\n",ans);
	return 0;
}

洛谷 P1984 [SDOI2008]烧水问题

题意：烧开水，每杯水烧开一次即可，还有一个热传递的操作，能使两杯水的温度平均分，问所要花的最小热量为多少。

思路：稍微一下贪心即可，对于每杯烧开的水，都拿去依次和后面的杯子热传递一遍，必然能提升后面杯子的温度。emm 数学公式有点影子但确实退不出来，打表找规律发现，每杯需要的温度，符合(2*n-1)/2n的递推规律，然后就能写了。（后来看了题解大佬的数学推理，确实是道简单数论，是我太菜了，只能找规律）。

#include 
using namespace std;
const int N = 3e6+5;

double cap[N];

int main()
{
	int n;
	scanf("%d",&n);
	double k = 100.0,g = 2;
	double ans = k/(double)n*4200;
	for(int i = 2;i <= n;++i){
		k *= ((g-1)/g);
		g += 2;
		ans += k/(double)n*4200;
	}
	printf("%.2lf\n",ans);
	return 0;
} 

洛谷 P1613 跑路

题意：小a可以用一点费用走2^k步，问走到终点的最小费用。

思路：这道题刚开始给疯狂卡思路，感觉是预处理建图然后跑最短路，因为规模很小，只要把图建出来，跑floyd都是可以的，因为是2^k步，找金总讨论了一下，感觉符合倍增的模型（前段时间学LCA、RMQ的时候接触的），想着dp一下，用倍增的方式把边处理起来，最外层枚举长度，里面枚举起点和终点，但发现dp不出来？说着说着忽然想到再枚举一个中间点就完事了。。。（这不就是ST里面套一个floyd的闭包传递吗。。。当时没看出来），接着和金总说了一下，感觉floyd这种能无视图中的环跑出正确结果（之前在想里面无限跑一个环凑到步数为止）。

#include 
using namespace std;
typedef long long ll;
const int INF = 0x3f3f3f3f;

int p[64][55][55],d[55][55];

void ST(int n){
	for(int l = 1;l < 64;++l){
		for(int k = 1;k <= n;++k){
			for(int i = 1;i <= n;++i){
				for(int j = 1;j <= n;++j){
					if(p[l-1][i][k] && p[l-1][k][j]){
						p[l][i][j] = 1;
						d[i][j] = 1;
					}
				}
			}
		}
	}
	return ;
}

void floyd(int n){
	for(int k = 1;k <= n;++k){
		for(int i = 1;i <= n;++i){
			if(d[i][k] != INF){
				for(int j = 1;j <= n;++j){
					if(d[k][j] != INF){
						d[i][j] = min(d[i][j],d[i][k]+d[k][j]);
					}
				}
			}
		}
	}
	return ;
}

int main()
{
	int u,v,n,m;
	scanf("%d%d",&n,&m);
	memset(p,0,sizeof(p));
	memset(d,INF,sizeof(d));
	
	for(int i = 1;i <= m;++i){
		scanf("%d%d",&u,&v);
		d[u][v] = p[0][u][v] = 1;
	}
	
	ST(n);
	floyd(n);
	printf("%d\n",d[1][n]);
	return 0;
}

洛谷 P1082 同余方程

题意：给一个同余方程，求解x的最小正解。

思路：虽然暑假里扩展欧几里得没学好，但这么裸的模板题还是完全没问题的。

#include 
using namespace std;
typedef long long ll;
const int INF = 0x3f3f3f3f;

void exgcd(int a,int b,int &x,int &y){
	if(!b){
		x = 1,y = 0;
		return ;
	}
	exgcd(b,a%b,y,x);
	y -= (a/b)*x;
	return ;
}

int main()
{
	int x,y,a,b;
	scanf("%d%d",&a,&b);
	exgcd(a,b,x,y);
	x = (x+b)%b;
	printf("%d\n",x);
	return 0;
}

洛谷 P1134 阶乘问题

题意：计算阶乘值最右边的非零位的值。

思路：这题我肯定在哪遇见过，印象太深刻了。。。对于已经为0的位置，在算乘法是无用的了，所以无脑吧0消掉就好了，但这题数据有点东西。。。取余的数字不对以及取余的位置不对就会tle（溢出到负数去了），然后明明感觉写过的我，交了5、6发才过。。。实在是太菜了。

#include 
using namespace std;
typedef long long ll;
const int INF = 0x3f3f3f3f;
const ll M = 1e7;

int main()
{
	ll n;
	scanf("%lld",&n);
	
	ll ans = 1;
	for(ll i = 2;i <= n;++i){
		ans *= i;	
		while(!(ans%10)) ans /= 10;
		ans %= M;
	}
	
	printf("%lld\n",ans%10);
	return 0;
}

2019icpc南京 A. Hard Problem

题意：1到N，问最小k原组能保证组内至少有一队数字不互质。

思路：很容易想到质数数量+1去，别问，问就是思维不行，实际推法可以发现，对于最大值n而言，直到n/2，都不会有数字互质，所以把这中间的值加上，然后再加1即可。

#include 
using namespace std;

int main()
{
	int n,T;
	scanf("%d",&T);
	while(T--){
		scanf("%d",&n);
		printf("%d\n",(n+1)/2+1);
	}
	return 0;
}

2019icpc南京 H. Prince and Princess

题意：问最小询问几次能找出公主所在的房间。

思路：发现前两个问题一点用都没有，然后直接把中立的人当反对的人看，直接考虑最坏清空，可以发现当b+c >= a，是不可能找到公主的，反之，询问（b+c）*2+1次就可以找到公主了，但是要考虑100的情况。。。因为只有一个人，那那个就只能是公主了。。。就不用询问了。

#include 
using namespace std;

int main()
{
	int a,b,c;
	scanf("%d%d%d",&a,&b,&c);
	if(b == 0 && c == 0){
		if(a == 1) printf("YES\n0\n");
		else printf("YES\n1\n");
	}
	else if(a > b+c){
		printf("YES\n%d\n",(b+c)*2+1);
	}
	else printf("NO\n");
	return 0;
}

2019icpc南京 K. Triangle

题意：给一个三角形，和三角形上的一个点，要求你找到另一个点，使连接的这条线能平分三角形的面积。

思路：这道数学题，真的不是我擅长的，但找到一个直接找点的方法https://zhidao.baidu.com/question/417422411.html，里面的第一个回答就是了，然后直接开始写代码，发现wa了无数发。。。然后和旁边要去ecfinal的队伍交流了一下，说是加了一个找到点之后再判一次是否再边上就过了，emm 我也加了一个，然后就过了。。。（wtf!!!，怀疑是精度问题？？？）

#include 
using namespace std;
const double eps = 1e-8;

struct node{
	double x,y;
	node(){}
	node(double x,double y):x(x),y(y){}
} p[4];

inline double cal_dis(node a,node b){
	double s = b.y-a.y;
	double t = b.x-a.x;
	return sqrt(s*s+t*t);
}

inline bool judge_p_b(){
	if(p[0].x == p[1].x && p[0].y == p[1].y) {printf("%.12lf %.12lf\n",(p[3].x+p[2].x)/2.0,(p[3].y+p[2].y)/2.0);return 1;}
	if(p[0].x == p[2].x && p[0].y == p[2].y) {printf("%.12lf %.12lf\n",(p[3].x+p[1].x)/2.0,(p[3].y+p[1].y)/2.0);return 1;}
	if(p[0].x == p[3].x && p[0].y == p[3].y) {printf("%.12lf %.12lf\n",(p[1].x+p[2].x)/2.0,(p[1].y+p[2].y)/2.0);return 1;}
	if(p[0].x == (p[1].x+p[2].x)/2.0 && p[0].y == (p[1].y+p[2].y)/2.0) {printf("%.12lf %.12lf\n",p[3].x,p[3].y);return 1;}
	if(p[0].x == (p[1].x+p[3].x)/2.0 && p[0].y == (p[1].y+p[3].y)/2.0) {printf("%.12lf %.12lf\n",p[2].x,p[2].y);return 1;}
	if(p[0].x == (p[2].x+p[3].x)/2.0 && p[0].y == (p[2].y+p[3].y)/2.0) {printf("%.12lf %.12lf\n",p[1].x,p[1].y);return 1;}
	return 0;
}

inline bool check(double c){
	if(c <= eps && c >= -eps) return 1;
	return 0;
}

void slove(double bl,node u,node v,node t){
	node o((u.x+v.x)/2.0,(u.y+v.y)/2.0);	
	if(u.x == v.x){
		double dis_y = o.y-u.y;
		node ans(o.x,o.y+dis_y*bl);
		if(check(cal_dis(ans,u)+cal_dis(ans,v)-cal_dis(u,v))) printf("%.12lf %.12lf\n",ans.x,ans.y);
		else printf("-1\n");
		return ;
	}
	else if(u.y == v.y){
		double dis_x = o.x-u.x;
		node ans(o.x+dis_x*bl,o.y);
		if(check(cal_dis(ans,u)+cal_dis(ans,v)-cal_dis(u,v))) printf("%.12lf %.12lf\n",ans.x,ans.y);
		else printf("-1\n");
		return ;
	}
	else{
		double dis_x = o.x-u.x;
		double dis_y = o.y-u.y;
		node ans(o.x+dis_x*bl,o.y+dis_y*bl);
		if(check(cal_dis(ans,u)+cal_dis(ans,v)-cal_dis(u,v))) printf("%.12lf %.12lf\n",ans.x,ans.y);
		else printf("-1\n");
		return ;
	}
}

int main()
{
	int T;
	scanf("%d",&T);
	while(T--){
		scanf("%lf%lf%lf%lf%lf%lf%lf%lf",&p[1].x,&p[1].y,&p[2].x,&p[2].y,&p[3].x,&p[3].y,&p[0].x,&p[0].y);
		
		double dis_12 = cal_dis(p[1],p[2]);
		double dis_13 = cal_dis(p[1],p[3]);
		double dis_23 = cal_dis(p[2],p[3]);
		
		if(judge_p_b()) continue;
		
		node u,v,t;
		if(check(dis_12-cal_dis(p[0],p[1])-cal_dis(p[0],p[2]))) u = p[1],v = p[2],t = p[3];
		else if(check(dis_13-cal_dis(p[0],p[1])-cal_dis(p[0],p[3]))) u = p[1],v = p[3],t = p[2];
		else if(check(dis_23-cal_dis(p[0],p[2])-cal_dis(p[0],p[3]))) u = p[2],v = p[3],t = p[1];
		else{printf("-1\n");continue;}
		
		double dis_u = cal_dis(p[0],u);
		double dis_v = cal_dis(p[0],v);
		
		if(dis_u/dis_v > 1) slove(dis_v/dis_u,u,t,v);
		else slove(dis_u/dis_v,v,t,u);
	}
	return 0;
}

2019icpc南京 C. Digital Path

题意：要求你找出图中有几个严格递增且长度大于等于4的路径

思路：之前暴力dfstle了，悄悄听了一会去ecfinal的大佬们的思路，分两种情况处理，对于每个点，如果是起始点（周围没有比他小一的点），从他开始dfs4步，给走到的地方权值加1，对于非起始点，把他的值推到所有相邻的值大一的点上去，并把自己的权值清零，没有的话不做操作。

但是还是wa了好几发。。。后来才发现，-1 0 1 2这种也是可行的路径。

中间自己想的一个思路想到一般的时候他们发现的。。。自己想的那个也是可行的，但还没写，矩阵转树，然后在树上做一个递推（非dp，没那么难），即当前长度为4的值为前一个结点长度为3的值，然后跑一遍拓扑排序即可，有时间会再写一个，赖队去南京写的和我这个差不多，但好一些，人家没先转成图，但思路是一样的。

#include 
using namespace std;
typedef long long ll;
const int N = 1e3+5;
const ll M = 1e9+7;

struct node{
	int x,y,val;
	node(int x,int y,int val):x(x),y(y),val(val){}
};

vector <node> p;
int maps[N][N],n,m;
int mvx[] = {1,0,0,-1};
int mvy[] = {0,1,-1,0};
ll v[N][N];

bool cmp(node a,node b){
	return a.val < b.val;
}

inline int read(){
	register int s = 0,m = 1;
	register char ch = getchar();
	while(ch < '0' || ch > '9') {if(ch == '-') m = -1;ch = getchar();}
	while(ch >= '0' && ch <= '9') {s = (s << 3)+(s << 1)+(ch^48);ch = getchar();}
	return m*s;
}

void cins(){
	for(int i = 1;i <= n;++i){
		for(int j = 1;j <= m;++j){
			maps[i][j] = read();
			p.push_back(node(i,j,maps[i][j]));
		}
	}
	sort(p.begin(),p.end(),cmp);
	return ;
}

inline bool check(int x,int y,int k){
	if(x < 1 || x > n || y < 1 || y > m || maps[x][y] != k) return 0;
	return 1;
}

void dfs(int x,int y,int k){
	if(maps[x][y] == k){
		v[x][y]++;
		v[x][y] %= M;
		return ;
	}
	
	for(int i = 0;i < 4;++i){
		int tx = x+mvx[i];
		int ty = y+mvy[i];
		if(check(tx,ty,maps[x][y]+1)) dfs(tx,ty,k);
	}
	return ;
}

void init(){
	for(int i = 1;i <= n;++i){
		for(int j = 1;j <= m;++j){
			v[i][j] = 0ll;
		}
	}
	return ;
}

inline bool judge(int x,int y){
	bool f = 1,flag = 0;
	for(int i = 0;i < 4;++i){
		int tx = x+mvx[i];
		int ty = y+mvy[i];
		if(tx < 1 || tx > n || ty < 1 || ty > m) continue;

		if(maps[tx][ty] == maps[x][y]+1) flag = 1,v[tx][ty] = (v[tx][ty]%M+v[x][y]%M)%M;
		if(maps[tx][ty] == maps[x][y]-1) f = 0;
	}
	if(flag) v[x][y] = 0;
	return f;
}

int main()
{
	n = read();
	m = read();
	init();
	cins();
	
	ll ans = 0;
	for(int i = 0;i < p.size();++i){
		node t = p[i];
		if(judge(t.x,t.y)) dfs(t.x,t.y,t.val+3);
	}
	
	for(int i = 1;i <= n;++i){
		for(int j = 1;j <= m;++j){
			ans = (ans+v[i][j]%M)%M;
		}
	}
	
	printf("%lld\n",(ans+M)%M);
	return 0;
}

Atcoder Sumitomo Mitsui Trust Bank Programming Contest 2019 D - Lucky PIN

题意：从序列中取三个值，然后按顺序排列，问不重复的值有多少个。

思路：n³复杂度必然超时，想了一下也就0~9总共10个数字，二进制hash一下，然后n²枚举没枚举过的前两个数字，然后增加贡献即可。（预处理从尾到头hash一遍即可）。
但是被zmh大佬暴力枚举000到999找位置的方法给完爆了。。。我就是个hape，思路不太行。

#include 
using namespace std;
const int N = 3e4+5;

int a[N],k[N];
bool vis[10][10];

inline int cal(int x){
	int res = 0;
	while(x){
		x -= (x&(-x));
		res++;
	}
	return res;
}

int main()
{
	int n;
	scanf("%d",&n);
	for(int i = 1;i <= n;++i) scanf("%1d",&a[i]);
	int t = 0;
	for(int i = n;i >= 1;--i){
		t |= (1 << a[i]);
		k[i] = t;
	}
	
	int ans = 0;
	for(int i = 1;i <= n-2;++i){
		for(int j = i+1;j <= n-1;++j){
			if(vis[a[i]][a[j]]) continue;
			vis[a[i]][a[j]] = 1;
			ans += cal(k[j+1]);
		}
	}
	
	printf("%d\n",ans);
	return 0;
}

Atcoder Sumitomo Mitsui Trust Bank Programming Contest 2019 E - Colorful Hats 2

题意：每个人有一个Ai值，表示前面有几个人和自己帽子颜色相同，总共就三种颜色，刚开始想复杂想着dp，发现要四重循环，复杂度完全不允许，同队大佬推了一个递推累乘，不用管具体颜色，只看数量即可。。。沾大佬的光，过了第5题。
（感觉原来dp思路保留二维那种，再推一推就出来了。。。我还是太菜了。。。）

#include 
using namespace std;
typedef long long ll;
const int N = 1e5+5;
const ll M = 1000000007;

int a[N],k[4];

int main()
{
	int x,n;
	scanf("%d",&n);
	memset(k,0,sizeof(k));
	
	ll ans = 1;
	for(int i = 1;i <= n;++i) scanf("%d",&a[i]);
	for(int i = 1;i <= n;++i){
		int sum = 0;
		for(int j = 1;j <= 3;++j){
			if(k[j] == a[i]) sum++;
		}
		ans = (ans*sum)%M;
		for(int j = 1;j <= 3;++j){
			if(k[j] == a[i]){
				k[j]++;
				break;
			}
		}
	} 
	
	printf("%lld\n",(ans+M)%M);
	return 0;
}

咸鱼了好久好久的我，总算回到洛谷橙名了，可喜可乐可喜可乐。