NOI ONLINE提高组

NOI ONLINE提高组

1. 序列 题目网址 提高

题目描述

小D有一个长度为n的整数序列$a_{1...n}$， 他想通过若干次操作把它变成序列$b_i$。
小D有m种可选的操作， 第i种操作可使用三元组$(t_i,u_i,v_i)$描述：若$t_i$ = 1, 则塔克以使$a_{u_i}$与$a_{v_i}$都加一或减一；若$t_i$ = 2， 则她可以使$a_{u_i}$减一， $a_{v_i}$加一， 或者是$a_{u_i}$加一， $a_{v_i}$减一， 因此当$u_i=v_i$时， 这种操作相当于没有操作。
小D可以以任意顺序执行操作， 且每种操作都可进行无数次。现在给定序列与所有操作， 请你帮他判断是否存在一种方案能将$a_i$变成$b_i$。题目保证两个序列长度都为n。若方案存在输出YES， 否则输出NO.

题目思路

假设现在又a, b, c三个数。
则如果是操作1的话， 在a， b上加x， 在b, c上减去x， 就能做到在a上加x， c上减x， 一看， 正好是第二种操作。
操作二的话， 在a上+x， b上-x， b上+x， c上+x， 那么看a, c, 又是操作一！！！！！
把操作1设为边权为1， 操作2设为边权为0；只要两个点之间有操作， 那么只要两个边有操作， 那么就连边。可见， 只要两个点是联通的， 就能在这两个点身上进行操作。
如上面两种转移操作。

第一种转移

1

1

0

a

b

c

第二种转移

0

1

1

a

b

c

可见， $dist(a,b)\oplus dist(b,c)=dist(a,c)$
那么， 就想到了并查集的操作， 每次吧中专点枚举唯根节点即可。
还有判断为一的自环的问题， 用一个数组记录， 足矣！！

代码

#include 
#include 
#include 
using namespace std;
inline long long readint(){
    long long a = 0; char c = getchar(), f = 1;
    for(; c<'0'||c>'9'; c=getchar())
        if(c == '-') f = -f;
    for(; '0'<=c&&c<='9'; c=getchar())
        a = (a<<3)+(a<<1)+(c^48);
    return a*f;
}
inline void writeint(long long x){
    if(x < 0) putchar('-'), x = -x;
    if(x > 9) writeint(x/10);
    putchar((x%10)^48);
}

# define MB template < typename T >
MB void getMax(T &a,const T &b){ if(a < b) a = b; }
MB void getMin(T &a,const T &b){ if(b < a) a = b; }

const int MaxN = 100005;

int fa[MaxN], val[MaxN];
inline int findSet(int a){
    if(fa[a] == a) return a;
    int root = findSet(fa[a]);
    val[a] ^= val[fa[a]];
    return fa[a] = root;
}
bool win[MaxN]; // 是否有长度为1的自环
void unionSet(int a,int b,int c){
    int x = findSet(a), y = findSet(b);
    int dis = val[a]^c^val[b];
    if(x == y) win[x] = win[x] or dis == 1;
    else{
        fa[x] = y, val[x] = dis;
        win[y] = win[y] or win[x];
    }
}

long long a[MaxN]; int n, m;
int main(){
    // freopen("sequence.in","r",stdin);
    // freopen("sequence.out","w",stdout);
    for(int T=readint(); T; --T){
        n = readint(), m = readint();
        for(int i=1; i<=n; ++i){
            a[i] = readint();
            fa[i] = i, val[i] = 0;
            win[i] = false;
        }
        for(int i=1; i<=n; ++i)
            a[i] = readint()-a[i];
        for(int opt,x; m; --m){
            opt = readint()%2, x = readint();
            unionSet(x,readint(),opt);
        }
        for(int i=1,rt; i<=n; ++i){
            rt = findSet(i);
            if(rt == i) continue;
            if(val[i] == 1) // a[i]-=a[i],a[rt]-=a[i]
                a[rt] -= a[i]; // 权值同时增加a[i] ...
            else a[rt] += a[i]; // ... 需求便减少了
        }
        bool ok = true;
        for(int i=1,rt; i<=n and ok; ++i){
            rt = findSet(i);
            if(rt != i) continue;
            if(win[rt]) a[rt] %= 2;
            if(a[rt] != 0) ok = false;
        }
        if(ok) puts("YES"); else puts("NO");
    }
    return 0;
}

2.冒泡排序 题目链接 提高

题目描述

给定一个1 ~ n 的排列$p_i$， 接下来有m次操作， 操作共两种：
1.交换操作：给定x， 把当前排列的第x个数与第x+1个数交换位置。
2.询问操作：给定k， 请你求出当前排列经过k轮冒泡排序后逆序对的个数。对一长度为n的排列$p_i$进行一轮冒泡排序的伪代码如下：

for i = 1 to n-1:
	if p[i] > p[i+1]:
		swap(p[i], p[i+1]);

题目分析

