BestCoder Round #74

身败名裂啊。。。。。。

T1WA了半天，30min才A。

T2又WA了一发，然后Hack刚2min就被别人叉了。

T3做完后最后40min不知所措。

去叉别人，看到一个人写D题判m=0很奇怪，随手把他叉了：

1

3 0

然后发现，标程输出1.

奥妙重重

嘿嘿嘿，我竟然又去叉了吉利。

T1的SB错误是，答案可能是|x-y|。

T2的SB错误是，一个[1,10^5]的数异或[1,10^5]的数可能是[1,131072]的数。

T1 Shortest Path

x到y的路径可能有几种：
1.x->y

2.x->i->j>y

其中i和j是新边里的节点（称为关键节点）

将六个关键点连起来跑一下Floyd，然后每次询问时枚举一下i，j。

#include<cstdio>
#include<cstring>
#include<cctype>
#include<map>
#include<algorithm>
#define rep(i,s,t) for(int i=s;i<=t;i++)
#define dwn(i,s,t) for(int i=s;i>=t;i--)
using namespace std;
inline int read() {
    int x=,f=;char c=getchar();
    for(;!isdigit(c);c=getchar()) if(c=='-') f=-;
    for(;isdigit(c);c=getchar()) x=x*+c-'';
    return x*f;
}
const int maxn=;
int n,m,u[],v[],A[],cnt;
int W[][];
map<int,int> M;
int find(int x) {
    if(!M.count(x)) M[x]=++cnt,A[cnt]=x;
    return M[x];
}
const int mod=;
int main() {
    dwn(T,read(),) {
        n=read();m=read();M.clear();cnt=;
        rep(i,,) rep(j,,) W[i][j]=;
        rep(i,,) W[i][i]=;
        rep(i,,) u[i]=read(),v[i]=read(),W[find(u[i])][find(v[i])]=W[find(v[i])][find(u[i])]=;
        rep(i,,cnt) rep(j,,cnt) W[i][j]=min(W[i][j],abs(A[i]-A[j]));
        rep(k,,cnt) rep(i,,cnt) rep(j,,cnt) W[i][j]=min(W[i][j],W[i][k]+W[k][j]);
        long long res=;
        rep(i,,m) {
            int x=read(),y=read(),ans=abs(x-y);
            rep(k,,cnt) rep(j,,cnt) ans=min(ans,abs(A[k]-x)+abs(A[j]-y)+W[k][j]);
            (res+=(long long)i*ans)%=mod;
        }
        printf("%I64d\n",res);
    }
    return ;
}

T2 Transform

x -> y  <=> 0 -> x xor y

所以从0BFS一下就好了。

然后应该搜到[1,131072]。QAQ（AQ）*

#include<cstdio>
#include<cstring>
#include<cctype>
#include<algorithm>
#include<queue>
#define rep(i,s,t) for(int i=s;i<=t;i++)
#define dwn(i,s,t) for(int i=s;i>=t;i--)
using namespace std;
inline int read() {
    int x=,f=;char c=getchar();
    for(;!isdigit(c);c=getchar()) if(c=='-') f=-;
    for(;isdigit(c);c=getchar()) x=x*+c-'';
    return x*f;
}
const int maxn=;
const int mod=;
typedef long long ll;
int n,m,A[maxn],vis[maxn],d[maxn];
queue<int> Q;
void bfs() {
    memset(vis,,sizeof(vis));d[]=;vis[]=;Q.push();
    while(!Q.empty()) {
        int x=Q.front();Q.pop();
        rep(i,,) {
            int v=x^(<<i);
            if(v<=&&!vis[v]) {
                vis[v]=;d[v]=d[x]+;Q.push(v);
            }
        }
        rep(i,,n) {
            int v=x^A[i];
            if(v<=&&!vis[v]) {
                vis[v]=;d[v]=d[x]+;Q.push(v);
            }
        }
    }
}
int main() {
    dwn(T,read(),) {
        n=read();m=read();
        rep(i,,n) A[i]=read();
        bfs();ll ans=;
        rep(i,,m) (ans+=(ll)i*d[read()^read()])%=mod;
        printf("%I64d\n",ans);
    }
    return ;
}

T3 Toposort

我们逐位考虑，那么我们需要一个数据结构完成这样的功能。

1.找到当前权值<=k的最小节点。

2.将一个节点的权值-1。

显然线段树就行了。

我懒得写线段树，于是STL大法好。

用一个堆来维护一下在某次操作前权值<=k的节点，不行就把它踢出去。

然后拓扑的时候再判判能不能扔到堆里。

因为最多有n+m个节点进入堆，所以时间复杂度为O((n+m)logn)。

