NOI2022 题解

upd：树上邻域数点如果 50 踩那国赛后会有的。可能是直接开写也可能是明年。截止笔试之前！

[NOI2022] 众数

首先看到题面第一句话发现这玩意跟摩尔投票一样。然后我们知道摩尔投票有结合律。于是我们如果不考虑前两个操作，那每个序列开个动态开点线段树维护一下摩尔投票，然后合并可以线段树合并，查询直接查每个序列摩尔投票的和，然后再统计一下这个答案在所有序列里的出现次数是否合法即可。

对于前两个操作，可以开个什么东西动态地维护序列，然后合并可以启发式合并。

然后是坑：首先这题赛时爆了一车零，因为 1e6 个 deque 会 MLE。需要 list。

然后是这题赛时一车人挂了 0-30 不等，因为查询的序列可能相同，因此统计次数要开 long long。

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <vector>
#include <list>
using namespace std;
int n,q;
list<int>v[1000010];
struct data{
    int val;
    long long cnt;
    data operator+(data s){
        if(val==s.val)return {val,cnt+s.cnt};
        else{
            if(cnt>s.cnt)return {val,cnt-s.cnt};
            else return {s.val,s.cnt-cnt};
        }
    }
};
struct node{
    #define lson tree[rt].ls
    #define rson tree[rt].rs
    int ls,rs;
    data val;
}tree[1000010<<5];
int t,rt[1000010];
void pushup(int rt){
    tree[rt].val=tree[lson].val+tree[rson].val;
}
void update(int &rt,int L,int R,int pos,int val){
    if(!rt)rt=++t;
    if(L==R){
        tree[rt].val.val=pos;
        tree[rt].val.cnt+=val;
        return;
    }
    int mid=(L+R)>>1;
    if(pos<=mid)update(lson,L,mid,pos,val);
    else update(rson,mid+1,R,pos,val);
    pushup(rt);
}
int query(int rt,int L,int R,int pos){
    if(!rt)return 0;
    if(L==R)return tree[rt].val.cnt;
    int mid=(L+R)>>1;
    if(pos<=mid)return query(lson,L,mid,pos);
    else return query(rson,mid+1,R,pos);
}
int merge(int x,int y,int l,int r){
    if(!x||!y)return x|y;
    if(l==r){
        tree[x].val.cnt+=tree[y].val.cnt;
        return x;
    }
    int mid=(l+r)>>1;
    tree[x].ls=merge(tree[x].ls,tree[y].ls,l,mid);
    tree[x].rs=merge(tree[x].rs,tree[y].rs,mid+1,r);
    pushup(x);
    return x;
}
int main(){
    scanf("%d%d",&n,&q);int lim=n+q;
    for(int i=1;i<=n;i++){
        int l;scanf("%d",&l);
        while(l--){
            int x;scanf("%d",&x);
            v[i].push_back(x);update(rt[i],1,lim,x,1);
        }
    }
    while(q--){
        int od;scanf("%d",&od);
        if(od==1){
            int x,y;scanf("%d%d",&x,&y);
            v[x].push_back(y);
            update(rt[x],1,lim,y,1);
        }
        else if(od==2){
            int x;scanf("%d",&x);
            int y=v[x].back();v[x].pop_back();
            update(rt[x],1,lim,y,-1);
        }
        else if(od==3){
            data val={0,0};
            int m;scanf("%d",&m);
            long long cnt=0,sum=0;
            static int tmp[500010];
            for(int i=1;i<=m;i++){
                scanf("%d",&tmp[i]);
                val=val+tree[rt[tmp[i]]].val;
                sum+=v[tmp[i]].size();
            }
            for(int i=1;i<=m;i++)cnt+=query(rt[tmp[i]],1,lim,val.val);
            if((cnt<<1)<=sum)puts("-1");
            else printf("%d\n",val.val);
        }
        else{
            int x1,x2,x3;scanf("%d%d%d",&x1,&x2,&x3);
            rt[x1]=merge(rt[x1],rt[x2],1,lim);rt[x3]=rt[x1];
            if(v[x1].size()<v[x2].size()){
                while(!v[x1].empty())v[x2].push_front(v[x1].back()),v[x1].pop_back();
                swap(v[x2],v[x3]);
            }
            else{
                while(!v[x2].empty())v[x1].push_back(v[x2].front()),v[x2].pop_front();
                swap(v[x1],v[x3]);
            }
        }
    }
    return 0;
}

