2021.10.17

T1:裂变链接

Problem:

现在有𝑁个异构体在前线排成一排参与战斗，但由于地方火力过于凶猛，异构体们都受到了不同程度的损伤。为了能够让所有异构体继续战斗，避免由于能量不均衡导致的爆炸，异构体们需要使得他们彼此之间的能量值一样。记第𝑖个异构体当前𝑒𝑖的能量，每个时刻，每个异构体都可以做如下三种操作中的一种：

1、传递1的能量给自己左边相邻的异构体（如果存在）。

2、传递1的能量给自己右边相邻的异构体（如果存在）。

3、传递1的能量给自己（摸鱼）。

为了尽快的回到前线作战，异构体们希望在最短的时间内使得所有异构体的能量值一样，问最短时间。数据保证有解。操作过程中自己的能量可以变为负数。

Solution：

每个物体只用考虑能量向左还是向右传递，找到需要传递能量最多的物体即可。

Code:

#include<bits/stdc++.h>
using namespace std;
const int maxn=100010;
int n,z[maxn];
long long sum[maxn];
void read(){
    scanf("%d",&n);
    for(int a=1;a<=n;a++) scanf("%d",&z[a]);
}
long long work(){
    for(int a=1;a<=n;a++) sum[a]=sum[a-1]+z[a];
    if(sum[n]%n) return -1;
    long long ans=0,v=sum[n]/n;
    for(int a=1;a<=n;a++){
        long long l=sum[a-1]-1ll*(a-1)*v;
        long long r=sum[n]-sum[a]-1ll*(n-a)*v;
        if(l<0&&r<0) ans=max(ans,-l-r);
        ans=max(ans,max(abs(l),abs(r)));
    }
    return ans;
}
int main(){
    read();
    printf("%lld\n",work());
    return 0;
}

T2:死亡鸽者

Problem:

死亡鸽者最喜欢的事情就是咕咕咕，他的座右铭“风萧萧兮易水寒，壮士一去兮不复返，然鸽子至今未到”也每天被他所忘记。今天，死亡鸽者又要开始咕咕的旅行了。现在有𝑁座城市排成一排，死亡鸽者会从第一座城市一直走到最后一座城市。每个城市都有一个数𝑎𝑖，每次死亡鸽者可以选择取走或者不取走这个数，但想要取走这个数的话要求这个数必须是所有已经取走的数的倍数或者约数。现在问死亡鸽者从第一座城市走到最后一座城市的过程中，最多取走多少个数。

Solution:

所有数的顺序并不影响，按照所有数从小到大排序后可以转化为取倍数问题。利用类似于埃式筛法的思路可以做到O(nlogn)。

Code:

#include<bits/stdc++.h>
using namespace std;
const int maxn=1000010;
int n,cnt[maxn],f[maxn];
int main(){
    scanf("%d",&n);
    for(int a=1;a<=n;a++){
        int v;
        scanf("%d",&v);
        cnt[v]++;
        f[v]++;
    }
    int ans=0;
    for(int a=1;a<=1000000;a++){
        if(f[a]){
            if(f[a]>ans) ans=f[a];
            for(int b=a+a;b<=1000000;b+=a){
                if(cnt[b]&&f[a]+cnt[b]>f[b]) f[b]=f[a]+cnt[b];
            }
        }
    }
    printf("%d\n",ans);
    return 0;
}

T3:进阶之灾

Problem:

TarjanLusa 是一款风靡全球的卡牌游戏，在这款游戏中，你需要一层一层的前进，击败像萌死戳、天启骑士等 boss，最终来到心脏面前一决胜负。为了能够有一套更好的卡牌来面对心脏，我们需要在每一层选择更好的卡牌。假设我们总共有𝑁层，在第𝑖层的时候，我们可以从两张卡牌中选择一张加入我们的卡组，这两张卡牌的战斗力分别为𝑎𝑖, 𝑏𝑖。在经过𝑁层的选择之后，我们便会有一套𝑁张卡的卡组，而整套卡组的战斗力取决于卡牌与卡牌之间战斗力差值的绝对值的最小值。但是心脏是一个非常强大的敌人，如果我们不能拥有强大的战斗力，人类就

会一败涂地。所以，现在我们想知道，战斗力最大可能是多少。

Solution:

二分答案。
每次检验的时候会发现，一组卡牌中的一张选了会导致其他某组卡牌必须选另外一张，从而转化为2-SAT问题。
但由于数据范围过大，直接2SAT无法建图，注意到所有的边都是在一个区间里面的边，所以用线段树优化建图即可。

Code:

#include<bits/stdc++.h>
using namespace std;
const int maxn=200010;
const int maxp=maxn+(maxn<<2);
const int maxm=maxn+maxp+maxn*40;
int n,size,cnt,en,t,dfn[maxp],low[maxp],s[maxp],belong[maxp],pos[maxn];
bool instack[maxp];
struct edge{
    int e;
    edge *next;
}*v[maxp],ed[maxm];
void add_edge(int s,int e){
    en++;
    ed[en].next=v[s];
    v[s]=ed+en;
    v[s]->e=e;
}
struct rec{
    int v,p;
    rec(){}
    rec(int a,int b){
        v=a;
        p=b;
    }
}z[maxn];
bool operator<(const rec &a,const rec &b){
    return a.v<b.v;
}
void dfs(int p){
    t++;
    dfn[p]=low[p]=t;
    instack[p]=true;
    s[++size]=p;
    for(edge *e=v[p];e;e=e->next){
        if(!dfn[e->e]){
            dfs(e->e);
            low[p]=min(low[p],low[e->e]);
        }
        else{
            if(instack[e->e]) low[p]=min(low[p],dfn[e->e]);
        }
    }
    if(dfn[p]==low[p]){
        cnt++;
        while(s[size]!=p){
            belong[s[size]]=cnt;
            instack[s[size]]=false;
            size--;
        }
        belong[p]=cnt;
        instack[p]=false;
        size--;
    }
}
void build(int l,int r,int rt){
    if(l==r){
        add_edge(rt+(n<<1),z[l].p<=n?z[l].p+n:z[l].p-n);
        return;
    }
    int m=(l+r)>>1;
    build(l,m,rt<<1);
    build(m+1,r,rt<<1|1);
    add_edge(rt+(n<<1),(rt<<1)+(n<<1));
    add_edge(rt+(n<<1),(rt<<1|1)+(n<<1));
}
void insert(int l,int r,int rt,int nowl,int nowr,int p){
    if(nowl<=l&&r<=nowr){
        add_edge(p,rt+(n<<1));
        return;
    }
    int m=(l+r)>>1;
    if(nowl<=m) insert(l,m,rt<<1,nowl,nowr,p);
    if(m<nowr) insert(m+1,r,rt<<1|1,nowl,nowr,p);
}
bool check(int k){
    en=0;
    cnt=0;
    memset(v,0,sizeof(v));
    memset(dfn,0,sizeof(dfn));
    build(1,(n<<1),1);
    int r=1,l=1;
    for(int a=1;a<=(n<<1);a++){
        int op,p=z[a].p;
        if(p<=n) op=pos[p+n];
        else op=pos[p-n];
        while(r<=a&&z[r].v<=z[a].v-k) r++;
        if(r<a&&r>=1&&z[r].v>z[a].v-k){
            if(op>=r&&op<=a-1){
                if(op>r) insert(1,(n<<1),1,r,op-1,z[a].p);
                if(op<a-1) insert(1,(n<<1),1,op+1,a-1,z[a].p);
            }
            else insert(1,(n<<1),1,r,a-1,z[a].p);
        }
        while(l<=(n<<1)&&z[l].v<z[a].v+k) l++;
        l--;
        if(l>a&&l<=(n<<1)&&z[l].v<z[a].v+k){
            if(op>=a+1&&op<=l){
                if(op>a+1) insert(1,(n<<1),1,a+1,op-1,z[a].p);
                if(op<l) insert(1,(n<<1),1,op+1,l,z[a].p);
            }
            else insert(1,(n<<1),1,a+1,l,z[a].p);
        }
    }
    for(int a=1;a<=(n<<1);a++) if(!dfn[a]) dfs(a);
    for(int a=1;a<=n;a++) if(belong[a]==belong[a+n]) return false;
    return true;
}
int main(){
    scanf("%d",&n);
    int minv=0x3f3f3f3f,maxv=-0x3f3f3f3f;
    int x=0;
    for(int a=1;a<=n;a++){
        int v1,v2;
        scanf("%d%d",&v1,&v2);
        z[++x]=rec(v1,a);
        z[++x]=rec(v2,a+n);
        minv=min(minv,min(v1,v2));
        maxv=max(maxv,max(v1,v2));
    }
    if(maxv-minv+1<n){
        printf("0\n");
        return 0;
    }
    sort(z+1,z+x+1);
    for(int a=1;a<=(n<<1);a++) pos[z[a].p]=a;
    int l=0,r=1000000001;
    while(l+1!=r){
        int m=(l+r)>>1;
        if(check(m)) l=m;
        else r=m;
    }
    printf("%d\n",l);
    return 0;
}