久违的题解 多校联考

题目描述

Evensgn 有一群好朋友，他们经常互相借钱。假如说有三个好朋友 A，B，C。

A 欠 B 20 元，B 欠 C 20 元，总债务规模为 20+20=40 元。Evensgn 是个追求简约

的人，他觉得这样的债务太繁杂了。他认为，上面的债务可以完全等价为 A 欠 C

20 元，B 既不欠别人，别人也不欠他。这样总债务规模就压缩到了 20 元。

现在给定 n 个人和 m 条债务关系。Evensgn 想找到一种新的债务方案，使得

每个人欠钱的总数不变，或被欠钱的总数不变（但是对象可以发生变化），并且使

得总债务规模最小。

输入

输入文件第一行两个数字 n; m，含义如题目所述。

接下来 m 行，每行三个数字 ai; bi; ci，表示 ai 欠 bi 的钱数为 ci。

注意，数据中关于某两个人 A 和 B 的债务信息可能出现多次，将其累加即可。

如”A 欠 B 20 元”、”A 欠 B 30 元”、”B 欠 A 10 元”，其等价为”A 欠 B 40 元”。

输出

输出文件共一行，输出最小的总债务规模。

样例输入

样例输入 1
5 3
1 2 10
2 3 1
2 4 1

样例输出

样例输出 1

10

考试的T1，在考试的时候想了N^3的用队列+枚举每个人和他之间的关系来转移债务，转移极其麻烦且讨论极多，正解只是个结论。Ans=abs（每个人欠别人的-别人欠他的），

然后在除2，因为每个人被算了两次。

这么水的题还打了Tarjan缩点。

#include <stdio.h>
#include <cstring>
#include <iostream>
#include <cmath>
#define MAXN 1000005
int n,m,first[MAXN],e=1,Ans,last_Ans;
int in[MAXN],out[MAXN];
 
 
template<typename _t>
inline _t read(){
    _t x=0,f=1;
    char ch=getchar();
    for(;!isdigit(ch);ch=getchar())if(ch=='-')f=-f;
    for(;isdigit(ch);ch=getchar())x=x*10+(ch^48);
    return x*f;
}
 
int main(){
    n=read<int>();m=read<int>();
    for(int i=1;i<=m;i++){
        int u=read<int>(),v=read<int>(),W=read<int>();
        in[v]+=W;out[u]+=W;
    }
    int In=0,Out=0;
    for(int i=1;i<=n;i++)Ans += abs(in[i]-out[i]);
    printf("%d\n",Ans/2);
}

T2 Number

题目描述

一个排列，求出了 a 数组，其中 ai 表示第 i 个数左边有多少个数比它小

计算出原来的排列

输入

第一行输入 n 接下来 n - 1 个整数 ai，下标从 2 开始

输出

输出 n 个整数表示原排列

样例输入

5
1
2
1
0

样例输出

2
4
5
3
1

倒序枚举，在1~i的区间找未被选走的k小值即可。写棵平衡树就好。

这题被卡了operator new和普通delete之间关系。。去掉delete直接A，加上全部RE。

注：这么裸的题，以后还是不要重载new了。。

#include <stdio.h>
#include <cstring>
#include <iostream>
using namespace std;
#define MAXN 1000005
int n,a[MAXN],Ans[MAXN];
 
 
template<typename _t>
inline _t read(){
    _t x=0,f=1;
    char ch=getchar();
    for(;!isdigit(ch);ch=getchar())if(ch=='-')f=-f;
    for(;isdigit(ch);ch=getchar())x=x*10+(ch^48);
    return x*f;
}
 
struct node{
    node *ch[2];
    int v,s,r;
    void Maintain(){s=ch[0]->s+ch[1]->s+1;}
    node(){ch[0]=ch[1]=NULL;v=0;s=0;r=0;}
    node(int x);
    void *operator new(size_t);
}*null=new node(),*C,*mempool,*root;
typedef pair<node*,node*>pa;
 
void* node :: operator new(size_t){
    if(C==mempool){
        C=new node[1<<15];
        mempool=C+(1<<15);
    }
    return C++;
}
 
node :: node(int x){
    v=x;s=1;r=rand();
    ch[0]=ch[1]=null;
}
 
node* merge(node *a,node *b){
    if(a==null)return b;
    if(b==null)return a;
    if(a->r>b->r){
        a->ch[1]=merge(a->ch[1],b);
        a->Maintain();
        return a;
    }
    else{
        b->ch[0]=merge(a,b->ch[0]);
        b->Maintain();
        return b;
    }
}
 
