CodeTON Round 1 (Div. 1 + Div. 2, Rated, Prizes)（ABCDE）

CodeTON Round 1 (Div. 1 + Div. 2, Rated, Prizes!)（ABCDE）

晚点补F题

A. Good Pairs

题意：
给出长度为n的序列，去找个两个坐标$i,j$(可以相同)，满足对于序列中的所有下标k,
满足公式$|a[i]-a[k]|+|a[k]-a[j]|=|a[i]-a[j]|$
思路：
发现样例输出的就是每个序列的最大值最小值的下标，猜测输出最大值和最小值对应的下标就行了
后面发现正确性：中间值是与最大值最小值差值的绝对值和等于最大值-最小值。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=1e5+5;
int n,m,q,a[N];

void solve(){
    int mx=0,idx1;
    int mi=1e9+1,idx2;
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        scanf("%d",&a[i]);
        if(mx<a[i]) mx=a[i],idx1=i;
        if(mi>a[i]) mi=a[i],idx2=i;
    }
    printf("%d %d\n",idx1,idx2);
}

int main(){
    int T;scanf("%d",&T);
    while(T--) solve();
    return 0;
}

B. Subtract Operation

题意：给出长度为n的序列，每次选择序列中一个元素x并讲元素移除序列，同时序列中剩下的所有元素的值都减去x，问最后序列只剩下一个元素的时候，元素的值是否等于k
思路：
因为是不断减，所以手动模拟一下操作就行了

当前长度n=4       
元素集合              a[1]                      a[2]                    a[3]              a[4]
第一步(移除a[4])    a[1]-a[4]                 a[2]-a[4]               a[3]-a[4]
第二步(移除a[3])    a[1]-a[4]-(a[3]-a[4]      a[2]-a[4]-(a[3]-a[4]) 
即：               a[1]-a[3]                 a[2]-a[3] 
第三步(移除a[2])    a[1]-a[3]-(a[2]-a[3])
即：               a[1]-a[2]

由此推断，最后剩下的元素值，一定是原序列中某两个元素的差值
所以找到a[x]-a[y]=k就行了，暴力肯定不行，使用map记录一下。
当前是a[x]，就看是否存在元素a[y]+k
当前是a[y]，就看是否存在元素a[x]-k

挺简单的，感觉说复杂了

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=2e5+5;
int n,k,a[N];
map<int,bool>mp;

void solve(){
    mp.clear();
    bool flag=false;
    scanf("%d%d",&n,&k);
    for(int i=1;i<=n;i++){
        scanf("%d",&a[i]);
        if(mp.find(a[i]+k)!=mp.end()||mp.find(a[i]-k)!=mp.end()) flag=true;
        mp[a[i]]=true;
    }
    if(flag) puts("YES");
    else puts("NO");
}

int main(){
    int T;scanf("%d",&T);
    while(T--) solve();
    return 0;
}

C. Make Equal With Mod

题意：
给出长度为n的序列，问是否可以进行零次或多次操作，使得所有元素都相等。
每次操作选择一个x>=2,使序列中元素都对x进行取模操作。
思路：
开始想成分奇偶，同时记录序列中0和1的出现次数了。
后面发现更简易的写法，显然0和1是不可能同时出现的，因为模数>=2，在这里1再怎么取模都会是1。
同时我们观察四个序列{1,7,8},{1,6,7},{0,7,8},{0,6,7}， 发现0是不会影响的，每次取当前最大值去取模就全部变成0了，而对于1来说，如果存在两个连续的数字，那么无论怎么取，都无法满足条件

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=1e5+5;
int n,m,q,a[N];

void solve(){
    scanf("%d",&n);
    int nu1=0;
    for(int i=1;i<=n;i++){
        scanf("%d",&a[i]);
        if(a[i]==1) nu1++;
    }
    if(nu1==0) puts("YES");
    else{
        sort(a+1,a+n+1);
        for(int i=2;i<=n;i++){
            if(a[i]==a[i-1]+1){
                puts("NO");
                return;
            }
        }
        puts("YES");
    }
}

int main(){
    int T;scanf("%d",&T);
    while(T--) solve();
    return 0;
}

D. K-good

题意：
对于数字n，是否存在整数k，使得有k个正整数，这k个正整数满足对k进行取模的值不同，且这k个数和为n，有输出满足条件的任意一个k，否则输出-1
思路：
公式化简。

因为是k个对k取模值都不同的正整数，我们可以知道肯定模k的取值区间为[0,k-1]
又保证正整数，即值至少[1,k]的累加和:(1+k)*k/2   //公式一 
得到公式： n=(1+k)*k/2+k*num   //公式二
公式变换一下： 2*n =(1+k)*k+2*k*num=k*(1+k+2*num) //公式三

首先明确一点：n如果是奇数肯定是可以的，因为可以分成两部分（n/2)和（n+1)/2
那么现在讨论的公式三的左边(2*n)来说，n一定会是一个偶数，而右边一定是一个奇数*一个偶数的形式。
由此推断，如果n是2的幂次方的话，肯定不能满足公式，即n要是非2的幂次方，这样可以对n进行mod2操作后，
可以使得左右两边都是一个奇数*一个偶数的形式，从而得到答案

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=2e5+5,M=1e6+6;
ll n;

void solve(){
    scanf("%lld",&n);
    if(n%2==1){puts("2");return;}
    ll nu=1;
    while(n%2==0){
        n/=2;
        nu*=2;
    }
    if(n==1) puts("-1");
    else printf("%lld\n",min(n,2*nu));
}

int main(){
    int T;scanf("%d",&T);
    while(T--) solve();
    return 0;
}

E. Equal Tree Sums

题意：
给出一个有n个节点的树，要求删除任意一个节点，都满足剩余的各个连通块的权值和相等，要求输出每个节点的权值
(如果删除某节点后只有一个连通块，直接满足条件)
思路：
具体证明我也不清楚
我猜的是进行一下类似二分图染色，将树染成一个二分图，然后每个节点的权值就是与其相连的边的条数。
幸运猜过

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=1e5+5;
int n,val[N];
vector<int>edge[N];

void dfs(int u,int fa,int col){
    int len=edge[u].size();
    val[u]=len*col;
    for(int i=0;i<len;i++){
        int v=edge[u][i];
        if(v==fa) continue;
        dfs(v,u,-col);
    }
}

void solve(){
    scanf("%d",&n);
    for(int i=1;i<n;i++){
        int u,v; scanf("%d%d",&u,&v);
        edge[u].push_back(v);
        edge[v].push_back(u);
    }
    dfs(1,0,1);
    for(int i=1;i<=n;i++) printf("%d%c",val[i],(i==n)?'\n':' ');
    puts("");
    for(int i=1;i<=n;i++) edge[i].clear();
}

int main(){
    int T;scanf("%d",&T);
    while(T--) solve();
    return 0;
}

F. Parametric MST

正在试试能不能写