北京集训:20180326

爆零蒟蒻今天终于滚粗了......
也就是说，这是北京集训的最后一篇题解了。之后的比赛，我已经没有访问权限了。


T1:

考虑一个暴力做法:f[i][j]表示字符串区间[i,j]的最大等级。
如果k级字符串[i,j]包含一个k-1级字符串s，且s没有达到[i,j]的首(或者尾)的话，我们去掉[i,j]的首(或者尾)，剩下的仍然是一个k级字符串。
所以我们可以暴力dp，f[i][j]=max(f[i+1][j],f[i][j-1],max(f[substr])+1)。
而后面的那个可以用后缀自动机枚举出现两次及以上的子串，总复杂度O(n^3)。
显然这并不是正解(然而这对正解有很大的帮助)(要不然我也不会写他)。
考虑我们这样增量(减量?不!)去掉首尾字符的过程，我们一定能保证一个k级字符串的首尾都是一个k-1级字符串。
尾相同的子串有怎样的性质呢?他会出现在当前串的parent树的祖先上。
于是我们可以用f[i]表示后缀自动机第i个节点及其祖先节点中，最大的等级，g[i]表示取到这个等级，所在的最短的节点。
为什么这样做正确?因为对于结尾更靠后的串，我们不计算他的贡献也没有关系是吧，反正他能转移到的串的子串一定能由一个结尾更靠前的串转移到。
转移显然用最短的节点转移最优。我们暴力找头上的那个串出现的位置，看看是否可行即可。
这样我们get到了n^2暴力......
考虑我们现在复杂度的瓶颈在哪里?维护right集合和查询的过程。于是我们可以反向建立主席树并进行启发式合并，复杂度O(nlogn)。
(其实我感觉这东西时间和空间复杂度都是O(nlog^2n)的，只不过跑不满罢了)
代码:

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#define debug cerr
using namespace std;
const int maxn=4e5+1e2;

char in[maxn>>1];
int li,ans=1;

struct PersistentSegmentTree {
    static const int maxe = maxn * 25;
    int siz[maxe],lson[maxe],rson[maxe],cnt;
    
    inline void insert(int &pos,int l,int r,const int &tar) {
        if( !pos ) pos = ++cnt;
        siz[pos] = 1;
        if( l == r ) return;
        const int mid = ( l + r ) >> 1;
        if( tar <= mid ) return insert(lson[pos],l,mid,tar);
        else return insert(rson[pos],mid+1,r,tar);
    }
    inline int merge(int p1,int p2,int l,int r) {
        if( ! ( siz[p1] && siz[p2] ) ) return siz[p1] ? p1 : p2;
        int ret = ++cnt; siz[ret] = siz[p1] + siz[p2];
        if( l == r ) return ret;
        const int mid = ( l + r ) >> 1;
        lson[ret] = merge(lson[p1],lson[p2],l,mid);
        rson[ret] = merge(rson[p1],rson[p2],mid+1,r);
        return ret;
    }
    inline int query(int pos,int l,int r,const int &ll,const int &rr) {
        if( !pos ) return 0;
        if( ll <= l && r <= rr ) return siz[pos];
        const int mid = ( l + r ) >> 1;
        if( rr <= mid ) return query(lson[pos],l,mid,ll,rr);
        if( ll > mid ) return query(rson[pos],mid+1,r,ll,rr);
        return query(lson[pos],l,mid,ll,rr) + query(rson[pos],mid+1,r,ll,rr);
    }
}tree;

namespace SAM {
    int ch[maxn][26],fa[maxn],len[maxn],deg[maxn],last,root,cnt;
    int rit[maxn],pos[maxn],roots[maxn],bst[maxn],f[maxn];
    int seq[maxn],qlen;
    
