AtCoder Beginner Contest 221（A-D）

（转自atcoder官网）

A - Seismic magnitude scales

因为我们可以假设，当震级增加 1 时，它正好乘以 32 ，所以答案是 

根据约束条件， A和 B 是整数，  ， 因此，可以使用  语句计算它。在某些语言中，我们可以用求幂或  函数来找到它

#include <bits/stdc++.h>
using namespace std;

int main(void) {
	int a, b;
	int k = 1;
	cin >> a >> b;
	for (int i = b; i < a; i++)k *= 32;
	cout << k << endl;
	return 0;
}

B - typo

我们可以在不执行任何操作的情况下检查 S 和 T 是否相同，或者在每个  ，交换第  个和第  个字符时， 和  是否一致.

#include<bits/stdc++.h>
using namespace std;

int main(){
    string S,T; 
    cin >> S >> T;
    string ans = "No";
    if(S == T) ans = "Yes";
    for(int i=0; i<S.size(); i++){
        if(S[i] != T[i]){
            if(0 < i){
                swap(S[i-1],S[i]);
                if(S == T) ans = "Yes";
                swap(S[i-1],S[i]);
            }
            if(i+1 < S.size()){
                swap(S[i],S[i+1]);
                if(S == T) ans = "Yes";
                swap(S[i],S[i+1]);
            }
            break;
        }
    }
    cout << ans << endl;
    return 0；
}

C - Select Mul

最多有  种分离方式（或2903040/2=1451520，忽略两个分离整数的顺序时），这足够小。

因此，我们可以用暴力对付所有可能的分离方式。

在 c++ 中实现时，有一个有用的函数称为 next_permutation ，它包含在标准库  中。

#include<bits/stdc++.h>
using namespace std;

int main(){
    string N; 
    cin >> N;
    sort(N.begin(),N.end());
    int ans = 0;
    do{
        for(int i=1; i<N.size(); i++){
            string l = "", r = "";
            for(int j=0; j<i; j++) l += N[j];
            for(int j=i; j<N.size(); j++) r += N[j];
            if(l[0]=='0' || r[0]=='0') continue;
            ans = max(ans,stoi(l)*stoi(r));
        }
    }while(next_permutation(N.begin(),N.end()));
    cout << ans << endl;
    return 0；
}

再稍加观察，我们就会发现接受前导零并不影响结果。

#include<bits/stdc++.h>
using namespace std;

int main(){
    string N; 
    cin >> N;
    sort(N.begin(),N.end());//排序，next_permutation只能排已经排好序的全排列
    int ans = 0;
    do{
        for(int i=1; i<N.size(); i++){
            int l = 0, r = 0;
            for(int j=0; j<i; j++) l = l*10+N[j]-'0';//分割线左边的数值
            for(int j=i; j<N.size(); j++) r = r*10+N[j]-'0';//分割线右边的数值
            ans = max(ans,l*r);
        }
    }while(next_permutation(N.begin(),N.end()));//下一个排序
    cout << ans << endl;
    return 0；
}

进一步观察，我们可以看到，当达到最大值时，被分离的两个变量在被视为一个数字序列时是单调不递增的。

根据这个属性，我们可以看到应该检查的分离次数是（或 如果忽略两个分开的整数的顺序）。

在实现时，使用位强制暴力也是很简单的。

D - Online games

让 x1，x2，...，xn 是一个整数排序序列，由某些玩家开始或退出登录的天数组成；也就是说，X使X= Ai 或X= + 

然后，对于任意满足 X 的 <=Y<=  ，在第Y天登录的人数不变。同样，对于  的任何  或  ，  人登录，所以我们不必考虑这些天。因此，可以使用一个计数器和一个记录答案的数组来解决这个问题，计数器和数组初始化为  ，并针对每个  进行更新按照以下步骤进行操作：

· 递增计数器 X 我根据第 X 天开始登录的人数i，并减少退出登录的人数。

· 将 C 用户登录的天数增加 xi+1-xi ，其中  是计数器的当前值。

#include <bits/stdc++.h>
using namespace std;

#define N 200010
#define rep(i, n) for(int i = 0; i < n; ++i)

int main( ) {
	int n;
	int a, b;
	vector<pair<int, int> >x;
	int cnt;
	int ans[N];
	rep(i, N)ans[i] = 0;

	cin >> n;
	rep(i, n) {
		cin >> a >> b;
		x.push_back({ a,1 });
		x.push_back({ a + b,-1 });
	}

	sort(x.begin(), x.end());

	cnt = 0;
	rep(i, (x.size())-1) {
		cnt += x[i].second;
		ans[cnt] += ((x[i + 1].first) - (x[i].first));
	}

	rep(i, n - 1)cout << ans[i + 1] << " ";
	cout << ans[n] << endl;
	return 0;
}