COCI2014-2015CONTEST#7——POLICE

http://www.hsin.hr/coci/archive/2014_2015/contest7_tasks.pdf

【题目描述】

有N个书架，每个书架可以容纳M本书。给出了若干本书，每本书有一个正整数的唯一编号，且编号不超过N*M。 给出了初始时各个书架里面的书的编号，即给出二维数组S[1..N][1..M]。设S[i][j]=k，表示的意义是第i个书架的第j个格子放的那本书的编号是k。如果k等于0则说明该格子没有书，是空的。一个格子最多只能放一本书。再给出二维数组T[1..N][1..M]，表示最终你需要把这些书经过移动之后达到的目的。你移动书的过程需要满足如下两个条件：

1、你可以把某一个书架的书向左或者向右推动一格。这就是横向的“推”动作，你可以“推”任意多次。

2、你可以拿起某一个书架的一本书，然后把这本书放到任意书架的空格子里。这就是“拿”动作。你可以“拿”任意多次。注意：当你“拿”起一本书时，你是不能做“推”的动作。则“拿”起一本书，接下来的那个动作必须是把这本书放到一个空格子里。每次只能“拿”起一本书。

现在你的任务是：用最少次数的“拿”动作，去完成目标，如果无法完成目标，输出-1。

【输入格式】

第一行，两个整数N和M。 1<=N,M<=1000。

接下来是N行M列的S二维数组。

接下来是N行M列的T二维数组。

【输出格式】

最少次数的“拿”动作。

【数据范围】

50%的数据保证每本书开始和结束时都在同一个书架上。

 

先来考虑无解的情况。如果所有书架都没有空位，并且存在一本书开始和结束时不在同一个位置，那么无解，输出-1。

当然，如果所有书架都没有空位，但是所有的书开始和结束时都在同一个位置，那么直接输出0即可。

我们先来讨论一下50%数据的情况：每本书开始和结束时都在同一个书架上。

记$k[i]$为开始和结束时都在书架$i$上的书数。

我们分2种情况讨论：

a.书架上有空位

我们只在书架i上移动。

因为有空位，所以我们可以随便把一本书放在任意两本书之间。

根据这$k[i]$本书开始和结束的位置，转换后求最长上升子序列，记$lis[i]$为根据这$k[i]$本书开始和结束的位置转换后求到的最长上升子序列。

那么第$i$个书架的答案是$k[i]-lis[i]$

b.书架上没有空位

我们必须先拿出一本书放到其他的书架上，空出一个位置，我们才可以随便把一本书放在任意两本书之间；最后再把放到其他书架的那本书直接放到它最终位置。

那么第$i$个书架的答案是$k[i]-lis[i]+1$

我们现在来讨论一下100%时情况：

$k[i]$还是表示开始和结束时都在书架$i$上的书数，$lis[i]$还是表示根据这$k[i]$本书开始和结束的位置转换后求到的最长上升子序列。

这时可能有些书开始和结束的时候不在同一个书架上。

我们把每个书架都看成一个点，如果有一本书开始时在书架$i$，结束时在书架$j$，那么点$i$到点$j$连一条有向边。

我们把每个连通图单独考虑。

分两种情况讨论：

a.连通图里所有的书架开始时都没有空位

容易知道连通图里所有书架结束时也都没有空位。

我们发现每个点的入度都等于出度，所以可以构成一个欧拉回路。

第一步，我们必须先拿出一本书放到其他的书架上，空出一个位置；然后根据欧拉回路，把不在正确书架的上的书放到正确书架的正确位置上，我们要移动的步数等于边数；最后再把放到其他书架的那本书直接放到它最终位置。

我们发现，对于这个连通中的每个点$i$，存在某个一个时刻，书架$i$上存在一个空位。

根据前面的推论容易知道：如果某个时刻书架存在$i$一个空位，那么把$k[i]$本开始和结束都在书架$i$上的书放回原位的最长步数是$k[i]-lis[i]$。

所以这个连通图的答案是$边数+\sum (k[i]-lis[i])+1$

注意这里有个特殊情况，就是如果连通图里只有一个书架，并且书都已经在正确位置上了，即使已经没有空位了，也不用移动。

b.连通图里存在一个书架开始时有空位

 我们任选一个入度大于出度的点$u$和一个出度大于入度的点$v$，从点$u$到点$v$连一条虚拟的有向边。

重复上述过程，直至所有点的入度均等于出度。

任选一个开始时有空位的书架，类似地，根据欧拉回路，如果走实边，那么把不在正确书架的上的书放到正确书架的正确位置上；如果走虚边，那么不做任何操作。

这样为什么是对的呢？

我们发现，对于入度大于出度的点，一定至少有$入度-出度$个空位；而对于入度大于出度的点，只有$入度-出度$条虚边从它自己出发。

所以一定有足够的空位。

这种方法好神奇！

所以这个连通图的答案是$实边数+\sum (k[i]-lis[i])$

虽然我们分析了这么久，但是其实实现起来非常简单，时间复杂度$O(nmlogm)$

#include<cstdio>
#include<cstdlib>
#include<iostream>
#include<fstream>
#include<algorithm>
#include<cstring>
#include<string>
#include<cmath>
#include<queue>
#include<stack>
#include<map>
#include<utility>
#include<set>
#include<bitset>
#include<vector>
#include<functional>
#include<deque>
#include<cctype>
#include<climits>
#include<complex>
//#include<bits/stdc++.h>适用于CF,UOJ，但不适用于poj
 
using namespace std;

typedef long long LL;
typedef double DB;
typedef pair<int,int> PII;
typedef complex<DB> CP;

