2013

2013D2T1
积木赛
Task
n个初始为0的数，求最少的操作次数变成目标数组。
一次操作：选择区间[ l , r ]内所有数+1
n<=1e5,0<=hi<=1e4

Solution
贪心：
为使操作次数最少，每次选的区间应尽可能的大。因此每次贪心选一段最长都是正数的区间，区间内数-1.最值可以用堆维护。
如果当前选出的区间操作完后不含0，那么下一次还是会选择这个区间，为减少操作次数，
如果一次性减去这个区间的最小值，就一定会含0，区间分成2个子区间。

用堆写还是太麻烦了，不如dfs，每次找到这个区间内的最小值，分成2个子区间。

const int M=1e5+5;int A[M],n;struct node{    int l,r,x;    bool operator<(const node &t)const{        r-l>t.r-t.l;    }};priority_queue<node>Q;inline void input(){    int i;    rd(n);    rep(i,1,n)rd(A[i]);}inline void add(int L,int R,int x){    int i,k,mi,l,r;    rep(i,L,R)A[i]-=x;    rep(i,L,R){        if(A[i-1]==0&&A[i]>0){            l=i;            mi=A[i];        }        MIN(mi,A[i]);        if(A[i]>0&&A[i+1]==0){            Q.push((node){l,i,mi});        }    }}inline void solve(){    int i,j,k,ans=0,l,r;    node res;    while(!Q.empty()){        res=Q.top();        Q.pop();        ans+=res.x;        add(res.l,res.r,res.x);    }    printf("%d\n",ans);}int main(){    input();    add(1,n,0);    solve();    return 0;}

LIN452大神提供了一种O(n)的方法。
刷漆：
区间加除了线段树以外，还可以用刷漆法处理，左端点+1，右端点+1的位置-1。
对于i点而言，权值从0变成hi，说明[1,i]操作前缀和是hi。对于i-1点而言，操作的前缀和是h[i-1],说明对i点的操作数是h[i]-h[i-1],是以i为操作区间左端点的最少次数。

const int M=1e5+5;int A[M];int n;int main(){    int i,j,k,ans=0;    rd(n);    rep(i,1,n)rd(A[i]);    rep(i,1,n)ans+=max(0,A[i]-A[i-1]);    printf("%d\n",ans);}

2013D2T2
花匠
Task
在n个数去除一些数，使剩余的数满足条件A或条件B,求最多剩余数？
条件A:对所有的i，g[2i]>g[2i-1]，g[2i]>g[2i+1]
条件B:对所有的i，g[2i]小于g[2i-1],g[2i]小于g[2i+1]
n<=1e5,hi<=1e6

Solution
考察LIS的dp思想。

发现最后满足的数是波浪锯齿状，且2个为1组。每个数的选择：不选，组内第一个数，组内第二个数。每一个数都是接在符合条件的另一个数后面。
如果定义dp[0][i]，i作为组第一个，dp[1][i]i作为组第二个。
条件A：
Dp[0][i]=max(dp[1][j])+1 j小于i&&A[j]>A[i]
Dp[1][i]=max(dp[0][i])+1 j小于i&&A[j]小于A[i]
同样的条件B的式子也可以列出。
普通的转移是O(n^2)

但是我们可以借助线段树优化，因为是维护前缀后缀的最值，也可以用树状数组来代替，代码更短，效率更高。
但是比赛时以为后缀的下标搞错了，一个测试点WA了。
X对应的后缀下标是tot-x+1.因为[1,tot] 对应[tot,1]

