Codeforces Round #773 (Div. 2)(ABCD)

Codeforces Round #773 (Div. 2)(ABCD)

总结：阅读理解+手速

A. Hard Way
思路：按y值从小到大排序，后两个点的y值相等，答案就是abs(两点x值的差值)，否则是0

#include<bits/stdc++.h>
using namespace std;
struct PDD{
    double x,y;
    const double operator<(const PDD&t){
        return y<t.y;
    }
};
PDD pg[5];

bool cek(PDD a,PDD b){return a.y==b.y;}
void print(PDD a,PDD b){printf("%.8lf\n",fabs(a.x-b.x));}

void solve(){
    for(int i=1;i<=3;i++) scanf("%lf%lf",&pg[i].x,&pg[i].y);
    sort(pg+1,pg+4);
    if(cek(pg[2],pg[3])) print(pg[2],pg[3]);
    else puts("0.0000000");
}

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

B. Power Walking
题意：有n个物品，第$i$物品价值$a[i]$，要求将n个物品依次分成$x(1<=x<=n)$组，每组的贡献为其中包括多少种数字。问每个x的最小总贡献是多少。
思路：将数字相同的放在同一组可以贡献会少一点，我们统计好初始有多少种数字len。
①当x小于等于len,那么ans=len
②当x大于len，那么ans=x

/*
[1,1,2,2,3,3,4,4,4]  种类数4
我们可以看成[1,1] [2,2] [3,3] [4,4,4]这4个区间
当x小于等于4时,我们可以看成4个区间进行合并操作，得到x个区间，答案就是4
当x大于4时，每次从其中一个区间长度大于1的里面，得到x个区间，其中会有x-4个区间只包含一个元素，贡献x-4,所以答案就是4+x-4=x
*/

#include<bits/stdc++.h>
using namespace std;
int n;
set<int>a;

void solve(){
    a.clear();
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        int x;scanf("%d",&x);
        a.insert(x);
    }
    int len=a.size();
    for(int i=1;i<=len;i++) printf("%d ",len);
    for(int i=len+1;i<=n;i++) printf("%d ",i);
    puts("");
}

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

C. Great Sequence

题意：给定n个数和乘积x，问最少添加多少数，保证最后可以全部两两一对，同时每对数保证$a\ast x==b$
思路：给大给小没有影响，那么我们拿map记录每个数的个数。
遍历map(从小到大)，所以当前数为一对数中小的那个数。
当前数a如果：
①：当前数a的个数为0，表示没有该数，直接continue
②：当前数a存在，与之配对的数是$b=a\ast x$,
(1)b的个数大于等于a的个数，a全部跟b匹配。那么a和b的个数都会减去a的个数。b还会有剩余$(map[b]-map[a])$，后面去拿b当小的数去配对
(2)b的个数小于a的个数，b全部跟a匹配。a还会有剩余，那么剩下的a就用加进来的b去配对，则添加的数$sum+=(map[a]-map[b])$ ，此时a和b的个数清空

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll N=2e5+5;
ll n,x,sum;
map<ll,ll>mp;

void solve(){
    mp.clear(); sum=0;
    scanf("%lld%lld",&n,&x);
    for(ll i=1;i<=n;i++){
        ll nu;scanf("%lld",&nu);
        mp[nu]++;
    }
    for(auto it:mp){
        ll now=it.first;
        ll num1=it.second;
        if(num1==0) continue;
        else{
            ll ned=now*x;
            ll num2=mp[ned];
            if(num2>=num1){
                mp[now]-=num1;
                mp[ned]-=num1;
            }
            else{
                mp[now]=mp[ned]=0;
                sum+=num1-num2;
            }
        }
    }
    printf("%lld\n",sum);
}

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

D. Repetitions Decoding

题意：给定一个长度为n的序列a，要求将序列a分成若干段，每段长度len大于等于2，同时需要保证$a[i]==a[i+len/2]$。我们可以进行一种操作，每次操作是在一个pos为后面加入两个相同的数，同时改变序列长度。

/*
要求：
是否可以分为若干段，不能输出-1
可以输出格式：
输出添加操作个数len1,接下来len1行每行输出两个整数pos,val，表示在当前序列的pos位置加入两个val
输出分成段数len2，接下来一行中输出len2个数，表示在最后序列中，从前往后每一段的长度。
*/

