Educational Codeforces Round 161 (Rated for Div. 2)（A~F)

这次的比赛感觉A题有点难懂题意，读起来很费劲，感冒了确实有点不在状态，继续加油吧。

A. Tricky Template

对这个题，我们可以想到一定要满足a,b与模板t匹配，而不匹配的时候只需要有一个位置上不满足即可，若是a和b其中有一个和c相等，并且a和b不相等，此时不管是大写还是小写，都注定不满足条件，但是若是有另外一个位置可以满足让c不能够匹配，此时其他位置就不需要关心c是否能进行匹配，此时c已经不符合模板t，因此若是所有结点均满足上述情况，说明不符合题意，其他情况均满足题意。

void solve() {
	int n;
	cin >> n;
	string s1,s2,s3;
	cin >> s1 >> s2 >> s3;
	int ans = 0;
	for(int i = 0 ;i < n ;i ++)
	{
		if((s1[i] != s2[i] && (s1[i]==s3[i] || s2[i] == s3[i])))
		{
			ans++;
		}
	}
	if(ans != n)
	cout << "YES" << endl;
	else
	cout << "NO" << endl;
}

B. Forming Triangles

这道题最初在写的时候没看到是2的n次方，贡献了好几发wa，但是当注意到后我们会发现，对于2的n次方，若是2 1 1 这种情况，此时满足的情况也是 2 + 2 = 4，不满足三角形的定义，因此我们可以想到对于这种情况，只有可能是等边三角形或者等腰三角形外加一条小于对应腰的边，因此我们采取map进行存储，将长度与边数存储，按照从小到大的顺序采取标识符记录出现过的边数进行计算。

void solve() {
	int n;
	cin >> n;
	vector<int>nums(n);
	for(auto &i : nums)
	cin >> i;
	int count = 0;
    map<int,int>ma; 
    for(auto i : nums)
    ma[i]++;
    int ans = 0,sum=0;
    for(auto i : ma)
    {
		sum += i.second * (i.second-1) / 2 * ans;     //选择两条等腰后乘以可以选择的小边
		sum += i.second * (i.second-1)*(i.second-2) / 6; //任选3个等边
    	ans += i.second;
	}
	cout << sum << endl;
}

C. Closest Cities

我们可以观察一下，当从一个顶点到左右两个顶点时，一定是一个权值为1，一个为|ax - ay|,我们可以想一下从1到5，最坏情况就是在这个过程中没有可以支付1金币的点，但是就算这样，我们仍旧可以选择从1 - 2 - 3 - 4 - 5这种情况来进行行走，因此确定最优的路线是唯一的，我们可以想到维护一个前缀和和一个后缀和来分别记录从1开始往前走和从n开始往回走的情况，首先采取标记数组来判断这个点距离最近的方向是左还是右，右的话标记为0，左的话标记为1，我们可以想到最左端向右一定是距离最近，最右端向左一定是距离最近。

void solve() {
	int n;
	cin >> n;
	vector<int>v(n);
	for(auto &i : v)
	cin >> i;
	int flag[n] = {0};
	flag[n-1]=1;
	for(int i = 1 ;i < n - 1 ;i ++)
	{
		if((v[i]-v[i-1]) > (v[i+1]-v[i]))
		flag[i] = 0;
		else
		flag[i] = 1;
	}
	vector<int>a(n,0),b(n,0);
	for(int i = 1 ;i < n ;i ++)
	{
		if(flag[i-1] == 0)
		 {
		 	a[i] = a[i-1] + 1;
		 }
		 else
		 a[i] = a[i-1] + v[i] - v[i-1]; 
	}
	for(int i = n - 2;i >=0 ;i --)
	{
		if(flag[i+1] == 1)
		{
			b[i] = b[i + 1] + 1;
		}
		else
		b[i] = b[i + 1] + v[i+1]-v[i];
	}
	int q;
	cin >> q;
	while(q--)
	{
		int x,y;
		cin >> x >> y;
		x--;y--;
		if(x < y)
		cout << a[y] - a[x] << endl;
		else
		cout << b[y] - b[x] << endl;
	}
}

D. Berserk Monsters

这道题是采取jls的思路，这道题的本质就是模拟，我们可以想到对于每个结点，我们都需要找他的左右两个相邻的结点，因此我们采取双向链表的写法，随后在每一次遍历的过程中找到死亡的结点，随后对左右节点的前驱和后继进行改变，我们可以知道，每一次遍历都会将死亡的结点进行消除，即改变了死亡结点的前驱和后继，而对于其他没有改变过的结点，他一定不能被消灭（因为左右结点都没有变化，若是消灭了在上一轮已经消灭），因此我们每次对被消灭的结点进行处理即可。

void solve() {
	int n;
	cin >> n;
	vector<int>a(n),d(n),l(n),r(n);
	for(auto &i : a)
	cin >> i;
	for(auto &i : d)
	cin >> i;
	for(int i = 0 ;i < n ;i ++)
	{
		l[i] = i - 1;
		r[i] = i + 1;
	}
	r[n - 1] = -1;
	vector<int>v;
	for(int i = 0 ;i < n ;i ++)
	v.push_back(i);
	vector<int>flag(n,-1);
	for(int i = 0 ;i < n ;i ++)
	{
		vector<int>die;
		for(auto x : v)
		{
			int sum = 0;
			if(l[x] != -1)
			{
				sum += a[l[x]];
			}
			if(r[x] != -1)
			{
				sum +=a[r[x]]; 
			}
			if(sum > d[x])
			{
				die.push_back(x);
				flag[x] = i;
			}
		}
		v.clear();
	   cout << die.size() << ' ';	
		for(auto x : die)
		{		
		       if(l[x] != -1)
				{
					r[l[x]] = r[x];
					if(flag[l[x]] < i)
					{
						v.push_back(l[x]);
						flag[l[x]] = i;
					}
				}
				if(r[x] != -1)
				{
					l[r[x]] = l[x];
					if(flag[r[x]] < i)
					{
						v.push_back(r[x]);
						flag[r[x]] = i;
					}
				}
		}
    }
    cout << endl;
}

E. Increasing Subsequences

这个E题，我们可以举个例子先，首先1 2 3 ，我们会发现若是不带空字符是7个，1 2 3 4 ，我们会发现若是不带空字符是15个，1 2 3 4 5，我们会发现若是不带空字符是31个，因此我们可以想到这道题是和二进制有关的一道题，而若是 (1,2,3,4,5,1)：我们会发现若是不带空字符是31 + 1个，若是(1,2,3,4,1,5)：31+2个，(1,2,3,1,4,5)：32+4个严格增子序列，因此我们会发现，对于数m，我们将其拆分为二进制，我们首先构造一个长度为n单调递增的序列（此时长度为m的二进制最高位，可以默认带上了空字符串），后面每次我们分析m的二进制，我们每次加入的数字k的实际权重为 2的（n - k)次方，我们采取栈的存储方式从后往前进行存放即可。在计算过程中我们使用__lg函数进行计算高位。

void solve() {
	int n;
	cin >> n;
	stack<int>s;
	int m = __lg(n); // 对数进行log2（n)函数 
	n -= (1ll << m);
	for(int i = m;i >= 1 ;i --)
	s.push(i);
	int flag[m] = {0};
	while(n)
	{
		int k = __lg(n);
		s.push(m - k);
		n-=1ll << k;
	}
	cout << s.size() << endl;
	while(!s.empty())
	{
		cout << s.top() << " ";
		s.pop();
	}
	cout << endl; 
}