【解题报告】CF DIV2 #ROUND 708 A~C,E1

【解题报告】CF DIV2 #ROUND 708 A~C,E1

比赛链接
打到一半cf崩了，还好没计rate，不然这把我就没了。
构造题，数论题，贪心题我都不咋会啊啊啊

A Meximization

思路
看样例
mex之和尽可能大，那就先把小的先补上，先排序单次输出一遍
然后把剩下的输出一波就完事了

代码

#include<bits/stdc++.h>
using namespace std;
#define int long long
 
int T,n,m;
const int N=105;
int a[N],b[N];
set<int>s;
int mex[N];
signed main()
{
    scanf("%lld",&T);
    while(T--)
    {
        s.clear();
        memset(b,0,sizeof(b));
        memset(a,0,sizeof(a));
        scanf("%lld",&n);
        for(int i=1;i<=n;i++)
        {
            scanf("%lld",&a[i]);
            b[a[i]]++;
            s.insert(a[i]);
        }
 
        for(auto t:s)cout<<t<<" ";
        for(int i=0;i<=100;i++)
            for(int j=2;j<=b[i];j++)
                cout<<i<<" ";
        cout<<endl;
 
    }
 
    return 0;
}

B M-arrays

思路
对输入的数取模，并统计数量
后面的配对分组问题在比赛的时候没有做好