#include<cstdio>
#include<cstring>
#include<cctype>
#include<queue>
#include<algorithm>
#define rep(i,s,t) for(int i=s;i<=t;i++)
#define dwn(i,s,t) for(int i=s;i>=t;i--)
using namespace std;
inline int read() {
    int x=,f=;char c=getchar();
    for(;!isdigit(c);c=getchar()) if(c=='-') f=-;
    for(;isdigit(c);c=getchar()) x=x*+c-'';
    return x*f;
}
const int mod=;
const int maxn=;
const int maxm=;
typedef long long ll;
int n,m,k,first[maxn],Next[maxm],to[maxm],in[maxn],is[maxn],e;
void AddEdge(int u,int v) {
    to[++e]=v;Next[e]=first[u];first[u]=e;in[v]++;
}
int main() {
    dwn(T,read(),) {
        n=read();m=read();k=read();
        rep(i,,n) in[i]=first[i]=is[i]=;e=;
        rep(i,,m) {
            int u=read(),v=read();
            AddEdge(u,v);
        }
        priority_queue<int> Q;
        rep(i,,n) if(in[i]<=k) is[i]=,Q.push(-i);
        ll ans=;
        rep(j,,n) {
            int x;
            while(Q.size()) {
                x=-Q.top();Q.pop();is[x]=;
                if(in[x]<=k) break;
            }
            (ans+=(ll)j*x)%=mod;k-=in[x];in[x]=;is[x]=;
            for(int i=first[x];i;i=Next[i]) if(in[to[i]]) {
                in[to[i]]--;
                if(in[to[i]]<=k&&!is[to[i]]) is[to[i]]=,Q.push(-to[i]);
            }
        }
        printf("%I64d\n",ans);
    }
    return ;
}

T4 Deletion

比赛时并没有想出来QAQ(AQ)*

这道题想法很妙，考虑题目说的“要求选出来的边构成的子图的每个连通块最多只有一个环”其实就是环套树。

而如果对一个无向图进行定向，满足所有节点的出边最多只有1，那么这个无向图可以一次选出。

所以问题转化成对一个无向图进行定向，让出边最多的节点出度最少，那么二分答案后就是一个分配模型了。

#include<cstdio>
#include<cctype>
#include<queue>
#include<cstring>
#include<algorithm>
#define rep(i,s,t) for(int i=s;i<=t;i++)
#define dwn(i,s,t) for(int i=s;i>=t;i--)
#define ren for(int i=first[x];i!=-1;i=Next[i])
using namespace std;
typedef long long ll;
inline int read() {
    int x=,f=;char c=getchar();
    for(;!isdigit(c);c=getchar()) if(c=='-') f=-;
    for(;isdigit(c);c=getchar()) x=x*+c-'';
    return x*f;
}
const int maxn=;
const int maxm=;
const int inf=1e9;
struct Dinic {
    int n,m,s,t,first[maxn],Next[maxm];
    void init(int n) {
        m=;this->n=n;
        memset(first,-,sizeof(first));
    }
    struct Edge {int from,to,flow;}edges[maxm];
    void AddEdge(int u,int v,int w) {
        edges[m]=(Edge){u,v,w};Next[m]=first[u];first[u]=m++;
        edges[m]=(Edge){v,u,};Next[m]=first[v];first[v]=m++;
    }
    int d[maxn],vis[maxn],cur[maxn];
    int BFS() {
        memset(vis,,sizeof(vis));
        queue<int> Q;Q.push(s);vis[s]=;
        while(!Q.empty()) {
            int x=Q.front();Q.pop();cur[x]=first[x];
            ren {
                Edge& e=edges[i];
                if(!vis[e.to]&&e.flow) {
                    vis[e.to]=;
                    d[e.to]=d[x]+;
                    Q.push(e.to);
                }
            }
        }
        return vis[t];
    }
    int DFS(int x,int a) {
        if(x==t||!a) return a;
        int flow=,f;
        for(int& i=cur[x];i!=-;i=Next[i]) {
            Edge& e=edges[i];
            if(d[e.to]==d[x]+&&(f=DFS(e.to,min(a,e.flow)))) {
                e.flow-=f;edges[i^].flow+=f;
                a-=f;flow+=f;if(!a) break;
            }
        }
        return flow;
    }
    int solve(int s,int t) {
        this->s=s;this->t=t;int flow=;
        while(BFS()) flow+=DFS(s,inf);
        return flow;
    }
}sol;
int n,m,u[maxn],v[maxn];
int check(int x) {
    int s=n+m+,t=n+m+;sol.init(t);
    rep(i,,n) sol.AddEdge(s,i,x);
    rep(i,,m) sol.AddEdge(i+n,t,);
    rep(i,,m) sol.AddEdge(u[i],i+n,),sol.AddEdge(v[i],i+n,);
    return sol.solve(s,t)==m;
}
void solve() {
    n=read();m=read();
    rep(i,,m) u[i]=read(),v[i]=read();
    if(!m) {puts("");return;}
    int l=,r=m,mid;
    while(l<r) if(check(mid=l+r>>)) r=mid; else l=mid+;
    printf("%d\n",l);
}
int main() {
    dwn(T,read(),) solve();
    return ;
}