20180418小测

T1:

看到这种东西就想二维数点。
如果圆弧i和圆弧j能贡献答案的话(假设i在左边)，需要满足 Li<Lj && Ri<Rj && Lj<Ri && Coli!=Colj 。
我们先不管最后颜色的那个限制，如果我们确定了i之后，能有贡献的j需要满足: Li<Lj && Lj<Ri && Rj>Ri .
这样我们按照左端点建立主席树，把右端点插进去，就能统计了。
然后再按照颜色分类，计算颜色相同的贡献减去，就能得到答案。
复杂度O(sigma(Si^2)logn)，能获得70分。
正解大概是均衡不同复杂度算法之类的东西，然而并不能想到不同复杂度的算法(然后题解真是这样的)。
70分暴力代码:

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#include<map>
#include<cctype>
#define debug cout
using namespace std;
const int maxn=1e5+1e2,maxe=2e7+1e2;
const int mod=1e9+7;

struct PersistentSegmentTree {
    int lson[maxe],rson[maxe],dat[maxe],cnt;
    inline void insert(int &pos,int pre,int l,int r,const int &tar) {
        dat[pos=++cnt] = dat[pre] + 1;
        if( l == r ) return;
        const int mid = ( l + r ) >> 1;
        if( tar <= mid ) insert(lson[pos],lson[pre],l,mid,tar) , rson[pos] = rson[pre];
        else insert(rson[pos],rson[pre],mid+1,r,tar) , lson[pos] = lson[pre];
    }
    inline int query(int pos,int pre,int l,int r,const int &ll,const int &rr) {
        if( !pos || dat[pos] == dat[pre] ) return 0;
        if( ll <= l && r <= rr ) return dat[pos] - dat[pre];
        const int mid = ( l + r ) >> 1;
        if( rr <= mid ) return query(lson[pos],lson[pre],l,mid,ll,rr);
        else if( ll > mid ) return query(rson[pos],rson[pre],mid+1,r,ll,rr);
        return query(lson[pos],lson[pre],l,mid,ll,rr) + query(rson[pos],rson[pre],mid+1,r,ll,rr);
    }
    inline void reset() {
        memset(dat+1,0,sizeof(int)*cnt) , memset(lson+1,0,sizeof(int)*cnt) , memset(rson+1,0,sizeof(int)*cnt) , cnt = 0;
    }
}pst;

int in[maxn],root[maxn],n,cnt,ans,sub;
vector<int> pos[maxn];
map<int,int> id;

inline int getint() {
    int ret = 0 , fix = 1 , ch;
    while( !isdigit(ch=getchar()) ) fix = ch == '-' ? -fix : fix;
    do ret=ret*10+ch-'0'; while( isdigit(ch=getchar()) );
    return ret * fix;
}

