NOIp ( on line ) 提高组 2020 总结

---

 

 

 

---

　　T1 ： 序列

　　　　题意：

　　　　　　　一共有T组数据，每组数据有两个长度为n的序列a,b，m个操作，问a序列是否可以转换成b，是输出YES，否的话输出NO。

　　　　　　　m个操作分别为t_i，x_i，y_i，若t为1，则x和y上的数可同时加减一；若t为2，则x上的数加一同时y上的数减一，或y上的数加一同时x上的数减一；

　　　　　　　　

　　　　　　大概理解为： 将a上的所有数变成b上的对应的数，当t=1时可以将a[x],a[y]同时加任何数，当t=2时可以将a[x]加任何数同时a[y]上的数减上相同的数（相当于把a[x]一部分值转到a[y]上）；

　　　　　　 列：   a : 1 3 5 4     t=1,x=1,y=2         则若a[1] (1) 要加上3，a[2] (3) 也必须加上3，a 变成 4 6 5 4

　　　　　　　　　　　　　　   t=2,x=1,y=2 　　 则若a[1] (1) 要加上3，a[2] (3) 必须减去3，a变成 4 0 5 4;　　　　   

　　　　数据范围：

　　　　　　　　　1≤T≤10,1≤n,m≤10⁵,1≤a_i,b_i≤10⁹

---

 

　　　　　　　　　　

　　　　分析：

　　　　　　　　这题可以用图论来做

　　　　　　　　先定义一个序列 c ，c[i]=a[i]-b[i]，这样我们只要判断c中的每一个值是否可以变为零就行了。

　　　　　　　　然后读入m个操作

　　　　　　　　先不用管t为1时的情况，若 t 为2的话，把 x 和 y 之间连一条无向边，然后将图中的联通块缩点。

　　　　　　　　因为联通块中的任何俩个数都可以将他们的一部分值互相转换，所以可以将他们看做一个点，该点的权值就是联通块中的每一个c[i]的和。

　　　　　　　　下面记 i 点所在的联通块为bel[i]。

　　　　　　　　接下来再操作将t为1时的情况， 将bel[x]与bel[y]之间连一条无向边，若bel[x]=bel[y]则用一个bool数组表示bel[x]有自环，有自环后bel[x]的值就可以成2的倍数增长。

　　　　　　　　接下来就对新图进行缩点，可以发现，若两个点之间的路径长度为偶数时，两个点间可进行值的转移。

　　　　　　　　所以我们再将图进行黑白染色，同色点之间一定长度为偶数的路径，那么我们就将颜色相同的点进行缩点。

　　　　　　　　缩到最后，我们再将判断一下每个联通块是否可以将其的总权值变为零，如果有一个联通块不能将其总权值变为零，则输出NO，反之输出YES。

　　　　　　　　我们再看看如何判断联通块之间是否可以将其总权值变为零。

　　　　　　　　因为缩点缩到最后一定每个联通块最多只有两个点（黑点和白点），所以判断一下这两个点可不可以变为零就行了。

　　　　　　　　只要两个点的权值相同，那么就可以两个点同时加减变为零。

　　　　　　　　如果不相等，如果两个点其中一个有自环，且两个点权值差为偶数，那就可以将两个点的值变相同，之后再进行操作。

　　　　　　　　因为我们只需要判断联通块是否可以变成零就行了，所以不用建新图，dfs一下就行。

　　　　　　　　（我还是太弱了，考场上不会写图，只会n≤2的）

 

 

---

 

　　　　代码如下：

 

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<vector>

using namespace std;

typedef long long LL;

const int N=1000010;

LL sum[N];
int bel[N],a[N],color[N];
bool book[N];

vector<int> h[N],g[N];

struct Node
{
    int x,y;
}w[N];

void dfs1(int u,int c)//第一次缩点 （t为2时的边） 
{
    bel[u]=c;
    sum[c]+=a[u];
    for(int i=0;i<g[u].size();i++)
    {
        int j=g[u][i];
        if(!bel[j])
        dfs1(j,c);
    }
}

bool dfs2(int u,int col,bool &pd,LL &suma,LL &sumb)//第二次缩点 
{
    if(~color[u]) return color[u]==col;//若颜色不一样说明有奇数环 
    
    color[u]=col;//进行染色 
    pd|=book[u];//判断有没有自环 
    
    if(col==0) suma+=sum[u];//将相同色的点权值相加 
    else sumb+=sum[u];
    
    bool t=true;
    
    for(int i=0;i<h[u].size();i++)
    {
        int j=h[u][i];
        
        t&=dfs2(j,col^1,pd,suma,sumb);
    }
    
    return t;
}