    inline int NewNode(int li) {
        len[++cnt] = li;
        return cnt;
    }
    inline void extend(int x,int at) {
        int p = last;
        int np = NewNode(len[p]+1); rit[np] = pos[np] = at;
        while( p && !ch[p][x] ) ch[p][x] = np , p = fa[p];
        if( !p ) fa[np] = root;
        else {
            int q = ch[p][x];
            if( len[q] == len[p] + 1 ) fa[np] = q;
            else {
                int nq = NewNode(len[p]+1);
                memcpy(ch[nq],ch[q],sizeof(ch[q])) , fa[nq] = fa[q] , pos[nq] = pos[q];
                fa[np] = fa[q] = nq;
                while( p && ch[p][x] == q ) ch[p][x] = nq , p = fa[p];
            }
        }
        last = np;
    }
    inline void build() {
        last = root = NewNode(0);
        for(int i=1;i<=li;i++) extend(in[i]-'a',i);
    }
    inline void topo() {
        for(int i=1;i<=cnt;i++) if( fa[i] ) ++deg[fa[i]];
        queue<int> q;
        for(int i=1;i<=cnt;i++) if( !deg[i] ) q.push(i);
        while( q.size() ) {
            const int pos = q.front(); q.pop() , seq[++qlen] = pos;
            if( pos == root ) continue;
            if( rit[pos] ) {
                int t = 0;
                tree.insert(t,1,li,rit[pos]);
                roots[pos] = tree.merge(roots[pos],t,1,li);
            }
            roots[fa[pos]] = tree.merge(roots[fa[pos]],roots[pos],1,li);
            if( !--deg[fa[pos]] ) q.push(fa[pos]);
        }
        reverse(seq+1,seq+1+qlen);
    }
    inline void getans() {
        f[root] = 1 , bst[root] = root;
        for(int i=2;i<=qlen;i++) {
            const int now = seq[i] , milen = len[fa[now]] + 1;
            if( fa[now] == root ) {
                f[now] = 1 , bst[now] = now;
            } else {
                bst[now] = bst[fa[now]] , f[now] = f[bst[now]];
                const int ql = pos[now] - len[now] + len[bst[now]];
                const int qr = pos[now] - milen + len[bst[now]];
                if( tree.query(roots[bst[now]],1,li,ql,qr) ) f[now]++ , bst[now] = now;
            }
            ans = max( ans , f[now] );
        }
    }
}