int main() {
    n = getint();
    for(int i=1;i<=n;i++) {
        in[i] = getint();
        if( id.find(in[i]) == id.end() ) id[in[i]] = ++cnt;
        pos[id[in[i]]].push_back(i);
    }
    for(int i=n,iid;i;i--) {
        root[i] = root[i+1] , iid = id[in[i]];
        for(unsigned j=0;j<pos[iid].size();j++) if( pos[iid][j] > i ) {
            pst.insert(root[i],root[i],1,n,pos[iid][j]);
            ans += pst.query(root[i+1],root[pos[iid][j]],1,n,pos[iid][j]+1,n);
        }
        ans %= mod;
    }
    for(int i=1;i<=cnt;i++) {
        pst.reset() , memset(root,0,sizeof(int)*(pos[i].size()+2));
        for(int j=(signed)pos[i].size()-1;j>=0;j--) { // j is left point of now .
            root[j] = root[j+1];
            for(unsigned k=j+1;k<pos[i].size();k++) { // k is right point of now .
                pst.insert(root[j],root[j],1,n,pos[i][k]);
                sub += pst.query(root[j+1],root[k],1,n,pos[i][k]+1,n);
            }
            sub %= mod;
        }
    }
    ans = ( ans - sub + mod ) % mod;
    printf("%d
",ans);
    return 0;
}

T2:

全场就我不会做这题，高一学弟都会做......
我考虑枚举中间点，然后计算两遍有长度限制的大于/小于点数，发现并不可做，然后就O(n^2)暴力滚粗了。
正解是枚举右端点，计算中间点和左端点的贡献。
显然先要断环成链，我们用一颗权值线段树维护权值为i的点，左边比他小的点的个数fi。然后从左向右(n->2*n-1)枚举当前右端点，需要记录答案的就是sum(f1->f(in[i]-1))。
考虑怎么预处理出前n个点的区间的这个值，直接线段树求顺序对即可。
考虑怎么从区间[i,i+n-1]转移到区间[i+1,i+n]。显然对于权值>in[i]的所有点，其左边的点少了一个，应该区间-1。
考虑新加入的in[i+n]，所有的点都在他的左边，所以他的权值应该为in[i+n]-1。并且更新前权值为0(因为左边没有其他点)。
然后就是老年选手身败名裂的故事了。
60分暴力代码:

#include<cstdio>
typedef long long int lli;
const int maxn=5e3+1e2;

int in[maxn<<1],n;
lli f[maxn][maxn],ans;

int main() {
    scanf("%d",&n);
    for(int i=1;i<=n;i++) scanf("%d",in+i) , in[i+n] = in[i];
    for(int i=1;i<=n;i++) for(int j=1;j<n;j++) f[i][j] = f[i][j-1] + ( in[i+j] > in[i] );
    for(int i=1;i<=n;i++) for(int j=i+1;j<i+n;j++) if( in[j] > in[i] ) ans += f[j>n?j-n:j][n-(j-i+1)];
    printf("%lld
",ans);
    return 0;
}

正解代码:

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define debug cout
typedef long long int lli;
using namespace std;
const int maxn=2e5+1e2;

class SegmentTree {
    private:
    int l[maxn<<3],r[maxn<<3],lson[maxn<<3],rson[maxn<<3],cnt;
    lli dat[maxn<<3],lazy[maxn<<3];
    public:
    SegmentTree() { cnt = 1; }
    inline void build(int pos,int ll,int rr) {
        l[pos] = ll , r[pos] = rr;
        if( ll == rr ) return;
        const int mid = ( ll + rr ) >> 1;
        build(lson[pos]=++cnt,ll,mid) , build(rson[pos]=++cnt,mid+1,rr);
    }
    inline void apply(int pos,lli x) {
        dat[pos] += ( r[pos] - l[pos] + 1 ) * x , lazy[pos] += x;
    }
    inline void push(int pos) {
        apply(lson[pos],lazy[pos]) , apply(rson[pos],lazy[pos]) , lazy[pos] = 0;
    }
    inline void update(int pos,const int &ll,const int &rr,const lli &x) {
        if( rr < l[pos] || r[pos] < ll ) return;
        if( ll <= l[pos] && r[pos] <= rr ) return apply(pos,x);
        push(pos) , update(lson[pos],ll,rr,x) , update(rson[pos],ll,rr,x) , dat[pos] = dat[lson[pos]] + dat[rson[pos]];
    }
    inline lli query(int pos,const int &ll,const int &rr) {
        if( rr < l[pos] || r[pos] < ll ) return 0;
        if( ll <= l[pos] && r[pos] <= rr ) return dat[pos];
        return push(pos) , query(lson[pos],ll,rr) + query(rson[pos],ll,rr);
    }
}pre,sgt;

int in[maxn<<1],n;
lli ans;

int main() {
    scanf("%d",&n) , pre.build(1,1,n) , sgt.build(1,1,n);
    for(int i=1;i<=n;i++) scanf("%d",in+i) , in[i+n] = in[i] , pre.update(1,in[i]+1,n,1) , sgt.update(1,in[i],in[i],pre.query(1,in[i],in[i]));
    for(int i=n,lst=1;i<n<<1;i++,lst++) ans += sgt.query(1,1,in[i]-1) , sgt.update(1,in[lst]+1,n,-1) , sgt.update(1,in[lst],in[lst],in[lst]-1);
    printf("%lld
",ans);
    return 0;
}

T3:

这不是BZOJ4774吗?斯坦纳树板子题。
写写写，和原来的代码对拍，发现要跑5s？
赶紧大力卡常，卡到3s，没办法了不管了(不知道评测机具体体位架构所以不敢target("avx"))。
然后发现这题竟然A了(震惊!1.5s竟然能让斯坦纳树AC)
然后又发现zhy的乱搞算法也A了(他枚举点对顺序然后贪心最短路，显然不对)，这数据是有多水？
辣鸡出题人不会造数据费我时间掉我排名！
代码:

#pragma GCC optimize("Ofast,no-stack-protector")
//#pragma GCC target("avx")
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#include<cctype>
#define bool unsigned char
const unsigned maxn=1e4+1e2+3,maxs=(1<<9)+5,maxq=11;
const unsigned inf=0x3f3f3f3f;
// I know it's impossible for me to AC this problem in 1.5s, but I have to try.

unsigned s[maxn],t[maxn<<1],nxt[maxn<<1],l[maxn<<1];
unsigned f[maxs][maxn],g[maxs],pts[maxq];
unsigned n,m,d,full;

__inline void addedge(unsigned from,unsigned to,unsigned len) {
    static unsigned cnt = 0;
    t[++cnt] = to , l[cnt] = len ,
    nxt[cnt] = s[from] , s[from] = cnt;
}
__inline void spfa(unsigned* dis) {
    static bool inq[maxn];
    static std::queue<unsigned> q;
    for(unsigned i=1;i<=n;i++) if( dis[i] != inf ) q.push(i) , inq[i] = 1;
    while( q.size() ) {
        const unsigned pos = q.front(); q.pop() , inq[pos] = 0;
        for(register unsigned at=s[pos];at;at=nxt[at])
            if( dis[t[at]] > dis[pos] + l[at] ) {
                dis[t[at]] = dis[pos] + l[at];
                if( !inq[t[at]] ) q.push(t[at]) , inq[t[at]] = 1;
            }
    }
}
__inline void getf() {
    memset(f,0x3f,sizeof(f));
    for(register unsigned i=0;i<(d<<1);i++) f[1<<i][pts[i]] = 0;
    for(register unsigned sta=0;sta<full;sta++) {
        for(register unsigned ss=sta;ss;ss=(ss-1)&sta)
            for(register unsigned i=1;i<=n;i++)
                f[sta][i] = std::min( f[sta][i] , f[ss][i] + f[sta^ss][i] );
        spfa(f[sta]);
    }
}
__inline bool legal(unsigned sta) {
    for(register unsigned i=0;i<=(d<<1);i++)
        if( ( ( sta >> i ) & 1 ) != ( sta >> ( ( d << 1 ) - i - 1 ) & 1 ) ) return 0;
    return 1;
}
__inline void getg() {
    memset(g,0x3f,sizeof(g));
    for(register unsigned sta=0;sta<full;sta++) if( legal(sta) ) for(register unsigned i=1;i<=n;i++) g[sta] = std::min( g[sta] , f[sta][i] );
    for(register unsigned sta=0;sta<full;sta++) for(register unsigned ss=sta;ss;ss=(ss-1)&sta) g[sta] = std::min( g[sta] , g[ss] + g[sta^ss] );
}

__inline unsigned char nextchar() {
    static const unsigned BS = 1 << 22;
    static unsigned char buf[BS],*st=buf+BS,*ed=buf+BS;
    if( st == ed ) ed = buf + fread(st=buf,1,BS,stdin);
    return st == ed ? -1 : *st++;
}
__inline unsigned getint() {
    register unsigned ret = 0 , ch;
    while( !isdigit(ch=nextchar()) );
    do ret=ret*10+ch-'0'; while( isdigit(ch=nextchar()) );
    return ret;
}

int main() {
    n = getint() , m = getint() , full = 1 << ( ( d = getint() ) << 1 );
    for(register unsigned i=1,a,b,l;i<=m;i++) a = getint() , b = getint() , l = getint() , addedge(a,b,l) , addedge(b,a,l);
    for(register unsigned i=0;i<d;i++) pts[i] = i + 1 , pts[(d<<1)-i-1] = n - i;
    getf() , getg();
    if( g[full-1] == inf ) puts("-1");
    else printf("%u
",g[full-1]);
    return 0;
}

 
话说我似乎是这个机房中历届存在过的常数最大的人了。
虽然我知道怎么优化，然而我懒......
于是就有了自带大常数的属性。
话说这不是萌点吗，怎么就变成槽点了(雾)。
我怎么知道......