[NOI2022] 移除石子

一道玄学的题目。

首先考虑如何判定。先看 k=0,l=r 的部分，即给定一个序列如何判定是否有解。

观察到操作 2 只会有 3,4,5 长度的而且不会重复。

设 dpi,j,k 为到 i，钦定有 j 个 i 之前的段延长到 i，必须有 k 个延伸到 i+1 是否合法。转移考虑初值 dp1,0,0=1，从 i 转移到 i+1 时枚举从 i 开始的操作个数 l，若 ai−j−k−l 小于 0 或等于 1 则不合法，否则选出 p∈[k,k+j] 个钦定延伸到 i+1，并使 dpi+1,p,l=1，答案即 dpn+1,0,0。复杂分析或者打个大表一直拍可以得到 j,k 只取到 [0,2] 一共九种状态。

考虑 k>0 的判断。容易发现大部分情况下 k 合法则 >k 的数也合法，特例是 k=1 且全 0 或 k=1,n=3 且三个都是 1。于是设 fi,j,k 为使 dpi,j,k=1 至少添加的石子个数，转移同样枚举 l 和 p，容易得到至少在 i 出添加多少个石子。检查是否 fn+1,0,0≤k 即可。

然后是关于计数。先对 k=0 计数：由于 j,k,l≤2，因此 ≥8 的所有 ai 都是等价的。打个大表一直拍可以把这个界减到 6。于是只要枚举 [0,6]。考虑 dp 套 dp：先暴力搜出 ai 为某个数时一种状态会转移到哪种状态。转移枚举状态 s 和 ai，对于 ai<6 那么只要 li≤ai≤ri 就有一倍贡献，ai≥6 时则每个 ai 都有贡献，转移很简单。

把两个东西拼起来，k 是 100 所以 g 的值域是 [0,101]，看起来状态数是 1029。但是搜一下会发现实际上 8000 多种，直接跑就行了。

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <vector>
#include <map>
using namespace std;
const int mod=1000000007;
int n,k,num,ans,trans[10010][7],dp[2][10010],l[1010],r[1010];
map<vector<int>,int>mp;
int dfs(vector<int>g){
    if(mp.find(g)!=mp.end())return mp[g];
    mp[g]=num++;int id=mp[g];
    for(int i=0;i<7;i++){
        vector<int>tmp;
        for(int j=0;j<9;j++)tmp.push_back(101);
        for(int j=0;j<3;j++){
            for(int k=0;k<3;k++){
                if(g[3*j+k]==101)continue;
                for(int x=0;x<3;x++){
                    int val=i-j-k-x;
                    if(val<0)val=-val;
                    else val=val==1;
                    for(int l=k;l<=min(2,j+k);l++)tmp[3*l+x]=min(tmp[3*l+x],g[3*j+k]+val);
                }
            }
        }
        trans[id][i]=dfs(tmp);
    }
    return id;
}
int main(){
    int tim;scanf("%d",&tim);
    dfs({0,101,101,101,101,101,101,101,101});
    while(tim--){
        scanf("%d%d",&n,&k);ans=0;
        for(int i=1;i<=n;i++)scanf("%d%d",&l[i],&r[i]);
        memset(dp,0,sizeof(dp));dp[0][0]=1;
        int cur=0;
        for(int i=1;i<=n;i++){
            cur^=1;
            memset(dp[cur],0,sizeof(dp[cur]));
            for(int j=0;j<num;j++){
                if(!dp[cur^1][j])continue;
                for(int k=0;k<7;k++){
                    int ret=0;
                    if(k<6)ret=l[i]<=k&&k<=r[i];
                    else if(r[i]>=6)ret=r[i]-max(l[i],6)+1;
                    dp[cur][trans[j][k]]=(dp[cur][trans[j][k]]+1ll*ret*dp[cur^1][j])%mod;
                }
            }
        }
        for(pair<vector<int>,int>p:mp)if(p.first[0]<=k)ans=(ans+dp[cur][p.second])%mod;
        if(k==1){
            bool jud=true;
            for(int i=1;i<=n;i++)if(l[i]!=0){
                jud=false;break;
            }
            if(jud)ans=(ans-1+mod)%mod;
            if(n==3&&l[1]<=1&&r[1]>=1&&l[2]<=1&&r[2]>=1&&l[3]<=1&&r[3]>=1)ans=(ans-1+mod)%mod;
        }
        printf("%d\n",ans);
    }
    return 0;
}