思路：
我们拿两个vector存在当前序列，同时记录已经匹配好的长度。
来回讨论vector，每次从后往前遍历当前讨论vector，找出第一个等于当前vector的第一个元素的下标idx，然后将下标从$[1,idx-1]$依次添加(idx-1)个数加到idx数后面，最后将新序列加入到另一个vector中，清空当前vector。当讨论的vector的个数等于2时，此时这就是最后一段，长度为2.结束来回讨论。

/*模拟过程
讨论区间[3,2,1,1,2,3]。vector<int>a,b
len表示已经匹配长度 len=0
第一步：
讨论vector<int>a，此时a中序列[3,2,1,1,2,3]
我们发现第一个等于a[0]的是a[5](idx=5)，那么依次在位置5的后面加入区间[1,4]中元素，
此时a中序列[3,2,1,1,2,3,2,1,1,2,2,1,1,2],我们发现前一部分构成了符合条件的区间串[3,2,1,1,2,3,2,1,1,2]+[2,1,1,2]
将后面元素加入vector<int>b,此时b中序列[2,1,1,2],清空vector<int>a
已匹配长度len+=2*idx (len=10) 本段区间长度10

第二步：
讨论vector<int>b，此时b中序列[2,1,1,2]
我们发现第一个等于b[0]的是b[3](idx=3)，那么依次在位置3的后面加入区间[1,3]中元素，
此时b中序列[2,1,1,2,1,1,1,1],我们发现前一部分构成了符合条件的区间串[2,1,1,2,]+[2,1,1,2,1,1]+[1,1]
将后面元素加入vector<int>a,此时a中序列[1,1],清空vector<int>b
已匹配长度len+=2*idx (len=16) 本段区间长度6

第三步：
讨论vector<int>a，此时a中序列[1,1]
此时区间长度等于2，本段为最后一个匹配区间，本段区间长度2。
结束来回讨论
*/

#include<bits/stdc++.h>
using namespace std;
const int N=505;
int n,cnt[N],id;
map<int,int>mp;
vector<int>a,b,ans;
vector<pair<int,int> >ned;

void output(){
    int len_ned=ned.size(),len_ans=ans.size();
    printf("%d\n",len_ned);
    for(int i=0;i<len_ned;i++) printf("%d %d\n",ned[i].first,ned[i].second);
    printf("%d\n",len_ans);
    for(int i=0;i<len_ans;i++) printf("%d ",ans[i]);
    puts("");
}

void solve(){
    id=0;
    mp.clear();ans.clear();a.clear(),b.clear(),ned.clear();
    for(int i=0;i<N;i++) cnt[i]=0;
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        int x;scanf("%d",&x);
        if(mp[x]==0) mp[x]=++id;
        a.push_back(x);
        cnt[mp[x]]++;
    }
    if(n%2==1) {puts("-1");return;}
    for(int i=1;i<=id;i++){
        if(cnt[i]%2==1){
            puts("-1");
            return;
        }
    }
    int now_type=1,len=0;
    while(1){
        if(now_type==1){
            int lena=a.size(),idx;
            if(lena==2){ans.push_back(2);break;}
            for(int i=lena-1;i>=1;i--){
                if(a[i]==a[0]){
                    idx=i;break;
                }
            }
            for(int i=idx-1,j=1;i>=1;i--,j++) b.push_back(a[i]),ned.push_back({len+j+idx,a[j]});;
            for(int i=idx+1;i<lena;i++) b.push_back(a[i]);
            len=len+2*idx;ans.push_back(2*idx);
            a.clear(); now_type=-now_type;
        }
        else{
            int lenb=b.size(),idx;
            if(lenb==2){ans.push_back(2);break;}
            for(int i=lenb-1;i>=1;i--){
                if(b[i]==b[0]){
                    idx=i;break;
                }
            }
            for(int i=idx-1,j=1;i>=1;i--,j++) a.push_back(b[i]),ned.push_back({len+j+idx,b[j]});;
            for(int i=idx+1;i<lenb;i++) a.push_back(b[i]);
            len=len+2*idx;ans.push_back(2*idx);
            b.clear(); now_type=-now_type;
        }
    }
    output();
}

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