Codeforces Round #532 (Div. 2)

D. Dasha and Chess

交互题。题意： 有666个黑色的车和1个白色的国王在999*999的棋盘上，当白色的国王和任意一个黑色的车处于同一行，同一列的时候，白色国王胜利。白色的国王开始先行棋，NN执白，每一步可以横着，竖着或者斜着走一格，如果目标格子上已经有棋了那么就不能走。黑色的车每一次可以从一个格子走到任意的其他格子。每个玩家走2000步，如果白棋没法将军则黑棋胜利。现在你来执白棋，并想办法取得胜利。 

题解：

我们先把白棋走到棋盘的中间，然后一直向黑棋最多的角斜着走，这样一定可以将军。正确性显然。

#include<stdio.h>
#include<stdlib.h>
const int maxn = 1005;
int x,y,u,v,w,px[maxn],py[maxn],vis[maxn][maxn],sum[5],sum2[5];
int dis[5][2]={0,0,-1,-1,-1,1,1,-1,1,1};
void move_(int xx,int yy)
{
    x+=xx;
    y+=yy;
    if(vis[x][y]) x-=xx;
    printf("%d %d\n",x,y);
    fflush(stdout);
    scanf("%d%d%d",&u,&v,&w);
    if(u==-1&&v==-1&&w==-1) exit(0);
    vis[px[u]][py[u]]=0;
    vis[v][w]=1;
    px[u]=v;
    py[u]=w;
    return ;
}
int main()
{
    scanf("%d%d",&x,&y);
    for(int i=1;i<=666;i++)
    {
        scanf("%d%d",&px[i],&py[i]);
        vis[px[i]][py[i]]=1;
    }
    int dir=-1;
    while(x<500) move_(1,0);
    while(y<500) move_(0,1);
    while(x>500) move_(-1,0);
    while(y>500) move_(0,-1);
    for(int i=1;i<=499;i++) for(int j=1;j<=499;j++) if(vis[i][j]) sum[1]++;
    for(int i=1;i<=499;i++) for(int j=501;j<=999;j++) if(vis[i][j]) sum[2]++;
    for(int i=501;i<=999;i++) for(int j=1;j<=499;j++) if(vis[i][j]) sum[3]++;
    for(int i=501;i<=999;i++) for(int j=501;j<=999;j++) if(vis[i][j]) sum[4]++;
    sum2[1]=sum[1]+sum[2]+sum[3];
    sum2[2]=sum[2]+sum[1]+sum[4];
    sum2[3]=sum[3]+sum[1]+sum[4];
    sum2[4]=sum[4]+sum[2]+sum[3];
    int maxx=0;
    for(int i=1;i<=4;i++)
    {
        if(sum2[i]>maxx)
        {
            maxx=sum2[i];
            dir=i;
        }
    }
    while(true) move_(dis[dir][0],dis[dir][1]);
    return 0;
}

E. Andrew and Taxi

题意：

给你一个有边权的有向图，反转一条边的代价是这条边的边权，反转多个边的代价是所有反转边里面边权最大的那条边的边权，问让这个图不存在环的最小代价，以及被反转的边的编号。

题解：

我们先这么想，给出一个最小代价Min，我们如何判断是否有环？因为代价小于等于Min的边都可以选择反转，所以只要对于边权大于Min的边跑拓扑排序，如果没环就说明Min是可行的。那么反转哪些边呢？我们现在已经得到了拓扑序，然后只要对于每一条wi<=Min的从u到v的边，如果topo[v]<topo[u]，那么这条边就需要被反转。显然Min是可以通过二分获得的。

#include <cstdio>
#include <algorithm>
#include <iostream>
#include <cstring>
#include <queue>
#include <vector>

using namespace std;
const int maxn=100000+100;
int n,m,sz;
int head[maxn],Next[maxn],to[maxn],w[maxn],num[maxn];
void init(){
    sz=0;
    memset(head,-1,sizeof(head));
}
void add_edge(int a,int b,int c,int cnt){
    ++sz;
    to[sz]=b;w[sz]=c;num[sz]=cnt;Next[sz]=head[a];head[a]=sz;
}
int topo[maxn],Topo[maxn],vis[maxn],cnt;

