20180222小测

今天又是猝不及防的一场考试。

我赶紧去打卡，于是get:参加模拟赛，爆零。

T1:

这不是秦神上次的原题吗?赶紧粘一发代码走了(不)。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
#define debug cout
using namespace std;
const int maxn=2e2+1e1,maxm=4e4+1e2,maxe=55;
const int inf=0x3f3f3f3f;

int k[maxn],sum[maxn],n,full,mip,ans;
int st,ed,len;
bool vis[maxn];

struct Elevator {
    int h,x,y;
    friend bool operator < (const Elevator &a,const Elevator &b) {
        if( a.h != b.h ) return a.h < b.h;
        if( a.x != b.x ) return a.x < b.x;
        return a.y < b.y;
    }
    friend bool operator == (const Elevator &a,const Elevator &b) {
        return a.h == b.h && a.x == b.x && a.y == b.y;
    }
};
vector<Elevator> v;

namespace Flow {
    int s[maxn],t[maxm<<1],nxt[maxm<<1],f[maxm<<1],dep[maxn],cnt=1;
    
    inline void coredge(int from,int to,int flow) {
        t[++cnt] = to , f[cnt] = flow ,
        nxt[cnt] = s[from] , s[from] = cnt;
    }
    inline void singledge(int from,int to,int 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 int dfs(int pos,int flow) {
        if( pos == ed ) return flow;
        int 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 int dinic() {
        int ret = 0 , now = 0;
        while( bfs() )
            while( ( now = dfs(st,inf) ) ) ret += now;
        return ret;
    }
    inline void reset() {
        memset(s,0,sizeof(s)) , cnt = 1;
    }
}

inline int countbit(int x) {
    #define lowbit(x) (x&-x)
    int ret = 0;
    while( x ) ++ret , x -= lowbit(x);
    return ret;
}
inline int covdep(int dep,int pos) {
    return sum[dep-1] + pos;
}

inline int rebuild(int sta) {
    Flow::reset() , memset(vis,0,sizeof(vis));
    int ret = 0;
    for(int i=0;i<k[mip];i++) if( ! ( sta & ( 1 << i ) ) ) vis[covdep(mip,i+1)] = 1;
    for(int i=0;i<len;i++) {
        const int h = v[i].h , th = h != n ? h + 1 : 1;
        if( h == mip) {
            if( ( 1 << ( v[i].x - 1 ) ) & sta ) vis[covdep(th,v[i].y)] = 1;
        }
        else if( th == mip ) {
            if( ( 1 << ( v[i].y - 1 ) ) & sta ) vis[covdep(h,v[i].x)] = 1;
        }else {
            if( ( h > mip && ( ( h - mip ) & 1 ) ) || ( h < mip && ! ( ( mip - h ) & 1 ) ) )
                Flow::singledge(covdep(h,v[i].x),covdep(th,v[i].y),1);
            else Flow::singledge(covdep(th,v[i].y),covdep(h,v[i].x),1);
        }
    }
    for(int i=1;i<=n;i++) {
        if( ( i > mip && ( ( i - mip ) & 1 ) ) || ( i < mip && !( ( mip - i ) & 1 ) ) ) {
            for(int j=1;j<=k[i];j++)
                if( !vis[covdep(i,j)] ) Flow::singledge(st,covdep(i,j),1);
        } else if( i != mip ) {
            for(int j=1;j<=k[i];j++)
                if( !vis[covdep(i,j)] ) Flow::singledge(covdep(i,j),ed,1);
        }
    }
    for(int i=1;i<=full;i++) ret += !vis[i];
    ret -= Flow::dinic();
    return ret;
}
inline void getansodd() {
    int fs = ( 1 << k[mip] );
    for(int i=0;i<fs;i++) ans = max( ans , rebuild(i) );
}
inline void getanseven() {
    for(int i=0;i<len;i++) {
        const int x = covdep(v[i].h,v[i].x);
        const int y = covdep(v[i].h!=n?v[i].h+1:1,v[i].y);
        if( v[i].h & 1 ) Flow::singledge(x,y,1);
        else Flow::singledge(y,x,1);
    }
    for(int i=1;i<=n;i++) {
        if( i & 1 ) {
            for(int j=1;j<=k[i];j++)
                Flow::singledge( st , covdep(i,j) , 1 );
        } else {
            for(int j=1;j<=k[i];j++)
                Flow::singledge( covdep(i,j) , ed , 1 );
        }
    }
    ans = full - Flow::dinic();
}

inline void pre() {
    sort(v.begin(),v.end());
    len = unique(v.begin(),v.end()) - v.begin();
    for(int i=1;i<=n;i++) sum[i] = sum[i-1] + k[i];
    full = sum[n] , st = full + 1 , ed = full + 2;
    *k = inf;
    for(int i=1;i<=n;i++) if( k[i] < k[mip] ) mip = i;
}

int main() {
    static int h,x,y;
    scanf("%d",&n);
    int t = 0;
    while( scanf("%d%d%d",&x,&y,&h) == 3 ) {
        v.push_back((Elevator){h,x,y});
        k[h] = max( k[h] , x ) , k[h!=n?h+1:1] = max( k[h!=n?h+1:1] , y );
        ++t;
    }
    pre();
    if( n & 1 ) getansodd();
    else getanseven();
    printf("%d
",ans);
    return 0;
}

T2:

让你找一个长度为n的简单环或链并输出方案。

首先先考虑环是否存在的问题，随便乱搞一下看有没有长为n的简单路径就行了，等等，这东西能搞?30分钟过去了。

有没有环?tarjan一发看看所有点是否在一个强连通里不就行了……

输出方案，这东西怎么办?

手玩了多种方案发现无解后，我开始考虑弃疗。

这不是哈密顿回路吗?这不NP吗?woc这玩意能做?

n<=10的15分枚举全排列就好，n<=30的15分大概给什么随机化了吧(写了也不一定有分，不写了QAQ)。

n<=200，最短路乱搞骗分得了。

等会，这是二分图?然而二分图有一堆小环怎么办啊，弃了弃了。

--------我是废话的分割线--------

其实这种图是一张竞赛图，我们能够通过归纳法证明这张图中一定存在哈密顿通路。

怎么证?考虑2个点的初始情况一定可行，那么我们要用归纳法证明在n个点可行的情况下n+1个点也可行。

如果新加进来的点只有出边或只有入边，那么我们把他放到尾就好了。

考虑序列中的每一个位置，如果新加的点有顺序边(原来序列a->b新加点x，我们有a->x,x->b的边)，我们直接把新加点x加入就行。

否则，则新加点有且仅有逆序边，由于逆序边这种东西不可连续，则新加点x一定向序列前一段的点连出边，被序列后一段的点连入边(脑补一下)，这样我们就可以把x放在头或者尾了。

所以我们证明了，n>=2的竞赛图一定有哈密顿通路。

关于环(哈密顿回路)的问题，Dirac定理告诉我们顶点的度数大于等于N/2,则哈密顿回路一定存在，同时鸽巢原理告诉我们如果一张竞赛图所有点在同一个强连通分量中，则一定存在哈密顿回路(别问我怎么证明)，然后就是构造的问题。

构造的话，我们可以枚举初始点，然后加点，构造出没有重复点的最长链。最后是不是环就听天由命吧。(某神奇定理告诉我们只要枚举所有初始点则能构造出环)。

看成绩时发现，直接无脑匈牙利输出方案有55分，dinic输出方案能A(天知道这数据怎么回事)。

考场25分代码:

#include<cstdio>
#include<cstring>
#include<algorithm>
#define debug cout
#include<iostream>
using namespace std;
const int maxn=4e2+1e1;
const int inf=0x3f3f3f3f;

int in[maxn][maxn];
int n;

namespace Force {
    int pts[maxn],ans[maxn],sta=-1;
    inline int judge() { // return 0 if it is a ring , 1 if it is a chain .
        for(int i=1;i<n;i++)
            if( !in[pts[i]][pts[i+1]] ) return -1;
        return 1 - in[pts[n]][pts[1]];
    }
    inline void work() {
        for(int i=1;i<=n;i++) pts[i] = i;
        do {
            int t = judge();
            if( t == 0 ) {
                sta = 0 , memcpy(ans+1,pts+1,sizeof(int)*n);
                break;
            } else if( t == 1 && !~sta ) {
                sta = 1 , memcpy(ans+1,pts+1,sizeof(int)*n);
            }
        } while( std::next_permutation(pts+1,pts+1+n) );
        printf("%d
",sta);
        if( ~sta ) for(int i=1;i<=n;i++) printf("%d%c",ans[i],i!=n?' ':'
');
    }
}
namespace Exp {
    int dis[maxn][maxn];
    int ans[maxn],cnt,sta=-1,sx,sy;
    inline void gen() {
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++) {
                dis[i][j] = -inf;
                if( in[i][j] ) dis[i][j] = 1;
            }
    }
    inline void floyd() {
        for(int k=1;k<=n;k++)
            for(int i=1;i<=n;i++)
                for(int j=1;j<=n;j++) {
                    if( i == k || j == k ) continue;
                    if( dis[i][j] < dis[i][k] + dis[k][j] ) {
                        dis[i][j] = dis[i][k] + dis[k][j];
                    }
                }
    }
    inline void getans() {
        for(int i=1;i<=n;i++)
            if( dis[i][i] == n ) {
                sta = 0 , sx = i;
                return;
            }
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
                if( dis[i][j] == n - 1 ) {
                    sta = 1 , sx = i;
                    return;
                }
    }
    int t = 0;
    inline void work() {
        gen() , floyd() , getans();
        if( ~sta ) {
            for(int i=1;i<=n;i++) ans[dis[sx][i]%n] = i;
            printf("%d
",sta);
            for(int i=0;i<n;i++) printf("%d ",ans[i]);
        }
    }
}

int main() {
    scanf("%d",&n);
    for(int i=1;i<=n;i++) for(int j=1;j<=n;j++) scanf("%d",&in[i][j]);
    if( n <= 15 ) Force::work();
    else Exp::work();
    fclose(stdout);
    return 0;
}

考后AC代码:

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

int in[maxn][maxn],ans[maxn];
int n,tpe;

namespace Tarjan {
    int dfn[maxn],low[maxn],id[maxn],stk[maxn],vis[maxn],ins[maxn],top,dd,iid;
    inline void dfs(int pos) {
        vis[pos] = 1;
        low[pos] = dfn[pos] = ++dd ,
        stk[++top] = pos , ins[pos] = 1;
        for(int i=1;i<=n;i++)
            if( in[pos][i] && !vis[i] ) {
                dfs(i);
                low[pos] = min( low[pos] , low[i] );
            } else if( ins[i] ) low[pos] = min( low[pos] , dfn[i] );
        if( low[pos] == dfn[pos] ) {
            ++iid;
            do {
                const int x = stk[top--]; ins[x] = 0;
                id[x] = iid;
            } while( ins[pos] );
        }
    }
    inline bool work() {
        for(int i=1;i<=n;i++) if( !vis[i] ) dfs(i);
        for(int i=1;i<=n;i++) if( id[i] != id[1] ) return 0;
        return 1;
    }
}
namespace Build {
    int nxt[maxn],used[maxn],head,tail;
    inline void init(int hh) {
        memset(nxt,0,sizeof(nxt));
        head = tail = hh;
    }
    inline int build(int hh) {
        init(hh);
        for(int i=1;i<=n;i++)
            if( i != hh ) {
                if( in[i][head] ) nxt[i] = head , head = i;
                else {
                    int now;
                    for(now=head;nxt[now]&&in[nxt[now]][i];now=nxt[now]);
                    nxt[i] = nxt[now] , nxt[now] = i;
                    if( !nxt[i] ) tail = i;
                }
            }
        return in[tail][head];
    }
    inline void getans(int tpe) {
        if( tpe ) build(1);
        else for(int i=1;i<=n;i++) if( build(i) ) break;
        for(int i=head,now=0;i;i=nxt[i]) ans[++now] = i;
    }
    
}

int main() {
    scanf("%d",&n);
    for(int i=1;i<=n;i++) for(int j=1;j<=n;j++) scanf("%d",in[i]+j);
    int tpe = Tarjan::work() ^ 1;
    Build::getans(tpe);
    printf("%d
",tpe);
    for(int i=1;i<=n;i++) printf("%d%c",ans[i],i!=n?' ':'
');
    return 0;
}

T3:

全世界都知道这题是费用流(不)，为什么只有我在想怎么dp?

考场写了30分爆搜，结果没开long long 10分滚粗啦！(你不告诉我数据范围怪我喽)

首先我们先钦定小A全程睡觉，我们设0/1变量xi为第i天睡觉是否改成吃饭。

然后我们就是要在符合要求的情况下让修改的代价尽可能小，也就是说最小费用最大流了。

关于要求，我们有:

我们全部加入变量y，补成等式:

关于y的范围:前n-k个为[0,n-ms-me]，后

上下作差:

如果我们把每个方程看做点，x,y的加减看做边，x,y的范围看做流量，x,y改动的价值看做边权，这不就是费用流了呢？

关于数值细节自己推吧。

考场10分代码:

#include<cstdio>
#include<algorithm>
const int maxn=1e2+1e1;

int in[maxn][2],sta[maxn];
int n,k,ms,me,ans;

inline void judge() {
    int ss = 0 , se = 0 , sum = 0;
    for(int i=1;i<k;i++) ss += sta[i] == 1 , se += sta[i] == 2 , sum += in[i][sta[i]-1];
    for(int i=k;i<=n;i++) {
        ss += sta[i] == 1 , se += sta[i] == 2 , sum += in[i][sta[i]-1];
        ss -= sta[i-k] == 1 , se -= sta[i-k] == 2;
        if( ss < ms || se < me ) return;
    }
    ans = std::max(ans,sum);
}
inline void dfs(int pos) {
    if( pos > n ) return judge();
    sta[pos] = 1 , dfs(pos+1) ,
    sta[pos] = 2 , dfs(pos+1) ;
}

int main() {
    scanf("%d%d%d%d",&n,&k,&ms,&me) , ans = -0x7fffffff;
    for(int i=1;i<=n;i++) scanf("%d",in[i]);
    for(int i=1;i<=n;i++) scanf("%d",in[i]+1);
    dfs(1);
    printf("%d
",ans);
    fclose(stdout);
    return 0;
}

考后AC代码:

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#define lli long long int
#define debug cout
using namespace std;
const int maxn=1e3+1e2,maxe=maxn<<4;
const int int_inf=0x3f3f3f3f;
const lli lli_inf=0x3f3f3f3f3f3f3f3fll;

lli ins[maxn],ine[maxn];
int s[maxn],t[maxe],nxt[maxe],f[maxe],sou[maxn];
lli c[maxe],dis[maxn];
bool inq[maxn];
int n,k,ms,me,st,ed,lim;

inline void coredge(int from,int to,int flow,lli cost) {
    static int cnt = 1;
    t[++cnt] = to , f[cnt] = flow , c[cnt] = cost ,
    nxt[cnt] = s[from] , s[from] = cnt;
}
inline void singledge(int from,int to,int flow,lli cost) {
    coredge(from,to,flow,cost) , coredge(to,from,0,-cost);
}
inline bool spfa() {
    memset(dis,0x3f,sizeof(dis)) , dis[st] = 0;
    queue<int> q; q.push(st) , inq[st] = 1;
    while( q.size() ) {
        const int pos = q.front(); q.pop() , inq[pos] = 0;
        for(int at=s[pos];at;at=nxt[at])
            if( f[at] && dis[t[at]] > dis[pos] + c[at] ) {
                dis[t[at]] = dis[pos] + c[at] , sou[t[at]] = at;
                if( !inq[t[at]] ) q.push(t[at]) , inq[t[at]] = 1;
            }
    }
    return dis[ed] != lli_inf;
}
inline int release() {
    int ret = int_inf;
    for(int i=ed;i!=st;i=t[sou[i]^1])
        ret = min( ret , f[sou[i]] );
    for(int i=ed;i!=st;i=t[sou[i]^1])
        f[sou[i]] -= ret , f[sou[i]^1] += ret;
    return ret;
}
inline lli flow() {
    lli ret = 0;
    while( spfa() ) ret += dis[ed] * release();
    return ret;
}

int main() {
    static lli ans;
    scanf("%d%d%d%d",&n,&k,&ms,&me) , st = n + 1 , ed = n + 2;
    for(int i=1;i<=n;i++) scanf("%lld",ins+i) ; // ine :: value we lost in chageing e into s .
    for(int i=1;i<=n;i++) scanf("%lld",ine+i) , ans += ine[i] , ine[i] -= ins[i]; 
    lim = k - ms - me ;
    
    singledge(st,1,lim,0) , singledge(n,ed,k-me,0);
    for(int i=1;i<n;i++) singledge(i,i+1,i>=n-k+1?k-me:lim,0);
    for(int i=1;i<=k;i++) singledge(st,i,1,ine[i]);
    for(int i=1;i+k<=n;i++) singledge(i,i+k,1,ine[i+k]);
    
    /*singledge(st,1,k-me,0) , singledge(n,ed,lim,0);
    for(int i=1;i<n;i++) singledge(i,i+1,i<k?k-me:lim,0);
    for(int i=1;i+k<=n;i++) singledge(i,i+k,1,ine[i]);
    for(int i=n-k+1;i<=n;i++) singledge(i,ed,1,ine[i]);*/
    
    ans -= flow();
    printf("%lld
",ans);
    
    return 0;
}