int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        int n,m;
        int cnt_all=0,cnt=0;
        
        scanf("%d%d",&n,&m);
        
        for(int i=1;i<=n;i++) scanf("%d",&a[i]);
        
        for(int i=1;i<=n;i++)
        {
            int x;
            scanf("%d",&x);
            a[i]=x-a[i];
            
            g[i].clear();//将边初始化 
            h[i].clear();
        }
        
        memset(w,0,sizeof(w));
        
        while(m--)
        {
            int p,x,y;
            
            scanf("%d%d%d",&p,&x,&y);
            
            if(p==1)
            {
                w[cnt_all++]={x,y};//存储当t为1时的边 
            }
            else
            {
                g[x].push_back(y),g[y].push_back(x);//t为2时将x与y之间连边 
            }
        }
        
        memset(sum,0,sizeof(sum));//联通块总权值初始化 
        memset(bel,0,sizeof(bel));//每个点属于的联通块 
        
        for(int i=1;i<=n;i++)
        {
            if(!bel[i]) dfs1(i,++cnt);
        }
        
        memset(book,0,sizeof(book));
        
        for(int i=0;i<cnt_all;i++)
        {
            int x=bel[w[i].x],y=bel[w[i].y];
            
            if(x==y) book[x]=true;//判断自环 
            else
            {
                h[x].push_back(y);//不是自环则加边 
                h[y].push_back(x);
            }
        }
        
        bool ans=1;
        
        memset(color,-1,sizeof(color));//初始化颜色 
        
        for(int i=1;i<=cnt;i++)
        {
            if(color[i]==-1)//若没被染过色 
            {
                bool pd=false;//判断自环 
                LL suma=0,sumb=0;//黑色和白色点的权值总和 
                
                if(dfs2(i,0,pd,suma,sumb))
                {
                    if(pd) ans&=(suma+sumb)%2==0;//判断联通块权值是否可以变为零 
                    else ans&=suma==sumb;
                }
                else
                {
                    ans&=(suma+sumb)%2==0;
                }
            }
        }
        
        if(ans) puts("YES");
        else puts("NO");
    }
}

 

---

 

 　　T2 :

　　　　　　　　不会 ~

 

 

 

 

---

 

 

　　T3 ： 最小环

　　　　　　题意：

　　　　　　　　　　给定一个长度为 n 的正整数序列 a_i，下标从 1 开始编号。

　　　　　　　　　　我们将该序列视为一个首尾相邻的环。

　　　　　　　　　　更具体地，对于 下标为 i, j(i⩽j) 的两个数 a_i​, a_j，它们的距离为 min⁡(j−i,i+n−j)。

　　　　　　　　　　现在再给定 m 个整数 k₁, k₂,..., k_m。

　　　　　　　　　　对每个 k_i​(i=1, 2,..., m)，你需要将上面的序列 a_i 重新排列，使得环上任意两个距离为 k_i 的数字的乘积之和最大。

　　　　　　　　大概理解为：给一串数，让你将这串数重新排列，使任意两个中间间隔k-1个数的数的乘积之和最大（数列是头尾相连的）。

---

 

 

　　　分析：

　　　　　　　　　　根据样例数据推断出，将最大的数两旁放次大的及第二大的，再将次大的数旁放第三大的，以此类推，最后的结果一定是最大的情况。

　　　　　　　　　　总的来说，每次将未放到环中最大的数放入到环中最大的数旁，可使环的结果最大。

　　　　　　　　　　我们只需要将最大的几个数放入一个环中，再将环中最大的几个数放在一起，总结果就最大了。

　　　　　　　　　　接下来，我们就将当k为0~n/2的情况预处理一下，最后询问时直接输出答案就行。

　　　　　　　　　　然后得算一下距离k与分成多少个环的关系。假设一个环中有些个数，那么 (x*k) mod n=0，所以x=gcd(n,k)。

　　　　　　　　　　(我没想到环的个数是用最大公约数求，只搞了k为一的）

 

---

 

　　　代码如下：

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;

const int N=1000010;

long long a[N],f[N];

bool com(int a,int b)
{
    return a>b;
}

int gcd(int a,int b)//求最大公约数 
{
    return b ? gcd(b,a%b) : a;
}

int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    
    for(int i=1;i<=n;i++) scanf("%d",&a[i]);
    
    sort(a+1,a+n+1,com);//将数从大到小排序   找最大值好用 
    
    for(int i=1;i<=n;i++)//处理k为零的情况 
    {
        f[0]+=a[i]*a[i];
    }
    
    for(int k=1;k<=n/2;k++)
    {
        int t=gcd(n,k),num=n/t;//t为能分成多少个环   num为一个环有多少个数 
        
        if(f[t]) continue;
        
        for(int i=0;i<=n;i++)//依次枚举最大数放入环中 
        {
            if(i%num==0)//如果这是上一个环的最后一个数   就加上下一个环 
            {
                f[t]+=a[i+1]*a[i+2];
                continue;
            }
            
            if((i+1)%num==0)//如果这是环的倒数第二个数 
            {
                f[t]+=a[i]*a[i+1];
            }
            else f[t]+=a[i]*a[i+2];//正常情况下 
        }
        
        
    }
    while(m--)
    {
        int k;
        scanf("%d",&k);
        
        if(!k) printf("%lld\n",f[0]);//特判当k为零的情况 
        else
        {
            k=gcd(n,k);
            printf("%lld\n",f[k]);
        }
    }
}