[NOI2022] 树上邻域数点

不会 Top Tree。

但是你要是在笔试之前能给我点够 50 踩也不是不可以会。

[NOI2022] 挑战 NPC Ⅱ

看到 k 比较小，于是来个暴力一点的方法。

我们顺序搜两棵树，然后哈希值相同的直接匹配显然是最优的，哈希值不同的可以 O(k!) 暴力枚举哪对之间匹配然后暴力搜下去。

然后还需要加上一些玄学剪枝：首先如果 G 的儿子个数 / 子树大小小于 H 的儿子个数 / 子树大小显然不合法。然后如果子树大小相同直接返回哈希值相同。好像还有别的剪枝，不过不加也没什么关系，反正能过。

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <vector>
using namespace std;
typedef unsigned long long ull;
int n1,n2;
ull nxt(ull x){
	x^=x<<13;x^=x>>7;x^=x<<17;
	return x;
}
ull hs[100010][2];
vector<int>g[100010][2];
bool cmp1(int a,int b){
    return hs[a][0]<hs[b][0];
}
bool cmp2(int a,int b){
    return hs[a][1]<hs[b][1];
}
int size[100010][2];
void dfs1(int x,int id){
    hs[x][id]=size[x][id]=1;
    for(int v:g[x][id]){
        dfs1(v,id);
        hs[x][id]+=nxt(hs[v][id]);
        size[x][id]+=size[v][id];
    }
    if(id==0)sort(g[x][id].begin(),g[x][id].end(),cmp1);
    else sort(g[x][id].begin(),g[x][id].end(),cmp2);
}
bool dfs(int x,int y){
    if(g[x][0].size()<g[y][1].size())return false;
    if(size[x][0]<size[y][1])return false;
    if(size[x][0]==size[y][1])return hs[x][0]==hs[y][1];
    vector<int>A,B;
    int a=0,b=0;
    while(a<g[x][0].size()&&b<g[y][1].size()){
        if(hs[g[x][0][a]][0]==hs[g[y][1][b]][1])a++,b++;
        else if(hs[g[x][0][a]][0]<hs[g[y][1][b]][1])A.push_back(g[x][0][a]),a++;
        else B.push_back(g[y][1][b]),b++;
    }
    while(a<g[x][0].size())A.push_back(g[x][0][a]),a++;
    while(b<g[y][1].size())B.push_back(g[y][1][b]),b++;
    vector<int>p;
    for(int i=0;i<A.size();i++)p.push_back(i);
    do{
        bool jud=true;
        for(int i=0;i<B.size();i++){
            if(size[A[p[i]]][0]<size[B[i]][1]){
                jud=false;break;
            }
        }
        if(!jud)continue;
        for(int i=0;i<B.size();i++){
            if(!dfs(A[p[i]],B[i])){
                jud=false;break;
            }
        }
        if(jud)return true;
    }while(next_permutation(p.begin(),p.end()));
    return false;
}
int main(){
    int tim;scanf("%*d%d%*d",&tim);
    while(tim--){
        scanf("%d",&n1);
        int rt1,rt2;
        for(int i=1;i<=n1;i++){
            int f;scanf("%d",&f);
            if(f==-1)rt1=i;
            else g[f][0].push_back(i);
        }
        scanf("%d",&n2);
        for(int i=1;i<=n2;i++){
            int f;scanf("%d",&f);
            if(f==-1)rt2=i;
            else g[f][1].push_back(i);
        }
        dfs1(rt1,0);dfs1(rt2,1);
        if(dfs(rt1,rt2))puts("Yes");
        else puts("No");
        for(int i=1;i<=n1;i++)g[i][0].clear();
        for(int i=1;i<=n2;i++)g[i][1].clear();
    }
}

