Codeforces Round #565 (Div. 3)

传送门

A. Divide it!

•题意

　　定义整数 n 上的三个操作：

　　

　　如果可以经过上述操作使得 n 变为 1，输出最小操作次数，反之，输出-1；

•题解

　　易得 2 > 3/2 > 5/4；

　　操作执行的优先级 1 > 2 > 3；

　　按照优先级依次执行；

•AC代码

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

ll n;
int Solve()
{
    int ans=0;
    while(n%2 == 0)
    {
        n /= 2;
        ans++;
    }
    while(n%3 == 0)
    {
        n /= 3;
        ans += 2;
    }
    while(n%5 == 0)
    {
        n /= 5;
        ans += 3;
    }
    return n == 1 ? ans:-1;
}
int main()
{
    int test;
    scanf("%d",&test);
    while(test--)
    {
        scanf("%lld",&n);
        printf("%d
",Solve());
    }
    return 0;
}

---

B. Merge it!

•题意

　　给你一个包含 n 个数的序列 a；

　　定义序列 a 上的一个操作：合并任意两个元素；

　　你可以对序列 a 执行上述操作任意次，求操作后的序列最多有多少元素可以被 3 整除；

•题解

　　对于任意一个数 x ，如果 x 不是 3 的倍数，那么 x 最多加 2 就可以变成 3 的倍数；

　　首先求出 ai 最少加多少可以变成 3 的倍数；

　　共有三种可能：

　　　　①如果 ai%3 = 0，加0；

　　　　②ai%3 = 1，加2；

　　　　③ai%3 = 2，加1；

　　②和③结合正好是3的倍数，优先让②和③结合，剩余的自己结合；

•AC代码

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define INF 0x3f3f3f3f
#define mem(a,b) memset(a,b,sizeof(a))
#define memF(a,b,n) for(int i=0;i<=n;a[i++]=b);
const int maxn=1e2+50;

int n;
int a[maxn];
int b[3];

int Solve()
{
    b[0]=b[1]=b[2]=0;
    for(int i=1;i <= n;++i)
    {
        int k=a[i]%3;
        if(k == 0)
            b[0]++;
        else if(k == 1)
            b[2]++;
        else
            b[1]++;
    }

    return b[0]+min(b[1],b[2])+abs(b[2]-b[1])/3;
}
int main()
{
//    freopen("C:\Users\hyacinthLJP\Desktop\in&&out\contest","r",stdin);
    int test;
    scanf("%d",&test);
    while(test--)
    {
        scanf("%d",&n);
        for(int i=1;i <= n;++i)
            scanf("%d",a+i);
        printf("%d
",Solve());
    }
    return 0;
}

---

C. Lose it!

•题意

　　给你一个包含 n 个整数的序列 a；

　　在删去 x 个数后，使得序列 a 可以划分成 (n-x) / 6 个 "good" 序列；

　　求 x 的最小值；

•题解

　　求出序列 a 最多有多少个 "good" 序列（假设有 ans 个），那么答案就是 n-6×ans；

•AC代码

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define INF 0x3f3f3f3f
#define mem(a,b) memset(a,b,sizeof(a))
#define memF(a,b,n) for(int i=0;i<=n;a[i++]=b);
const int maxn=5e5+50;

int n;
int a[7]={0,4,8,15,16,23,42};
map<int ,int >mymap;

int b[7];///b[1]:4来到v[4][b[1]]位置,b[2,...,6]同理
vector<int >v[7];///v[1]:存放4出现的所有位置,v[2,...,6]同理
int ans;///"good"序列个数

void DFS(int cur,int pre)
{
    if(cur == 7)
    {
        ans++;
        return ;
    }

    ///找到上一个位置pre之后的最左的位置
    for(;b[cur] < v[cur].size() && v[cur][b[cur]] < pre;b[cur]++);
    if(b[cur] == v[cur].size())
        return ;
    ///查找下一个数的位置
    DFS(cur+1,v[cur][b[cur]++]);
}
int Solve()
{
    ans=0;
    for(int i=0;i < v[1].size();++i)
        DFS(2,v[1][i]);///枚举4的每个位置
        
    return n-6*ans;
}
int main()
{
//    freopen("C:\Users\hyacinthLJP\Desktop\in&&out\contest","r",stdin);
    for(int i=1;i <= 6;++i)
        mymap[a[i]]=i;
        
    scanf("%d",&n);
    for(int i=1;i <= n;++i)
    {
        int x;
        scanf("%d",&x);
        v[mymap[x]].push_back(i);
    }
    printf("%d
",Solve());
    return 0;
}

•非DFS

#include<bits/stdc++.h>
using namespace std;
#define memF(a,b,n) for(int i=0;i <= n;a[i++]=b);
const int maxn=5e5+50;

int n;
int a[maxn];
int num[10]={4,8,15,16,23,42};
int b[50];
vector<int >p[50];

int Solve()
{
    memF(b,0,49);

    int ans=0;///最多构成ans个"good"序列
    for(int i=0;i < p[4].size();++i)
    {
        int cur=p[4][i];
        for(int j=1;j <= 5;++j)
        {
            int index=num[j];
            for(;b[index] < p[index].size() && p[index][b[index]] <= cur;b[index]++);
            
            if(b[index] == p[index].size())
                return n-6*ans;

            ///p[index]的b[index]位置已使用，所以b[index]++
            cur=p[index][b[index]++];
        }
        ans++;
    }
    return n-6*ans;
}
int main()
{
    scanf("%d",&n);
    for(int i=1;i <= n;++i)
    {
        scanf("%d",a+i);
        p[a[i]].push_back(i);
    }
    printf("%d
",Solve());

    return 0;
}

•二分

#include<bits/stdc++.h>
using namespace std;
#define memF(a,b,n) for(int i=0;i <= n;a[i++]=b);
const int maxn=5e5+50;

int n;
int a[maxn];
int num[10]={4,8,15,16,23,42};
vector<int >p[50];

int Solve()
{
    int ans=0;///最多构成ans个"good"序列
    for(int i=0;i < p[4].size();++i)
    {
        int cur=p[4][i];
        for(int j=1;j <= 5;++j)
        {
            int index=num[j];
            ///二分查找p[index]中 > cur 的位置
            vector<int >::iterator it=upper_bound(p[index].begin(),p[index].end(),cur);
            if(it == p[index].end())
                return n-6*ans;
                
            cur=*it;
            p[index].erase(it);///it位置已被使用，删掉
        }
        ans++;
    }
    return n-6*ans;
}
int main()
{
    scanf("%d",&n);
    for(int i=1;i <= n;++i)
    {
        scanf("%d",a+i);
        p[a[i]].push_back(i);
    }
    printf("%d
",Solve());

    return 0;
}

•效率比拼

　　二分效率：

　　

　　非二分效率：

　　

　　总结：

　　codeforces评测鸡是真的快呀；

　

---

D. Recover it!

•题意

　　构造包含 n 个数的数组 a，使得 a 经过下述操作，多出 n 个数；

　　这 2n 个数构成数组 b，即输入的 2n 个数；

　　

　　输出 a 数组中的 n 个数；

•题解

　　这 2n 个数要平分到两个集合 U,V 中；

　　满足集合 U 通过上述两个操作可以推导出集合 V，并且是一一对应关系；

　　那么，考虑一下这 2n 个数中的最大值 x 要归到哪个集合？

　　①x 为素数，x∈V；

　　②x 为合数，x∈U；

　　根据这两个限定，首先将 b 排序，每次抽出最大值 x，判断 x 是否为素数；

　　①如果 x 为第 y 个素数，因为保证答案一定存在，那么 y 一定存在，并且 y 也是素数；

　　  将 x 归到集合 V，y 归到集合 U；

　　②如果 x 为合数，那么 x 归到集合 U，x的小于x的最大的约数 y 也一定存在，将 y 归到集合 V；

　　最后输出集合 U 中的元素即可；

•Code

#include<bits/stdc++.h>
using namespace std;
#define mem(a,b) memset(a,b,sizeof(a))
const int maxn=2e5+50;

int n;
int b[maxn<<1];
map<int ,int >f;
int cnt;
int prime[maxn];
bool isPrime[2750131+10];
void Prime()
{
    mem(isPrime,true);
    cnt=1;
    for(int i=2;cnt < (int)2e5;i++)
    {
        if(isPrime[i])
            prime[cnt++]=i;
        for(int j=1;j < cnt && prime[j]*i <= 2750131;++j)
        {
            isPrime[prime[j]*i]=false;
            if(i%prime[j] == 0)
                break;
        }
    }
}

void Solve()
{
    sort(b+1,b+2*n+1);
    for(int i=2*n;i >= 1;--i)
    {
        int x=b[i];
        if(f[x] == 0)
            continue;

        int y=lower_bound(prime+1,prime+cnt,x)-prime;
        if(y < cnt && prime[y] == x)
        {
            printf("%d ",y);
            f[x]--;
            f[y]--;
        }
        else
        {
            for(int i=2;;i++)
                if(x%i == 0)
                {
                    y=x/i;
                    break;
                }
            printf("%d ",x);
            f[x]--;
            f[y]--;
        }
    }
    printf("
");
}
int main()
{
    Prime();

    scanf("%d",&n);
    f.clear();
    for(int i=1;i <= 2*n;++i)
    {
        scanf("%d",b+i);
        f[b[i]]++;
    }
    Solve();

    return 0;
}

---

E. Cover it!

•题意

　　从含有 n 个点，m 条边的无向图中取出 x 个点，这 x 个点需满足：

　　① x ≤ n/2；

　　②剩余的点至少与这 x 个点中的一个点有连边；

　　输出满足条件的这 x 个点；

•题解

二部图裸题；

　　找出集合 U 和集合 V，输出 |U| 和 |V| 中元素个数最少的集合；

•AC代码

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define INF 0x3f3f3f3f
#define mem(a,b) memset(a,b,sizeof(a))
#define memF(a,b,n) for(int i=0;i<=n;a[i++]=b);
const int maxn=2e5+50;

int t;
int n,m;
int num;
int head[maxn];
struct Edge
{
    int to,next;
}G[maxn<<1];
void addEdge(int u,int v)
{
    G[num]=Edge{v,head[u]};
    head[u]=num++;
}
int col[maxn];///col[i]:节点i所属的集合

///集合U中的元素染成0
///集合V中的元素染成1
void DFS(int u,int k)
{
    col[u]=k;
//    printf("u=%d,k=%d
",u,k);
    for(int i=head[u];~i;i=G[i].next)
    {
        int v=G[i].to;
        if(col[v] != -1)
            continue;
        DFS(v,k^1);
    }
}
void Solve()
{
    memF(col,-1,n);
    DFS(1,0);
    int a=0,b=0;
    for(int i=1;i <= n;++i)
        if(col[i])
            a++;
        else
            b++;
            
    int ans=a > b ? 0:1;
    printf("%d
",min(a,b));
    for(int i=1;i <= n;++i)
        if(col[i] == ans)
            printf("%d ",i);
    printf("
");
}
void Init()
{
    num=0;
    memF(head,-1,n);
}
int main()
{
//    freopen("C:\Users\hyacinthLJP\Desktop\in&&out\contest","r",stdin);
    int test;
    scanf("%d",&test);
    while(test--)
    {
        scanf("%d%d",&n,&m);
        Init();
        for(int i=1;i <= m;++i)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            addEdge(u,v);
            addEdge(v,u);
        }
        Solve();
    }
    return 0;
}