我们首先要明白冒泡排序的本质：
看一组例子：
4 1 3 2 5
3 4 2 1 5
3 2 1 4 5
2 1 3 4 5
1 2 3 4 5
每一次转移的时候， 对于当前的这一个数，只有他前面没有比它大的， 他才会转移。。。
那么假如有x个要转移的数， 一轮下来， 就减少了n-x个逆序对。
所以当前有一个数， 前面有y个数比她大的话， 他需要经过y+1轮冒泡排序才能去转移。
用树状数组去预处理没有 操作一时候冒泡排序每一轮逆序对的数量。
在考虑转移；
用a数组表示输入进去的数， b数组表示在当前下标位置上， 前面有多少个比他大。
设当前交换的数为$a_x$, ， $b_x$为当前这个位置前有几个比它大的数。
当$a_x<a_{x+1}$时， 那么交换后初始逆序对个数会加一， 同时， 在x+1的位置上有多了个a_x+1所以$b_{x+1}$也会加1。但是当$b_x$为0时， 也就是x前没有数比$a_x$大时， 那么这个逆序对就是无效的， 因为下一轮冒泡接着就交换回去了。
当$a_x>a_{x+1}$时， $b_x$ - 1.当$b_{x+1}$为0时， 就失效了。
差分思想查询：前缀求和。

代码

#include
using namespace std;
const int maxn=2e5+5;
int n,m,a[maxn],b[maxn],d[maxn];
long long c[maxn],ans;
inline int lowbit(int x){
    return x&(-x);
}
inline void update(int x,long long val){
    while(x<=n){
        c[x]+=val;
        x+=lowbit(x);
    }
}
inline long long getsum(int x){
    long long res=0;
    while(x>0){
        res+=c[x];
        x-=lowbit(x);
    }
    return res;
}
int main(){
    int opt,x,tmp=0;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;++i){
        scanf("%d",&a[i]);
        b[i]=i-1-getsum(a[i]);
        ans+=b[i],++d[b[i]];
        update(a[i],1);
    }
    memset(c,0,sizeof(c));
    update(1,ans);
    for(int i=0;i<n;++i){
        tmp+=d[i];
        update(i+2,-(n-tmp));
    }
    for(int i=1;i<=m;++i){
        scanf("%d%d",&opt,&x);
        x=min(x,n-1);
        if(opt==1){
            if(a[x]<a[x+1]){
                swap(a[x],a[x+1]);
                swap(b[x],b[x+1]);
                update(1,1);
                update(b[x+1]+2,-1);
                b[x+1]++;
            }
            else{
                swap(a[x],a[x+1]);
                swap(b[x],b[x+1]);
                update(1,-1);
                b[x]--;
                update(b[x]+2,1);
            }
        }
        else printf("%lld\n",getsum(x+1));
    }
    return 0;
}

3.最小环 题目描述 提高

题目描述

给定一个长度为n的正整数序列$a_i$，下标从1开始编号。我们将该序列视为一个首尾相连的环， 对于下标为$i,j(i\le j)$的两个数$a_i,a_j$， 他们的距离为$min(j-i,i+n-j)$。
现在再给定m个整数$k_1,k_2......,k_m$， 对每个$k_i(i=1,2,....,m)$，你需要将上面的序列$a_i$重新排列， 使得换上任意两个距离为$k_i$的数字的乘积之和最大。

题目分析

k = 0

显然， 每个数距离为0的点就是他自己， 所以， 答案就为每个数的平方和。

k = 1

看样例， 我们的6个数中要使相邻两个数的乘积之和最大， 那么先把6放进去。然后再放与他相邻最大的5，4， 再放最大的2，3， 但大贴大， 小贴小。这样很显然是正确的， 因为设5， 4， 为一组， 设成a, b; 3，2为一组， 设成c, d；那么我们这一种方案就是$ac+bd$
另一种就是$ad+bc$, 显然， 两者一减， 前一种方案大。

k = 2

把他分成两个环， 分别解决。

多了

环的长度为n/gcd(n, k)
长度一样答案一样， 记得记忆化。

#include 
using namespace std;

map<int, long long> record;

int gcd(int a, int b)
{
    int temp;
    while (b)
    {
        temp = b;
        b = a % b;
        a = temp;
    }
    return a;
}(

long long a[200005];

int main()
{
    int n, m;
    scanf("%d%d", &n, &m);
    for (int i = 0; i < n; i++)
        scanf("%lld", a + i);
    sort(a, a + n, greater<long long>()); //从大到小排序
    for (int i = 0; i < m; i++)
    {
        int k;
        scanf("%d", &k);
        long long answer = 0;
        if (k == 0) //特判，不然下面gcd会出错
        {
            for (int p = 0; p < n; p++)
                answer += a[p] * a[p];
            printf("%lld\n", answer);
            continue;
        }
        int ring = n / gcd(n, k); //环长
        if (record[ring])         //记忆化
        {
            printf("%lld\n", record[ring]);
            continue;
        }
        for (int p = 0; p < n; p += ring)
        {                                                                 //对于每一个环，p记录每个环最开始的点的下标
            for (int x = 0, tp = p + 1; x < (ring - 2) / 2; x++, tp += 2) //一半环
                answer += a[tp] * a[tp + 2];
            for (int x = 0, tp = p; x < (ring - 1) / 2; x++, tp += 2) //另一半环
                answer += a[tp] * a[tp + 2];
            answer += a[p] * a[p + 1] + a[p + ring - 1] * a[p + ring - 2]; //最后处理两个半环链接的问题
        }
        printf("%lld\n", answer);
        record[ring] = answer; //记录
    }
    return 0;
}