[NOI2022] 冒泡排序

首先显然可以让所有数只取到给定的 V 中的数。于是先离散化一下。然后最小化逆序对个数。

先看 B 部分分。确定了一堆单点，那么开个区间加查最小值的线段树随便扫一扫就行了。

然后是 C。容易发现把区间的最小值放在开头一定最优，于是变成了确定一堆单点，每个位置 ≥ 某个数。也是线段树扫一扫就行了。

最后是比较困难的 A。根据上边的性质，我们必须把 1 铺满。然后看剩下的 0 的区间，它就变成了 C 部分。在开头安上然后线段树扫一扫就行了。

于是正解就十分显然了：我们把 V 从大到小排序，每次扫所有 ≥V 且没扫过的位置（可以用并查集记录扫没扫），在开头确定为最小值，然后给剩下的位置打个 ≥ 这个最小值的标记。确定的部分可以树状数组扫一遍统计，不确定的线段树扫一扫。

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <vector>
using namespace std;
int n,m,lsh[1000010];
long long ans;
struct ques{
    int l,r,val;
}q[1000010];
vector<pair<int,int> >v[1000010];
struct BIT{
    int c[1000010];
    #define lowbit(x) (x&-x)
    void update(int x){
        while(x)c[x]++,x-=lowbit(x);
    }
    int query(int x){
        int sum=0;
        while(x<=m)sum+=c[x],x+=lowbit(x);
        return sum;
    }
}c;
int fa[1000010];
int find(int x){
    return x==fa[x]?fa[x]:fa[x]=find(fa[x]);
}
struct node{
    #define lson rt<<1
    #define rson rt<<1|1
    int mn,pos,lz;
}tree[4000010];
void pushup(int rt){
    tree[rt].mn=min(tree[lson].mn,tree[rson].mn);
    if(tree[rt].mn==tree[lson].mn)tree[rt].pos=tree[lson].pos;
    else tree[rt].pos=tree[rson].pos;
}
void pushtag(int rt,int val){
    tree[rt].mn+=val;tree[rt].lz+=val;
}
void pushdown(int rt){
    if(tree[rt].lz){
        pushtag(lson,tree[rt].lz);
        pushtag(rson,tree[rt].lz);
        tree[rt].lz=0;
    }
}
void build(int rt,int l,int r){
    tree[rt].mn=tree[rt].lz=0;tree[rt].pos=l;
    if(l==r)return;
    int mid=(l+r)>>1;
    build(lson,l,mid);build(rson,mid+1,r);
}
void update(int rt,int L,int R,int l,int r,int val){
    if(l<=L&&R<=r){
        pushtag(rt,val);return;
    }
    pushdown(rt);
    int mid=(L+R)>>1;
    if(l<=mid)update(lson,L,mid,l,r,val);
    if(mid<r)update(rson,mid+1,R,l,r,val);
    pushup(rt);
}
pair<int,int> query(int rt,int L,int R,int l,int r){
    if(l<=L&&R<=r)return make_pair(tree[rt].mn,tree[rt].pos);
    pushdown(rt);
    int mid=(L+R)>>1;
    pair<int,int>val=make_pair(0x3f3f3f3f,0x3f3f3f3f);
    if(l<=mid)val=min(val,query(lson,L,mid,l,r));
    if(mid<r)val=min(val,query(rson,mid+1,R,l,r));
    return val;
}
int val[1000010],mn[1000010];
void solve(){
    scanf("%d%d",&n,&m);ans=0;
    for(int i=1;i<=n+1;i++)fa[i]=i,val[i]=mn[i]=0;
    for(int i=1;i<=m;i++)c.c[i]=0,v[i].clear();
    for(int i=1;i<=m;i++)scanf("%d%d%d",&q[i].l,&q[i].r,&q[i].val),lsh[i]=q[i].val;
    sort(lsh+1,lsh+m+1);
    for(int i=1;i<=m;i++){
        q[i].val=lower_bound(lsh+1,lsh+m+1,q[i].val)-lsh;
        v[q[i].val].push_back(make_pair(q[i].l,q[i].r));
    }
    for(int i=m;i>=0;i--){
        if(v[i].empty())continue;
        sort(v[i].begin(),v[i].end());
        int pre=n+1;
        for(int j=v[i].size()-1;j>=0;j--){
            if(v[i][j].second<pre){
                int pos=find(v[i][j].first);
                if(pos>v[i][j].second){
                    puts("-1");return;
                }
                val[pos]=i;pre=pos;
            }
        }
        for(pair<int,int>p:v[i]){
            for(int j=find(p.first);j<=p.second;j=find(j))mn[j]=i,fa[j]=j+1;
        }
    }
    build(1,0,m+1);
    for(int i=1;i<=n;i++){
        if(val[i]){
            ans+=c.query(val[i]+1);
            c.update(val[i]);
            update(1,0,m+1,val[i]+1,m+1,1);
        }
    }
    for(int i=1;i<=n;i++){
        if(val[i]){
            update(1,0,m+1,val[i]+1,m+1,-1);
            update(1,0,m+1,0,val[i]-1,1);
        }
        else{
            pair<int,int>p=query(1,0,m+1,mn[i],m+1);
            ans+=p.first;
            if(p.second)update(1,0,m+1,0,p.second-1,1);
        }
    }
    printf("%lld\n",ans);
}
int main(){
    int tim;scanf("%d",&tim);
    while(tim--)solve();
    return 0;
}

