Codevs1066 引水入城

• 前言：又是做到吐血的一道题。膜题解以后才明白这题怎么做。

• 思路：

  • 我觉得第一问是很好求的，直接从上往下BFS就够了。第二问被卡住了，但有一点突破口就是，需要确定第一行的某一个格子究竟能控制多少最后一行的格子。

  • 通过样例解释，可以观察到这样一点。似乎对于某一个第一排格子，其可以控制连续一段最后一行的格子，且对于有左右相对顺序的两个第一行的格子，其控制的一排格子也有同样的相对顺序。实际上这个猜想是正确的，证明如下：

    • 对于第一个猜想，如果一个格子的控制范围不是连续的，那么这种情况一定无解。因为如果除该点以外的另一个点能够覆盖这个格子，那么其路径一定会发生交叉，那么，这个点也能覆盖这个格子，与假设矛盾，原猜想正确。

    • 对于第二个猜想，设两个格子与其控制的两排独立的格子的相对位置相反，那么这两个路径一定交叉，进而a能控制b的一排格子，b也能a的一排格子，那么a、b所控制的格子是相同的，与原假设相矛盾，原猜想正确。

  • 现在，通过运用已经得到的两个论证，对最后一行进行线段覆盖就行了，贪心和DP均可。至于确定第一行某点的覆盖范围，需要从底往上BFS，枚举顺序正反各一边，正的确定线段的l，反的确定线段的r（这样做的正确性已由论证二证明，并且重叠的会被长的覆盖）。

• 代码如下

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
#include<algorithm>
using namespace std;
const int maxn=505;
const int dx[5]={0,0,0,1,-1};
const int dy[5]={0,1,-1,0,0};

struct node
{
    int x,y;
    node(int x=0,int y=0):x(x),y(y){}
};

int n,m,cnt;
int map[maxn][maxn];

void init()
{
    scanf("%d%d",&n,&m);
    for (int i=1;i<=n;++i)
      for (int j=1;j<=m;++j)
      {
          scanf("%d",&map[i][j]);
      }
    cnt=m;
}

queue<node> q;
bool vis[maxn][maxn];

void confirm(int x,int y)
{
    while (!q.empty())
       q.pop();
    q.push(node(x,y));
    vis[x][y]=1;
    if (x==n)
      cnt--;
    while (!q.empty())
    {
        node h=q.front();
        q.pop();
        for (int i=1;i<=4;++i)
        {
            int xx=h.x+dx[i];
            int yy=h.y+dy[i];
            if (xx<1 || xx>n || yy<1 || yy>m || vis[xx][yy] || map[xx][yy]>=map[h.x][h.y])
              continue;
            q.push(node(xx,yy));
            vis[xx][yy]=1;
            if (xx==n)
              cnt--;
        }
    }
}

int ex[2][maxn][maxn];

void expand(int x,int y,int dex,int f)
{
    while (!q.empty())
       q.pop();
    q.push(node(x,y));
    ex[f][x][y]=dex;
    while (!q.empty())
    {
        node h=q.front();
        q.pop();
        for (int i=1;i<=4;++i)
        {
            int xx=h.x+dx[i];
            int yy=h.y+dy[i];
            if (xx<1 || xx>n || yy<1 || yy>m || ex[f][xx][yy]!=0 || map[xx][yy]<=map[h.x][h.y])
              continue;
            q.push(node(xx,yy));
            ex[f][xx][yy]=dex;
        }
    }
}

struct pos
{
    int l,r;
    pos(int l=0,int r=0):l(l),r(r){}
    bool operator < (const pos &a) const
    {
        return l==a.l ? (r>a.r) : (l<a.l);
    }
};

pos seg[maxn];
int f[maxn],p=0;

void work()
{
    memset(f,0x3f,sizeof(f));
    f[0]=0;
    for (int i=1;i<=m;++i)
    {
        if (ex[0][1][i]==ex[1][1][i] && ex[0][1][i]==0)
          continue;
        seg[++p]=pos(ex[0][1][i],ex[1][1][i]);
    }
    sort(seg+1,seg+p+1);
    for (int i=1;i<=m;++i)
      for (int j=1;j<=p;++j)
      {
          if (seg[j].l<=i && seg[j].r>=i)
            f[i]=min(f[i],f[seg[j].l-1]+1);
      }
    printf("1\n%d",f[m]);
}

int main()
{
    init();
    for (int i=1;i<=m;++i)
      if (!vis[1][i])
        confirm(1,i);
    if (cnt!=0)
    {
        printf("0\n%d",cnt);
        return 0;
    }
    for (int i=1;i<=m;++i)
      if (!ex[0][n][i])
        expand(n,i,i,0);
    for (int i=m;i>=1;--i)
      if (!ex[1][n][i])
        expand(n,i,i,1);
    work();
    return 0;
}