int main() {
    scanf("%s",in+1) , li = strlen(in+1);
    SAM::build() , SAM::topo();
    SAM::getans();
    printf("%d
",ans);
    return 0;
}

T2:

显然不管是不是DAG，直接跑最小割都是WA的，不服见下图。
另外显然环上的边是一定不能割的，否则绕环一圈再走的路径上会有两条被割掉的边，我们可以先tarjan大力缩环变成DAG。
考虑如何防止一条路径上的边被割多次，我们能让这条路径上所有靠后的点向靠前的点连边容量inf，如果割掉后面的边且割掉前面的边相当于没割......
这建图点数O(n)，边数O(m^2)。
考虑怎么优化，由于inf具有传递性，所以我们让每个靠后的点单独向前面的点连边就行了，也就是，对于每一条边连接容量inf的反向边。
对于环的话，由于inf边的存在，我们显然不会割环上的边，于是连tarjan也省了。
然而这样是不行的，对于不在1~n路径上的边，不能连inf边，否则跑出的答案会比正确答案大(反例见上图)。
关于无解，直接判断最小割是否为inf就好了。
代码:

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
typedef long long int lli;
using namespace std;
const int maxn=1e3+1e2,maxe=2e3+1e2;
const lli inf=0x3f3f3f3f3f3f3f3fll;

namespace Flow {
    int s[maxn<<1],t[maxe<<2],nxt[maxe<<2],cnt=1;
    lli f[maxe<<2];
    int dep[maxn],st,ed;
    
    inline void coredge(int from,int to,lli flow) {
        t[++cnt] = to , f[cnt] = flow ,
        nxt[cnt] = s[from] , s[from] = cnt;
    }
    inline void singledge(int from,int to,lli flow) {
        coredge(from,to,flow) , coredge(to,from,0);
    }
    inline bool bfs() {
        memset(dep,-1,sizeof(dep)) , dep[st] = 0;
        queue<int> q; q.push(st);
        while( q.size() ) {
            const int pos = q.front(); q.pop();
            for(int at=s[pos];at;at=nxt[at])
                if( f[at] && !~dep[t[at]] )
                    dep[t[at]] = dep[pos] + 1 , q.push(t[at]);
        }
        return ~dep[ed];
    }
    inline lli dfs(int pos,lli flow) {
        if( pos == ed ) return flow;
        lli ret = 0 , now = 0;
        for(int at=s[pos];at;at=nxt[at])
            if( f[at] && dep[t[at]] > dep[pos] ) {
                now = dfs(t[at],min(flow,f[at]));
                ret += now , flow -= now ,
                f[at] -= now , f[at^1] += now;
                if( !flow ) return ret;
            }
        if( !ret ) dep[pos] = -1;
        return ret;
    }
    inline lli dinic() {
        lli ret = 0 , now = 0;
        while( bfs() ) {
            while( now = dfs(st,inf) ) {
                if( now == inf ) return -1; //No solution .
                ret += now;
            }
        }
        return ret;
    }
    inline void reset(int n) {
        memset(s,0,sizeof(s))  ,cnt = 1;
        st = 1 , ed = n;
    }
}

struct Graph {
    int s[maxn],t[maxe<<1],nxt[maxe<<1],vis[maxn],cnt;
    
    inline void addedge(int from,int to) {
        t[++cnt] = to , nxt[cnt] = s[from] , s[from] = cnt;
    }
    inline void dfs(int pos) {
        if( vis[pos] ) return;
        vis[pos] = 1;
        for(int at=s[pos];at;at=nxt[at]) dfs(t[at]);
    }
    inline void reset() {
        memset(s,0,sizeof(s)) , memset(vis,0,sizeof(vis)) , cnt = 0;
    }
}gra,inv;

int x[maxe],y[maxe],f[maxe];

inline void build(int m) {
    for(int i=1;i<=m;i++) {
        Flow::singledge(x[i],y[i],f[i]);
        if( gra.vis[x[i]] && inv.vis[y[i]] ) Flow::singledge(y[i],x[i],inf);
    }
}

inline void reset(int n) {
    Flow::reset(n);
    gra.reset() , inv.reset();
}

int main() {
    static int T,n,m;
    scanf("%d",&T);
    while(T--) {
        scanf("%d%d",&n,&m) , reset(n);
        for(int i=1;i<=m;i++) {
            scanf("%d%d%d",x+i,y+i,f+i);
            gra.addedge(x[i],y[i]) , inv.addedge(y[i],x[i]);
        }
        gra.dfs(1) , inv.dfs(n);
        build(m);
        printf("%lld
",Flow::dinic());
    }
    return 0;
}

T3:

直接放官方题解吧......

代码:

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define debug cout
using namespace std;
const int maxn=1e6+1e2;

int s[maxn],t[maxn<<1],nxt[maxn<<1],fa[maxn],w[maxn],sons[maxn];
int n,a,b;

inline  void coredge(int from,int to) {
    static int cnt = 0;
    t[++cnt] = to , nxt[cnt] = s[from] , s[from] = cnt;
}
inline void doubledge(int a,int b) {
    coredge(a,b) , coredge(b,a);
}
inline void update(int &mx,int &sec,const int &now) {
    if( now >= mx ) sec = mx , mx = now;
    else if( now > sec ) sec = now;
}
inline void dfs(int pos) {
    int mx = 0 , sec = 0;
    for(int at=s[pos];at;at=nxt[at])
        if( t[at] != fa[pos] ) {
            fa[t[at]] = pos , ++sons[pos];
            dfs(t[at]) , update(mx,sec,w[t[at]]);
        }
    w[pos] = sec + sons[pos];
}
inline bool check(int lim) {
    int fs = 0 , tim = 0 , ret = 0 , now = a , last = -1;
    for(int i=a;i!=b;i=fa[i]) fs += sons[i] - ( i != a );
    while( now != b ) {
        ++tim;
        int sum = 0;
        for(int at=s[now];at;at=nxt[at])
            if( t[at] != fa[now] && t[at] != last) {
                if( w[t[at]] + ret + fs > lim ) ++sum , --tim;
                if( tim < 0 ) return 0; // No enough time .
            }
        ret += sum , fs -= sons[now] - ( now != a );
        last = now , now = fa[now];
        if( ret > lim ) return 0;
    }
    return ret <= lim;
}
inline int bin() {
    int ll = -1 , rr = n << 1 , mid;
    while( rr > ll + 1 ) {
        mid = ( ll + rr ) >> 1;
        if( check(mid) ) rr = mid;
        else ll = mid;
    }
    return rr;
}

int main() {
    scanf("%d%d%d",&n,&b,&a);
    for(int i=1,a,b;i<n;i++) {
        scanf("%d%d",&a,&b) , doubledge(a,b);
    }
    dfs(b);
    printf("%d
",bin());
    return 0;
}

再有十几天就省选了，我这么弱，九成是要退役了吧。
大概无论如何也不会坚持了吧。“你学下去”，想像BE里的红一样用生命挽救别人，然而还有谁值得我这样做呢？
直到现在才发现，看起来很正常的我，其实是黑的......