[NOI2022] 二次整数规划问题

你觉得我会写吗？这篇博要是在 cnblogs 超过 20 个踩我就写。

妈妈生的，怎么这么能踩。

看题面发现这个限制非常奇怪。数据范围也很奇怪。然后 k=3,4,5 而且 3,4 一个 10 分更加奇怪。于是初步断定是个不可做题。

先看 k=3。显然如果一个数能取 2 那么取 2 更优，因为在 G 可以对所有数有贡献，在后半有 v2 的贡献。那么现在要找到所有只能取 1,3 的数。

一个数什么时候只能取 1？一种显然的情况是 r=1。另一种情况是和一个只能取 1 的数之间有第二类约束且 b=0。那么不难找到所有这样的点，直接计算即可。

然后是 k=4。可以发现去掉必须选 1,4 的，剩下的不选 1,4 更优。进一步的，能选 [2,k−1] 就选。然后需要决策剩下的选 2 还是选 3。观察对两部分的贡献：对于 G，相互之间一定有贡献，如果选 2 那就是和 1 贡献，选 3 就是和 4 贡献。对于后边的部分，选 2 有 v2，选 3 有 v3。每个位置是独立的，所以要么全 2 要么全 3，比一下就好了。

但是我们这时候还有第二类约束的限制，决定了一些点只能选 2/3。但是这个是个形似最短路的东西：对于 i,j 的约束，可以使 j 的区间变成 [lj,rj]∩[li−b,ri+b]。直接松弛 n 轮即可。于是我们在处理信息之前先松弛一遍得到真正的区间限制。

最后是 k=5 的情况。显然有结论：对于值域相同的数可以取到同一个值最优。然而第二类约束仍然是难以处理的。

确定 1,5 的个数之后，2,3,4 的个数 c2,c3,c4 的总和是一定的，因此可以只用 (c2,c4) 计算贡献。考虑找到能够贡献给答案的点：用 (c2,c4) 的答案减掉 (0,0) 的答案，化简一波式子变成：每次询问给定 C1,C2，求 (c2−C1)(c4−C2) 的最小值。

把所有点 (x,y) 扔到二维平面上，那么所有点在 ([minx,maxx],[miny,maxy]) 矩形中且一定可以取到 (minx,miny),(maxx,miny),(minx,maxy) 三个点。现在的问题变成平移矩形求 minx×y。

