Educational Codeforces Round 99 (Rated for Div. 2) （FG咕咕）

A. Strange Functions

大意：

定义(f(x))是去除x的后缀0，给出一个数n，问([1,n])中

[g(x)=frac {x}{f(f(x))} ]

的有多少不同的取值

思路：

直接输出输入字符串的长度即可

#include<bits/stdc++.h>

using namespace std;

const int N = 1e6 + 5;
typedef long long LL;
int n;
int main(){
    cin >> n;
    while(n--){
        string s;
        cin >> s;
        cout << s.size() << endl;
    }
    return 0;
}

B. Jumps

大意：

从0开始，第k次跳跃可以选择后退一步或者前进k步，给出一个n，问最少多少步可以到n

思路：

写了个bfs结果T了，利用这个bfs打了个表发现了规律：对于第k步，可以到达的范围是k的前缀和，除了k的前缀和-1的位置，所以可以直接预处理一下前缀和，判断一下位置关系即可

#include<bits/stdc++.h>

using namespace std;

const int N = 1e7 + 5;
queue<int> q;
int vis[2*N],n,t,pre[N];
int main(){
    for (int i = 1; i < 3000;i++){
        pre[i] = pre[i - 1] + i;
    }
    cin >> t;
    while(t--){
        cin >> n;
        for (int i = 1; i < 3000;i++){
            if(pre[i]>=n){
                if(pre[i]-n==1){
                    cout << i + 1 << endl;
                }
                else{
                    cout << i << endl;
                }
                break;
            }
        }
    }

    return 0;
}

C. Ping-pong

大意：

A和B打乒乓球，分别有体力a和b，每次击球都会消耗一次体力，A先发球，对于每次来球，每个人都可以选择打或不打，如果不打则对方得分，得分的人继续发球（如果没有体力则换人发球），直到两个人都没有体力。问A和B都想使自己赢得局数尽可能多，然后使对方赢得尽可能少，问最后比分为多少

思路：

对于B来说，为了使自己的体能都拿下尽可能多的局数，首先需要放弃击球，直到A使用最后一次体力发球，然后B反击，这样A没有体力击球，B拿下一分，然后随意击球即可，这样可以获得最大的局数，同时使对方少得一次分，可以发现这对于A来说也是最优的

#include<bits/stdc++.h>

using namespace std;

const int N = 1e6 + 5;
typedef long long LL;
int a, b;
int main(){
    int n;
    cin >> n;
    while(n--){
        cin >> a >> b;
        cout << a - 1 << ' ' << b << endl;
    }
    return 0;
}

D Sequence and Swaps

大意：

给出n和x，以及n个元素的数组(a_i)，每次可以选择一个大于x的数和x交换，最后要求数组为不下降数组，问最少要进行几次交换（如果不能就输出-1）

思路：

直接从前到后暴力求即可

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

const int N = 1e6 + 5;
int a[N],n,x,t,cnt,st[N];

int main(){
    cin>>t;
    while(t--){
        cin>>n>>x;
        bool flag=true;
        for(int i=1;i<=n;i++)cin>>a[i];
        for(int i=2;i<=n;i++){
            if(a[i]<a[i-1]){
                flag=false; break;
            }
        }
        int res=0;
        while(!flag){
            bool re=false;
            for(int i=1;i<=n;i++){
                if(a[i]>x){
                    re=true; res++;
                    swap(a[i],x);
                    break;
                }
            }
            if(!re)break;
            flag=true;
            for(int i=2;i<=n;i++){
                if(a[i]<a[i-1]){
                    flag=false; break;
                }
            }
        }
        if(flag)
            cout<<res<<endl;
        else
            cout << "-1" << endl;
    }
    return 0;
}

E Four Points

大意：

二维平面上有四个点，现在想让这四个点形成与坐标轴平行的正方形（正方形也可以是一个点），每次操作可以让其中一个点往上下左右移动一个单位距离，问最小的操作次数是多少。

思路：

见：https://blog.csdn.net/qq_41765114/article/details/110506665

分别计算x和y的贡献，然后相加，再加上特殊情况，最后全排列求所有答案

#include<bits/stdc++.h>

using namespace std;

const int N = 1e6 + 5;
typedef long long LL;
LL pos[5][2],t,ord[4]={0,1,2,3};
int main(){
    cin>>t;
    while(t--){
        LL res = 0x3f3f3f3f3f3f;
        for (int i = 0; i < 4; i++){
            cin >> pos[i][0] >> pos[i][1];
            ord[i] = i;
        }
        do{
            int p1 = ord[0], p2 = ord[1], p3 = ord[2], p4 = ord[3];

            LL x_len1 = min(abs(max(pos[p4][0], pos[p3][0] )- min(pos[p2][0], pos[p1][0])),
                            abs(min(pos[p4][0], pos[p3][0] )- max(pos[p2][0], pos[p1][0])));
            LL x_len2 = max(abs(max(pos[p4][0], pos[p3][0] )- min(pos[p2][0], pos[p1][0])),
                            abs(min(pos[p4][0], pos[p3][0] )- max(pos[p2][0], pos[p1][0])));

            LL y_len1 = min(abs(max(pos[p4][1], pos[p2][1] )- min(pos[p3][1], pos[p1][1])),
                            abs(min(pos[p4][1], pos[p2][1] )- max(pos[p3][1], pos[p1][1])));
            LL y_len2 = max(abs(max(pos[p4][1], pos[p2][1] )- min(pos[p3][1], pos[p1][1])),
                            abs(min(pos[p4][1], pos[p2][1] )- max(pos[p3][1], pos[p1][1])));
            
            res = min(res, 
                        max(pos[p1][0],pos[p2][0])-min(pos[p1][0],pos[p2][0])+
                        max(pos[p3][0],pos[p4][0])-min(pos[p3][0],pos[p4][0])+
                        max(pos[p1][1],pos[p3][1])-min(pos[p1][1],pos[p3][1])+
                        max(pos[p4][1],pos[p2][1])-min(pos[p4][1],pos[p2][1])+
                        2*max(0LL,max(x_len1,y_len1)-min(x_len2,y_len2)));
        } while (next_permutation(ord, ord + 4));
        cout << res << endl;
    }
    return 0;
}