bool is_circle(int u,int mid){
    vis[u]=-1;
    for(int i=head[u];i!=-1;i=Next[i]){
        int v=to[i];
        if(w[i]<=mid)continue;
        if(vis[v]==-1)return true;
        if(!vis[v])
            if(is_circle(v,mid))
                return true;
    }
    topo[cnt]=u;
    Topo[u]=cnt--;
    vis[u]=1;
    return false;
}
int Max;
int main(){
    init();
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++){
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        Max=max(Max,c);
        add_edge(a,b,c,i);
    }
    cnt=n;
//    for(int i=1;i<=n;i++){
//        printf("%d ",topo[i]);
//    }
    int l=0,r=Max,ans=0;
    while(l<=r){
        int mid=l+(r-l)/2;
        memset(vis,0,sizeof(vis));
        int flag=0;
        cnt=n;
        for(int i=1;i<=n;i++){
            if(!vis[i]){
                if(is_circle(i,mid)){
                   flag=1;
                   break;
                }
            }
        }

        if(!flag){
            ans=mid;
            r=mid-1;
        }else{
            l=mid+1;
        }
    }
    //printf("%d\n",ans);
    vector<int>ANS;
    memset(vis,0,sizeof(vis));
    cnt=n;
    for(int i=1;i<=n;i++)
        if(!vis[i])
            is_circle(i,ans);

    for(int i=1;i<=n;i++){
        for(int j=head[i];j!=-1;j=Next[j]){
            int v=to[j];
           // printf("%d %d %d %d %d\n",i,v,w[j],Topo[i],Topo[v]);
            if(w[j]<=ans&&Topo[v]<Topo[i]){
                ANS.push_back(num[j]);
            }
        }
    }
    printf("%d %d\n",ans,ANS.size());
    for(int i=0;i<ANS.size();i++){
        printf("%d ",ANS[i]);
    }
return 0;
}

F.题意：

给出n个数字ci和q个询问，每次询问给出li和ri，需要你求出从区间[li,ri]内选出一些数字，异或值最大。

题解：

这个题一看就是线性基。我们先来看一下简化版，也是线性基最经典的应用之一。如果是只有一次询问，问从这n个数字中选出一些数使得异或值最大。该怎么做？我们先求出这n个数字的线性基，然后从高位开始异或如果异或上这个值数变大那么就异或上。想想为什么？因为异或上高位的可能会影响异或低位的，但是结果一定不会更差。我们回到这个题，我们考虑离线的做法，将询问按照右端点排序，然后从1到n扫开始构造线性基，但是和正常构造的区别是，这里构造的时候，对于当前的元素，它所在线性基的位置一定是越高越好的。那么我们这里就有一个“替换”操作。详细的可以看代码。

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <vector>

using namespace std;
typedef long long LL;
const int maxn=500000+10;
int n,q;
int c[maxn],x[100],l[100];
struct Seg{
    int l,r;
}seg[maxn];
LL ans[maxn];
vector<int>en[maxn];

int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        scanf("%d",&c[i]);
    }
    scanf("%d",&q);
    for(int i=1;i<=q;i++){
        scanf("%d%d",&seg[i].l,&seg[i].r);
        en[seg[i].r].push_back(i);
    }

    for(int i=1;i<=n;i++){
        int pos=i;
        for(int j=62;j>=0;j--){
            if(((c[pos]>>j)&1)==0)continue;
            if(!x[j]){x[j]=c[pos];l[j]=pos;break;}
            else if(l[j]<pos){
                //swap(x[j],c[pos]);
                x[j]=c[pos];
                swap(pos,l[j]);
            }
            c[pos]^=x[j];
        }

        for(int j=0;j<en[i].size();j++){
            ans[en[i][j]]=0;
            for(int k=62;k>=0;k--){
                if(l[k]>=seg[en[i][j]].l){
                    ans[en[i][j]]=max(ans[en[i][j]],x[k]^ans[en[i][j]]);
                }
            }
        }
    }

    for(int i=1;i<=q;i++){
        printf("%I64d\n",ans[i]);
    }
return 0;
}