对于矩形和一 / 二 / 四象限有交的情况，只需要上边三个点。对于全部在第三象限的情况，则是整个点集的右上凸包，根据集训队论文它的大小上界是 O(n23) 的。

于是套用最小乘积生成树的做法，只需要求两点间离连线最远的点。设两个点为 (x1,y1),(x2,y2)，那么选 2 有 x2−x1 的代价，选 4 有 y1−y2 的代价，选 3 有 y1−y2+x2−x1 的代价，有若干组限制要求两个点之差不能超过某个数，求最小代价。这是切糕那题，直接跑网络流。

#include <iostream>
#include <algorithm>
#include <algorithm>
#include <cstring>
#include <vector>
#include <queue>
#define int long long
using namespace std;
const int inf=0x3f3f3f3f;
int n,m,k,q,l[610],r[610],cnt[10],val[10],size[610],belong[610];
vector<pair<int,int> >g[610];
int calc(){
    int ans=0;
    for(int i=2;i<k;i++)ans+=val[i]*cnt[i];
    for(int i=1;i<=k;i++){
        for(int j=max(i-1,1ll);j<=min(i+1,k);j++)ans+=1000000*cnt[i]*cnt[j];
    }
    return ans;
}
struct gra{
    int v,w,next;
}edge[100010];
int t,head[3010];
void Add(int u,int v,int w){
    edge[++t].v=v;edge[t].w=w;edge[t].next=head[u];head[u]=t;
}
void add(int u,int v,int w){
    Add(u,v,w);Add(v,u,0);
}
int S,T,dis[3010],head2[3010];
bool bfs(int st){
    queue<int>q;
    for(int i=0;i<=T;i++)head2[i]=head[i],dis[i]=0;
    dis[st]=1;q.push(st);
    while(!q.empty()){
        int x=q.front();q.pop();
        for(int i=head[x];i;i=edge[i].next){
            if(edge[i].w&&!dis[edge[i].v]){
                dis[edge[i].v]=dis[x]+1;
                if(edge[i].v==T)return true;
                q.push(edge[i].v);
            }
        }
    }
    return false;
}
int dfs(int x,int flow){
    if(x==T)return flow;
    int sum=0;
    for(int &i=head2[x];i;i=edge[i].next){
        if(edge[i].w&&dis[edge[i].v]==dis[x]+1){
            int ret=dfs(edge[i].v,min(flow,edge[i].w));
            if(ret){
                flow-=ret;sum+=ret;
                edge[i].w-=ret;edge[i^1].w+=ret;
                if(!flow)break;
            }
            else dis[edge[i].v]=-1;
        }
    }
    return sum;
}
struct node{
    int x,y;
    node operator-(const node&s)const{
        return {x-s.x,y-s.y};
    }
    int operator^(const node&s)const{
        return x*s.y-y*s.x;
    }
};
vector<node>tubao;
node dinic(){
    while(bfs(S))dfs(S,inf);
    node ans={};
    for(int i=1;i<=n;i++){
        if(size[i]==-1)continue;
        if(l[i]>=2&&r[i]<=4){
            if(!dis[i])ans.x+=size[i];
            else if(dis[i+n])ans.y+=size[i];
        }
    }
    return ans;
}
void solve(node X,node Y){
    int val1=Y.x-X.x,val2=X.y-Y.y;t=1;
    S=0,T=2*n+1;
    for(int i=0;i<=T;i++)head[i]=0;
    for(int i=1;i<=n;i++){
        if(size[i]==-1)continue;
        if(l[i]>=2&&r[i]<=4){
            if(l[i]>=3)add(S,i,inf);
            else add(S,i,val1*size[i]);
            if(r[i]<=3)add(i+n,T,inf);
            else add(i+n,T,val2*size[i]);
            if(l[i]==4||r[i]==2)add(i,i+n,inf);
            else add(i,i+n,(val1+val2)*size[i]);
        }
    }
    for(int x=1;x<=n;x++){
        for(pair<int,int>p:g[x]){
            int v=p.first,w=p.second;
            if(belong[x]!=belong[v]&&size[belong[x]]!=-1&&size[belong[v]]!=-1&&w==1)add(belong[x]+n,belong[v],inf);
        }
    }
    node mid=dinic();
    if(((Y-mid)^(X-mid))<0){
        tubao.push_back(mid);
        solve(X,mid);solve(mid,Y);
    }
}
void build(){
    for(int i=1;i<=n;i++){
        if(size[i]==-1)continue;
        size[i]=-1;int cnt=0;
        queue<int>q;q.push(i);
        while(!q.empty()){
            int x=q.front();q.pop();cnt++;
            belong[x]=i;
            for(pair<int,int>p:g[x]){
                int v=p.first,w=p.second;
                if(size[v]!=-1&&!w){
                    size[v]=-1;q.push(v);
                }
            }
        }
        size[i]=cnt;
    }
    tubao.push_back({cnt[2],cnt[4]});
    int cnt2=0,cnt4=0;
    for(int i=1;i<=n;i++){
        if(l[i]==2)cnt2++;
        if(r[i]==4)cnt4++;
    }
    node X={cnt[2],cnt4},Y={cnt2,cnt[4]};
    tubao.push_back(X);tubao.push_back(Y);
    solve(X,Y);
}
int getans(node x){
    cnt[2]=x.x,cnt[4]=x.y,cnt[3]=n-cnt[1]-cnt[2]-cnt[4]-cnt[5];
    return calc();
}
signed main(){
    int tim;scanf("%lld%lld",&tim,&tim);
    while(tim--){
        scanf("%lld%lld%lld%lld",&k,&n,&m,&q);
        for(int i=1;i<=n;i++)scanf("%lld%lld",&l[i],&r[i]);
        for(int i=1;i<=m;i++){
            int u,v,w;scanf("%lld%lld%lld",&u,&v,&w);
            g[u].push_back(make_pair(v,w));g[v].push_back(make_pair(u,w));
        }
        for(int i=1;i<=n;i++){
            for(int x=1;x<=n;x++){
                for(pair<int,int>p:g[x]){
                    int v=p.first,w=p.second;
                    l[v]=max(l[v],l[x]-w);
                    r[v]=min(r[v],r[x]+w);
                }
            }
        }
        for(int i=1;i<=n;i++){
            if(r[i]!=1&&l[i]!=k)l[i]=max(l[i],2ll),r[i]=min(r[i],k-1);
            if(l[i]==r[i])cnt[l[i]]++;
            else cnt[0]++;
        }
        if(k==5)build();
        while(q--){
            for(int i=2;i<k;i++)scanf("%lld",&val[i]);
            if(k==3)printf("%lld\n",calc());
            if(k==4){
                int ans=0;
                cnt[2]+=cnt[0];ans=max(ans,calc());cnt[2]-=cnt[0];
                cnt[3]+=cnt[0];ans=max(ans,calc());cnt[3]-=cnt[0];
                printf("%lld\n",ans);
            }
            if(k==5){
                int ans=0;
                for(node x:tubao)ans=max(ans,getans(x));
                printf("%lld\n",ans);
            }
        }
        for(int i=1;i<=n;i++)g[i].clear(),size[i]=0;
        for(int i=0;i<=k;i++)cnt[i]=0;
        tubao.clear();
    }
    return 0;
}
posted @   gtm1514  阅读(839)  评论(18)  编辑  收藏  举报
相关博文：
· 字符串专题 1
· NOI2021 题解
· NOI2022（部分）题解
· 好题胡扯 2.0
· ZJOI2022 题解
阅读排行：
· 无需6万激活码！GitHub神秘组织3小时极速复刻Manus，手把手教你使用OpenManus搭建本
· C#/.NET/.NET Core优秀项目和框架2025年2月简报
· Manus爆火，是硬核还是营销？
· 终于写完轮子一部分：tcp代理 了，记录一下
· 【杭电多校比赛记录】2025“钉耙编程”中国大学生算法设计春季联赛（1）
点击右上角即可分享
微信分享提示