#define mmst(a,v) memset(a,v,sizeof(a))
#define mmcy(a,b) memcpy(a,b,sizeof(a))
#define fill(a,l,r,v) fill(a+l,a+r+1,v)
#define re(i,a,b)  for(i=(a);i<=(b);i++)
#define red(i,a,b) for(i=(a);i>=(b);i--)
#define ire(i,x) for(typedef(x.begin()) i=x.begin();i!=x.end();i++)
#define fi first
#define se second
#define m_p(a,b) make_pair(a,b)
#define p_b(a) push_back(a)
#define SF scanf
#define PF printf
#define two(k) (1<<(k))

template<class T>inline T sqr(T x){return x*x;}
template<class T>inline void upmin(T &t,T tmp){if(t>tmp)t=tmp;}
template<class T>inline void upmax(T &t,T tmp){if(t<tmp)t=tmp;}

inline int sgn(DB x){if(abs(x)<1e-9)return 0;return(x>0)?1:-1;}
const DB Pi=acos(-1.0);

int gint()
  {
        int res=0;bool neg=0;char z;
        for(z=getchar();z!=EOF && z!='-' && !isdigit(z);z=getchar());
        if(z==EOF)return 0;
        if(z=='-'){neg=1;z=getchar();}
        for(;z!=EOF && isdigit(z);res=res*10+z-'0',z=getchar());
        return (neg)?-res:res; 
    }
LL gll()
  {
      LL res=0;bool neg=0;char z;
        for(z=getchar();z!=EOF && z!='-' && !isdigit(z);z=getchar());
        if(z==EOF)return 0;
        if(z=='-'){neg=1;z=getchar();}
        for(;z!=EOF && isdigit(z);res=res*10+z-'0',z=getchar());
        return (neg)?-res:res; 
    }

const int maxn=1000;
const int maxm=1000;

int n,m;
int S[maxn+10][maxm+10],T[maxn+10][maxm+10];

int check()
  {
      int i,j;
      int flag=0;
      re(i,1,n)re(j,1,m)if(S[i][j]==0){flag=1;break;}
      if(flag)return 0;
      re(i,1,n)re(j,1,m)if(S[i][j]!=T[i][j]){PF("-1\n");return 1;}
      PF("0\n");return 1;
  }

int k[maxn+100],lis[maxn+100],empty[maxn+100];//k[i]表示开始和结束都在书架i上的书数；lis[i]表示开始和结束都在书架i上的书的最长上升子序列 

#define lowbit(a) ((a)&(-a))
int tree[maxm+100];
void update(int a,int v){for(;a<=m;a+=lowbit(a))upmax(tree[a],v);}
int ask(int a){int res=0;for(;a>=1;a-=lowbit(a))upmax(res,tree[a]);return res;}

int s[maxm+100],t[maxm+100],vis[maxn*maxm+100],f[maxm+100];
void solve(int &k,int &lis,int &empty)
  {
      int i;
      empty=0;
      re(i,1,m)if(s[i]==0){empty=1;break;}
      re(i,1,m)if(t[i]!=0)vis[t[i]]=i;
      re(i,1,m)if(s[i]!=0)if(!vis[s[i]])s[i]=0;else s[i]=vis[s[i]];
        re(i,1,m)if(t[i]!=0)vis[t[i]]=0;
        re(i,1,m)if(s[i]!=0)k++;
      mmst(f,0);mmst(tree,0);
      re(i,1,m)if(s[i]!=0)f[i]=ask(s[i]-1)+1,update(s[i],f[i]);
      re(i,1,m)upmax(lis,f[i]);
  }

PII pos[maxn*maxm+100];
int now,info[maxn+100];
struct Tedge{int v,next;}edge[2*maxn*maxm+100];
int outdegree[maxn+100];

void addedge(int u,int v){now++;edge[now].v=v;edge[now].next=info[u];info[u]=now;}

int ans;

int head,tail,que[maxn+100];
int bfs(int start)
  {
      int i,j;
      vis[que[head=tail=1]=start]=1;
      while(head<=tail)
        {
            int u=que[head++],v;
            for(i=info[u],v=edge[i].v;i!=-1;i=edge[i].next,v=edge[i].v)if(!vis[v])vis[que[++tail]=v]=1;
        }
      int res=0;
      re(i,1,tail){int u=que[i];res+=outdegree[u];}
      re(i,1,tail){int u=que[i];res+=k[u]-lis[u];}
      if(tail==1)
        {
            int u=que[1];
            if(!empty[u] && lis[u]!=m)res++;
        }
      else
        {
            res++;
            re(i,1,tail){int u=que[i];if(empty[u]){res--;break;}}
          }
      return res;
  }

int main()
  {
      freopen("police.in","r",stdin);
      freopen("police.out","w",stdout);
      int i,j;
      n=gint();m=gint();
      re(i,1,n)re(j,1,m)S[i][j]=gint();
      re(i,1,n)re(j,1,m)T[i][j]=gint();
      if(check())return 0;
      re(i,1,n)
          {
              re(j,1,m)s[j]=S[i][j],t[j]=T[i][j];
                solve(k[i],lis[i],empty[i]);
            }
        re(i,1,n)re(j,1,m)
          {
              if(S[i][j]!=0)pos[S[i][j]].fi=i;
              if(T[i][j]!=0)pos[T[i][j]].se=i;
          }
        now=-1;mmst(info,-1);
        re(i,1,n*m)if(pos[i].fi && pos[i].fi!=pos[i].se)
          {
              addedge(pos[i].fi,pos[i].se);
                addedge(pos[i].se,pos[i].fi);
                outdegree[pos[i].fi]++;
            }
        ans=0;
        re(i,1,n)if(!vis[i])ans+=bfs(i);
        PF("%d\n",ans);
        return 0;
  }