const int M=1e5+5;int A[M],B[M];int n,ans,tot;struct P70{    int dp[2][1005];    inline void solve(){        int i,j,k,ans=0;        rep(i,1,n)rd(A[i]);        A[0]=1e9;        rep(i,1,n){//条件A             rep(j,0,i-1){                if(A[j]>A[i])MAX(dp[0][i],dp[1][j]+1);                if(A[j]<A[i])MAX(dp[1][i],dp[0][j]);            }        }        rep(i,1,n){            MAX(ans,dp[0][i]*2-1);            MAX(ans,dp[1][i]*2);        }        memset(dp,0,sizeof(dp));        A[0]=-1;        rep(i,1,n){            rep(j,0,i-1){                if(A[j]<A[i])MAX(dp[0][i],dp[1][j]+1);                if(A[j]>A[i])MAX(dp[1][i],dp[0][j]);            }        }        rep(i,1,n){            MAX(ans,dp[0][i]*2-1);            MAX(ans,dp[1][i]*2);        }        printf("%d\n",ans);    }}P70;struct Tree{    int bit[M];    inline void clear(){memset(bit,0,sizeof(bit));}    inline void modify(int i,int x){        while(i<=tot){            MAX(bit[i],x);            i+=lowbit(i);        }    }    inline int query(int i){        int mx=0;        while(i>0){            MAX(mx,bit[i]);            i-=lowbit(i);        }        return mx;    }}T[2];struct P100{    inline void init(){        int i,j,k;        rep(i,1,n)rd(A[i]),B[i-1]=A[i];        sort(B,B+n);        tot=unique(B,B+n)-B;        rep(i,1,n)//离散             A[i]=lower_bound(B,B+tot,A[i])-B+1;    }    inline void solve(){        int i,j,k,ans=0,a,b;        init();        T[0].clear();T[1].clear();        rep(i,1,n){            a=T[1].query(tot-A[i])+1;            b=T[0].query(A[i]-1)+1;            T[0].modify(A[i],a);            T[1].modify(tot-A[i]+1,b);            MAX(ans,max(a,b));        }        T[0].clear();T[1].clear();        rep(i,1,n){            a=T[1].query(A[i]-1)+1;            b=T[0].query(tot-A[i])+1;            T[0].modify(tot-A[i]+1,a);            T[1].modify(A[i],b);            MAX(ans,max(a,b));        }        printf("%d\n",ans);    }}P100;int main(){    rd(n);    if(n<=1000){P70.solve();return 0;}    P100.solve();    return 0;}

2013D2T3
华容道
Task
N*m棋盘上有n*m-1个棋子，1个空白格，棋子有若干个不能移动，剩余的可以移动，空白格只能和四周可以移动的格子交换位置。
Q个询问，除了不能移动的棋子外，空白格，其余棋子，初始目标位置都可能改变，求某棋子从初始位置到目标位置的最小步数。
60%数据,n,m<=30,q<=10
100% 数据，n,m<=30,q<=500

Solution
60分bfs
类似judge1205推箱子，从初始位置移动到目标位置的最小步数，唯一不同的是该题是多次询问。bfs可以求解最小步数的问题。
因为我们只关心空白格子和初始特别格子的位置，因此在bfs时只用记录这2个的坐标。
搜索时，注意判重，不合法的情况。

值得一提的是，Y同学用dfs?bfs?做没有判重,电脑死机了。唉╮(╯▽╰)╭

100分 最短路
题目中有一句话:要将指定块移入目标位置，必须先将空白块移入目标位置。给我带来了很大的提示。
更广泛的说，如果x要达到某个位置，必须先将空白格移到该位置，再交换，且该位置一定在x的四周。
60分是搜索空白格的路径，但100分是搜索x的路径，相比60分而言，同样是bfs，但是主体不同。可以一步代替多步，从无方向到有方向。
如果我已知x位置和空白格位置（一定在x的四周）那么x只能和空白格交换，因此可以得知x的新位置，空白格也必须移动到x的四周。
因此可以预处理点(x,y)在不经过中心点的情况下，到达中心点四周的最短路。

const int M=30;int rx[]={0,1,0,-1},ry[]={1,0,-1,0};int dis[M][M][4][M][M],val[M][M][4];bool A[M][M],vis[M][M],use[M][M][4];int n,m,q;struct qu{    int x,y;}Qu[905];struct node{    int x,y,d,v;    bool operator<(const node &t)const{        return v>t.v;    }};priority_queue<node>Q;inline void input(){    int i,j,k;    rd(n);rd(m);rd(q);    rep(i,0,n-1)        rep(j,0,m-1)rd(A[i][j]);}inline bool check(int x,int y){    return x>=0&&x<n&&y>=0&&y<m&&A[x][y]==1;}inline void bfs(int a,int b,int p){    int i,j,k,x,y,l,r,nx,ny;    qu res;    x=a+rx[p],y=b+ry[p];    memset(vis,0,sizeof(vis));    vis[a][b]=vis[x][y]=1;    l=r=dis[a][b][p][x][y]=0;    Qu[r++]=(qu){x,y};    while(l<r){        res=Qu[l++];        rep(i,0,3){            nx=res.x+rx[i],ny=res.y+ry[i];            if(!check(nx,ny)||vis[nx][ny])continue;            vis[nx][ny]=1;            dis[a][b][p][nx][ny]=dis[a][b][p][res.x][res.y]+1;            Qu[r++]=(qu){nx,ny};        }    }}inline void init(){    int i,j,k,ii,jj;    memset(dis,-1,sizeof(dis));    rep(i,0,n-1)        rep(j,0,m-1){            if(A[i][j]==0)continue;            rep(k,0,3)                if(check(i+rx[k],j+ry[k])){                    bfs(i,j,k);                }        }}inline int dijkstra(int tx,int ty){    int i,j,k,x,y;    node res;    while(!Q.empty()){        res=Q.top();Q.pop();        if(use[res.x][res.y][res.d])continue;        if(res.x==tx&&res.y==ty)return val[res.x][res.y][res.d];        use[res.x][res.y][res.d]=1;        x=res.x+rx[res.d],y=res.y+ry[res.d];        rep(i,0,3){            k=dis[x][y][i][res.x][res.y];            if(k>=0){                if(res.v+k+1<val[x][y][i])val[x][y][i]=res.v+k+1;                Q.push((node){x,y,i,res.v+k+1});            }        }    }    return -1;}inline void solve(){    int i,j,k,wx,wy,bx,by,tx,ty;    while(q--){        rd(wx);rd(wy);rd(bx);rd(by);rd(tx);rd(ty);        wx--,wy--,bx--,by--,tx--,ty--;        if(bx==tx&&by==ty){puts("0");continue;}        memset(use,0,sizeof(use));        memset(val,0x3f,sizeof(val));        while(!Q.empty())Q.pop();        rep(i,0,3){            k=dis[bx][by][i][wx][wy];            if(~k){                val[bx][by][i]=k;                Q.push((node){bx,by,i,k});            }        }        printf("%d\n",dijkstra(tx,ty));    }}int main(){    input();    init();    solve();    return 0;}