pa split(node *o,int k){
    if(o==null)return make_pair(null,null);
    if(o->ch[0]->s>=k){
        pa y = split(o->ch[0],k);
        o->ch[0]=y.second;
        o->Maintain();
        y.second = o;
        return y;
    }
    else{
        pa y = split(o->ch[1],k-o->ch[0]->s-1);
        o->ch[1]=y.first;
        o->Maintain();
        y.first=o;
        return y;
    }
}
 
inline int kth(int k){
    pa x = split(root,k-1);
    pa y = split(x.second,1);
    int ans = y.first->v;
    root = merge(x.first,y.second);
    return ans;
}
 
void build(node *&o,int l,int r){
    if(l>r)return;
    int mid=l+r>>1;
    o=new node(mid);
    build(o->ch[0],l,mid-1);
    build(o->ch[1],mid+1,r);
    o->Maintain();
}
 
int main(){
    n=read<int>();
    for(int i=2;i<=n;i++)a[i]=read<int>();
    build(root,1,n);
    for(int i=n;i>=1;i--)Ans[i]=kth(a[i]+1);
    for(int i=1;i<=n;i++)printf("%d\n",Ans[i]);
}

T3：与非

题目描述

作为一名新世纪共产主义的接班人，你认识到了资本主义的软弱性与妥协性，决定全面根除资本主义，跑步迈入共产主义。但是当你即将跨入共产主义大门的时候，遇到了万恶的资本家留下的与非电路封印，经过千辛万苦的研究，你终于把复杂的破解转变成了以下问题：

初始时你有一个空序列，之后有N个操作。

操作分为一下两种：

1 x：在序列末尾插入一个元素x(x=0或1)。

2 L R：定义nand[L,R]为序列第L个元素到第R个元素的与非和，询问nand[L,L]^nand[L,L+1]^nand[L,L+2]^......^nand[L,R]。

Nand就是先与，再取反

输入

从文件nand.in中读入数据。

输入第一行一个正整数N，表示操作个数。

接下来N行表示N个操作。

为了体现程序的在线性，记lastans为上一次操作二的回答，初始lastans=0,。对于操作1，你需要对x异或lastans。对于操作二，设现在序列中的元素个数为M，如果lastans=1，那么你需要作如下操作：L=M-L+1,R=M-R+1,swap(L,R)

输出

输出到nand.out中。

输出有多行。为对于每一个操作二的回答。

样例输入

6
1 1
1 1
1 0
2 1 2
2 1 3
2 2 3

样例输出

1
0
0

对于nand[1,r]和nand[l,r]之间关系，把nand[1,r]展开，nand[1,r]=!(sum[1,l-1]&a[l])而原式nand[l,r]=a[l] nand a[l+1] nand a[l+2] .. nand a[r] 

那么如果!(sum[1,l-1]&a[l]) == a[l] 那么nand[1,r] == nand[l,r]，就可以用前缀和来处理了。那么找的时候只要判断当前可不可行，若不可行，暴力向后扫描+记录答案，直到扫到能到的点。

nand[l,l]=a[l]的规定也是bi了狗了。

被特殊的坑点卡掉++；

#include <stdio.h>
#include <cstring>
#include <iostream>
#define MAXN 4000005
using std::swap;
int f[MAXN],sum[MAXN],Ans,n,m,L,R,x,size,a[MAXN];
 
 
template<typename _t>
inline _t read(){
    _t x=0,f=1;
    char ch=getchar();
    for(;!isdigit(ch);ch=getchar())if(ch=='-')f=-f;
    for(;isdigit(ch);ch=getchar())x=x*10+(ch^48);
    return x*f;
}
 
inline int Query(int l,int r){
    int st = l,s=!(a[l]&a[l+1]),ans=a[l];
    while(s!=sum[st+1]&&st<r){
        ans ^= s;
        st++;
        s=!(s&a[st+1]);
    }
    if(st<r)ans ^= f[r]^f[st];
    return ans;
}
 
int main(){
    n=read<int>();int cnt = 0;
    while(n--){
        register int op = read<int>();
        if(op==1){
            x = read<int>()^Ans;
            a[++size]=x;
            if(size==1){
                sum[size]=x;
                f[size]=x;
            }
            else{
                sum[size]=!(sum[size-1]&x);
                f[size]=sum[size]^f[size-1];
            }
        }
        else{
            L = read<int>();R=read<int>();
            if(Ans){
                L=size-L+1;
                R=size-R+1;
                swap(L,R);
            }
            printf("%d\n",Ans=Query(L,R));
        }
    }
}