x%m后为0的为一组，m/2的为一组
如果找不到，配对的，那么增加一组
如果可以找到配对，那么我们限制一下是小于m/2的为索引来找，那么后半部分就不会重复配对了。
由于我们可以这样配对：$x,m-x,x,m-x\dots \dots$这样拼接
所以对于和为m的配对，我们可以先用上面那种形式配成一组(这一组里$cn{t}_x和cn{t}_y最多可以相差1$，剩余的就是没法配对的也就是$max(0,abs(cn{t}_x-cn{t}_y)-1)$个组
举个例子
要求和可以被4整除，有3个1，5个3

1 1 1 3 3 3 3 3
可以分为
[3 1 3 1 3 1 3]   [3]

所以$ans+=1+max(0,abs(cn{t}_x-cn{t}_y)-1)$
没法找到的也可以用这个式子

代码

#include<bits/stdc++.h>
using namespace std;
int T;
int main()
{
    cin>>T;
    while(T--)
    {
        int n,m;
        cin>>n>>m;
        map<int,int>cnt;
        while(n--)
        {
            int x;
            cin>>x;
            cnt[x%m]++;
        }
        int ans=0;
        for(auto &c:cnt)
        {
            if(c.first==0)ans++;
            else if(2*c.first==m)ans++;
            else if(2*c.first<m||cnt.find(m-c.first)==cnt.end())
            {
                int x=c.second,y=cnt[m-c.first];
                ans+=1+max(0,abs(x-y)-1);
            }
        }
        cout<<ans<<'\n';
    }
    return 0;
}

C1. k-LCM (easy version)

思路
要让LCM尽可能小就要尽可能构造不互质的那种

分奇数偶数讨论
奇数：1，(n-1)/2,(n-1)/2
偶数：如果是四的倍数:n/2,n/4,n/4;如果不是四的倍数:(n-2)/2,(n-2)/2,2
因为偶数里面只有4k和4k+2两种形式嘛

数据给了<=n/2那么就要往n/2想

代码

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

int T,n,k;
const int N=1e5+10;
signed main()
{
    scanf("%lld",&T);
    while(T--)
    {
       scanf("%lld%lld",&n,&k);
       if(n&1)printf("%lld %lld 1\n",n/2,n/2);
       else
       {
           if(n%4==0)printf("%lld %lld %lld\n",n/2,n/4,n/4);
           else printf("%lld %lld 2\n",n/2-1,n/2-1);
       }
    }
    return 0;
}

C2. k-LCM (hard version)

思路
C1的扩展版本，k的范围变成了3<=k<=n。
由于1对LCM没啥影响
我们可以前面整k-3个1然后转化成C1

代码

#include<bits/stdc++.h>
using namespace std;
int T;
void solve(int n)
{
    if(n&1)printf("%d %d 1\n",n/2,n/2);
    else
    {
        if(n%4==0)printf("%d %d %d\n",n/4,n/4,n/2);
        else printf("%d %d 2\n",n/2-1,n/2-1);
    }
}
int main()
{
    int x,k;
    cin>>T;
    while(T--)
    {
        cin>>x>>k;
        for(int i=1;i<=k-3;i++)
        {
            printf("1 ");
            x--;
        }
        solve(x);
    }
    return 0;
}

E1. Square-free division (easy version)

思路
如果两个数乘积为完全平方，那么对两个数x,y质因数分解
$x=p_1^{c_1}{p}_2^{c_2}\dots \dots p_n^{c_n},y=p_1^{k_1}{p}_2^{k_2}\dots \dots p_n^{k_n}$
我们可以知道如果x*y质因数分解后若每一个质因子的指数为2的倍数那就是完全平方
那么我们可以在质因数分解的时候先取模2
$x=p_1^{c_1\%2}{p}_2^{c_2\%2}\dots \dots p_n^{c_n\%2}$
那么只要x和y每一位质因子指数相等，那么就是完全平方数

题目要求一个组内，不存在两个数的乘积为完全平方数，最少多少个分组
如果当前数pi的ci=1，只要前面存在1个1，那么就会产生完全平方数
如果当前数pi的ci=0，只要前面存在1个0，那么就会产生完全平方数

分析完毕然后就死在代码实现上了,看不懂题解的代码尝试带入数据模拟一遍

与个人想的不一样的是：题解代码先把输入都处理了然后最后整体处理，我原本想着输入一个处理一个，结果发现很不ok，如果单纯用输入的x分解出来的质因数索引的话不能找出所有的质因子（有的质因子不被x包含但被先前的数包含了）

完全平方数有一性质也就是
完全平方数*完全平方数=完全平方数这点在最终处理里很有用
代码

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

const int N=1e7+10;
int prime[N],st[N];//st标记最小质因数
int cnt;
void prework(int n)//线性筛
{
    for(int i=2;i<=n;i++)
    {
        if(st[i]==0)
        {
            st[i]=i;
            prime[++cnt]=i;
        }
        for(int j=1;prime[j]<=n/i;j++)
        {
            st[i*prime[j]]=prime[j];
            if(i%prime[j]==0)break;
        }
    }
}
int main()
{
    prework(10000010);
    int T;
    cin>>T;
    while(T--)
    {
        int n,k;
        cin>>n>>k;
        vector<int>a(n,1);//预处理n个1，a[i]保留第i个数取模后的质因数乘积
        for(int i=0;i<n;++i)
        {
            int x;
            cin>>x;
            int ct=0,last=0;//ct统计数量，last标记前一个使用的最小质因数
            while(x>1)
            {
                int p=st[x];
                if(last==p)//如果和前1前一样那么+1
                {
                    ++ct;
                }
                else//如果不愿意那就是有新的了，更新原来的，初始化新的ct和last
                {
                    if(ct%2==1)a[i]*=last;//如果%2后还有1，那么就是要保留的质因数
                    last=p;
                    ct=1;
                }
                x/=p;
            }
            if(ct%2==1)a[i]*=last;//处理最后一项
        }
        int L=0,ans=1;
        //完全平方数=完全平方数（A）*完全平方数（B）
        //A我们已经利用取模都消掉了，我们要看B能不能用剩下的数配出来,也就是找到a[x]==a[y]，如果找得到那就要多一个分组，如果找不到那就ok
        //为什么是a[x]==a[y]就可以呢，因为a[i]的值只有1或者单独的p,所以不会发生两个不同的数乘积为完全平方
        map<int,int>last;
        for(int i=0;i<n;i++)
        {
            if(last.find(a[i])!=last.end()&&last[a[i]]>=L)//限制>=L防止重复找
            {
                ++ans;
                L=i;
            }
            last[a[i]]=i;
        }
        cout<<ans<<'\n';
    }

    return 0;
}

反思

A：

分析样例即可

B:

序列和整除可以转化为取模

对于配对问题求组数：

能找到配对的：
特殊的：单独配对的比如这题的0，同种配对的比如这题的m/2
普通的：可以通过类似限制只从前一半找配对的技巧来防止同一配对被重复寻找。对于求配对组数，我们可以采用计算数量的绝对值之差来求配对剩余的没法完成配对的组数。

找不到配对的：直接单独分组

C1:

构造性问题：奇偶分类构造，然后看边界数据,数据给了lcm<=n/2那么就要往n/2想

C2:

LCM对1不敏感
构造性问题可以用1来填数然后缩小问题规模。0，1，2这种很多时候都很有用

E1:

完全平方数性质：完全平方数=完全平方数（A）*完全平方数（B）
当边输入边处理困难的时候可以尝试输入完后一起处理