1675: [Usaco2005 Feb]Rigging the Bovine Election 竞选划区（题解第二弹）

1675: [Usaco2005 Feb]Rigging the Bovine Election 竞选划区

Time Limit: 5 Sec  Memory Limit: 64 MB
Submit: 198  Solved: 118
[Submit][Status][Discuss]

Description

It's election time. The farm is partitioned into a 5x5 grid of cow locations, each of which holds either a Holstein ('H') or Jersey ('J') cow. The Jerseys want to create a voting district of 7 contiguous (vertically or horizontally) cow locations such that the Jerseys outnumber the Holsteins. How many ways can this be done for the supplied grid?

 农场被划分为5x5的格子，每个格子中都有一头奶牛，并且只有荷斯坦(标记为H)和杰尔西（标记为J）两个品种．如果一头奶牛在另一头上下左右四个格子中的任一格里，我们说它们相连．    奶牛要大选了．现在有一只杰尔西奶牛们想选择7头相连的奶牛，划成一个竞选区，使得其中它们品种的奶牛比荷斯坦的多．  要求你编写一个程序求出方案总数．

Input

* Lines 1..5: Each of the five lines contains five characters per line, each 'H' or 'J'. No spaces are present.

    5行，输入农场的情况．

Output

* Line 1: The number of distinct districts of 7 connected cows such that the Jerseys outnumber the Holsteins in the district.

    输出划区方案总数．

 

Sample Input

HHHHH
JHJHJ
HHHHH
HJHHJ
HHHHH

Sample Output

2

HINT

 

 

 

Source

Silver

 

题解：之前的题解中（传送门），采用的是\(O\left({25}^{7} \right)\)的简单暴力枚举，虽然能A，我一直认为还有更灵活的办法可以去做，于是有了这个第二篇题解

这次的思路是：每次先找一个点，然后向这个点的四周进行扩张，每一层dfs在原有的块的基础上再向外扩张一个，最终形成的块必然是7个连续的格子，应该能够起到比较好的优化效果——因为我每次选取扩张的点，都是通过动态维护当前块周围一圈的点来进行的，对于联通块而言，在地图内最多只能有15个周围的点，所以复杂度一下子降到了\(O\left({15}^{7} \right)\)，并且完全不需要判断7个点是否构成一块。。。

以上是优点，但是这样一来仔细想想，缺点也十分明显——由于对于同样一个图形而言，可以由很多中扩张顺序可以形成，所以势必造成巨大的重复计算，这是个致命的伤。。。所以只好进行判重，所以只好又写了个双值哈希，确保一种选取情况对应一对唯一的哈希值，而对于一大堆乱七八糟的哈希值对，怎样判断是否存在呢？于是逗比的我又来个了平衡树进行查找，这样子算下来，时间复杂度 \(O\left({15}^{7}\times 7 Ans \log Ans \right)\)

/**************************************************************
    Problem: 1675
    User: HansBug
    Language: Pascal
    Result: Accepted
    Time:2524 ms
    Memory:2964 kb
****************************************************************/
 
const p=314159;q=951413;
type
    pair=record
               a0,b0:int64;
    end;
var
   i,j,k,l,m,n,head,tot,ans,av:longint;
   lef,rig,fix:array[0..100000] of longint;
   b:array[0..100000,1..2] of int64;
   c,d:array[0..100,1..2] of longint;
   a,e:array[0..10,0..10] of longint;
   list:array[0..25,1..2] of int64;
   ch:char;
procedure rt(var x:longint);
          var l,f:longint;
          begin
               if (x=0) or (lef[x]=0) then exit;
               f:=x;l:=lef[x];
               lef[f]:=rig[l];
               rig[l]:=f;
               x:=l;
          end;
procedure lt(var x:longint);
          var r,f:longint;
          begin
               if (x=0) or (rig[x]=0) then exit;
               f:=x;r:=rig[x];
               rig[f]:=lef[r];
               lef[r]:=f;
               x:=r;
          end;
function ins(var x:longint;y:longint):boolean;
          begin
               ins:=true;
               if x=0 then
                  begin
                       x:=y;
                       exit;
                  end;
               if (b[y,1]<b[x,1]) or ((b[y,1]=b[x,1]) and (b[y,2]<b[x,2])) then
                  begin
                       if lef[x]=0 then lef[x]:=y else ins:=ins(lef[x],y);
                       if fix[lef[x]]<fix[x] then rt(x);
                  end
               else if (b[y,1]>b[x,1]) or ((b[y,1]=b[x,1]) and (b[y,2]>b[x,2])) then
                    begin
                         if rig[x]=0 then rig[x]:=y else ins:=ins(rig[x],y);
                         if fix[rig[x]]<fix[x] then lt(x);
                    end
               else exit(false);
          end;
function checkhash(t:pair):boolean;
         begin
              inc(tot);
              b[tot,1]:=t.a0;b[tot,2]:=t.b0;
              lef[tot]:=0;rig[tot]:=0;fix[tot]:=random(maxlongint);
              checkhash:=ins(head,tot);
              if not(checkhash) then dec(tot);
         end;
function trans(x,y:longint):longint;
         begin
              trans:=(x-1)*5+y;
         end;
function hashstate:pair;
         var
            i,j:longint;x,y:int64;t:pair;
         begin
              x:=0;y:=0;
              for i:=1 to 7 do
                  begin
                       j:=trans(c[i,1],c[i,2]);
                       x:=(x+list[j,1]) mod q;
                       y:=(y+list[j,2]) mod p;
                  end;
              t.a0:=x;t.b0:=y;
              exit(t);
         end;
procedure hashstartup;
          var i:longint;
          begin
               list[0,1]:=1;list[0,2]:=1;
               for i:=1 to 25 do
                   begin
                        list[i,1]:=(list[i-1,1]*p) mod q;
                        list[i,2]:=(list[i-1,2]*q) mod p;
                   end;
          end;
procedure dfs(z:longint);
          var i,j,k,l:longint;
          begin
               if z>7 then
                  begin
                       j:=0;
                       for i:=1 to 7 do inc(j,a[c[i,1],c[i,2]]);
                       if j<=3 then exit;
                       if checkhash(hashstate) then
                          begin
                               inc(ans);
                          end;
                       exit;
                  end;
               l:=av;
               for i:=1 to l do
                   begin
                        if e[d[i,1],d[i,2]]<>1 then continue;
                        c[z,1]:=d[i,1];c[z,2]:=d[i,2];
                        e[d[i,1],d[i,2]]:=2;
                        if e[d[i,1]-1,d[i,2]]=0 then
                           begin
                                inc(av);
                                d[av,1]:=d[i,1]-1;
                                d[av,2]:=d[i,2];
                                e[d[i,1]-1,d[i,2]]:=1;
                           end;
                        if e[d[i,1]+1,d[i,2]]=0 then
                           begin
                                inc(av);
                                d[av,1]:=d[i,1]+1;
                                d[av,2]:=d[i,2];
                                e[d[i,1]+1,d[i,2]]:=1;
                           end;
                        if e[d[i,1],d[i,2]-1]=0 then
                           begin
                                inc(av);
                                d[av,1]:=d[i,1];
                                d[av,2]:=d[i,2]-1;
                                e[d[i,1],d[i,2]-1]:=1;
                           end;
                        if e[d[i,1],d[i,2]+1]=0 then
                           begin
                                inc(av);
                                d[av,1]:=d[i,1];
                                d[av,2]:=d[i,2]+1;
                                e[d[i,1],d[i,2]+1]:=1;
                           end;
                        dfs(z+1);
                        while av>l do
                              begin
                                   e[d[av,1],d[av,2]]:=0;
                                   d[av,1]:=0;d[av,2]:=0;
                                   dec(av);
                              end;
                        e[d[i,1],d[i,2]]:=1;
                   end;
          end;
begin
     hashstartup;
     tot:=0;head:=0;ans:=0;av:=0;
     randomize;
     fillchar(e,sizeof(e),0);
     for i:=0 to 6 do
         begin
              e[i,0]:=1;e[0,i]:=1;
              e[i,6]:=1;e[6,i]:=1;
         end;
     for i:=1 to 5 do
         begin
              for j:=1 to 5 do
                  begin
                       read(ch);
                       case upcase(ch) of
                            'H':a[i,j]:=0;
                            'J':a[i,j]:=1;
                       end;
                  end;
              readln;
         end;
     for i:=1 to 5 do
         for j:=1 to 5 do
             begin
                  av:=0;
                  c[1,1]:=i;c[1,2]:=j;
                  if e[i-1,j]=0 then
                     begin
                          inc(av);
                          d[av,1]:=i-1;d[av,2]:=j;
                          e[i-1,j]:=1;
                     end;
                  if e[i+1,j]=0 then
                     begin
                          inc(av);
                          d[av,1]:=i+1;d[av,2]:=j;
                          e[i+1,j]:=1;
                     end;
                  if e[i,j-1]=0 then
                     begin
                          inc(av);
                          d[av,1]:=i;d[av,2]:=j-1;
                          e[i,j-1]:=1;
                     end;
                  if e[i,j+1]=0 then
                     begin
                          inc(av);
                          d[av,1]:=i;d[av,2]:=j+1;
                          e[i,j+1]:=1;
                     end;
                  e[i,j]:=2;
                  dfs(2);
                  while av>0 do
                        begin
                             e[d[av,1],d[av,2]]:=0;
                             d[av,1]:=0;d[av,2]:=0;
                             dec(av);
                        end;
                  e[i,j]:=0;
             end;
     writeln(ans);
     readln;
end.           

于是我很嗨皮的交了一下，结果是（上面的那个是这种新的算法，下面的是之前的纯暴力）

于是我再一次有了一种彻底被吓尿的赶脚QAQ，实在没想到这玩意常数会这么大，还有后来查了一下数据，事实证明在有些比较单调的图中，我程序的速度相当坑TT

所以只能优化啦——比如，我们不难发现每个块总有一个x值最小的点，于是可以在下面的搜索过程中限制扩张方向，只准向下、向右、向左（注意：不可以一一个点为基准，同时限制向下和向左，想想为什么^_^）；还有，当当前的块里面已经出现4个H的时候，我觉得这个块就没任何继续下去的必要了对不——就算接下来全是J也没有用^_^；还有就是简单的常数优化了

于是再交了一次，结果如下（这两个都是优化过的，唯一的区别在于是否在过程和函数后面加了inline;）

于是，我终于战胜了原来的纯暴力，可实际上也不难发现一个问题——我后来写的优化程序有7KB还多，而简单的暴力只有2.5KB的样子，而且弄来弄去我最终的程序也才快了0.2s的样子，在考场上这根本不存在决定性作用。

显然，对这道题而言，还是朴素的暴力算法性价比高得多，尤其是考场上在极为有限的时间内，选择一个合适的方法尤其重要；不过我们还是不要为此导致不敢乱搞，脑洞还是要大开的^_^

优化代码：

/**************************************************************
    Problem: 1675
    User: HansBug
    Language: Pascal
    Result: Accepted
    Time:1660 ms
    Memory:2972 kb
****************************************************************/
 
const p=314159;q=951413;
type
    pair=record
               a0,b0:int64;
    end;
var
   i,j,k,l,m,n,head,tot,ans,av:longint;
   lef,rig,fix:array[0..100000] of longint;
   b:array[0..100000,1..2] of int64;
   c,d:array[0..100,1..2] of longint;
   a,e:array[0..10,0..10] of longint;
   list:array[0..25,1..2] of int64;
   ch:char;
procedure rt(var x:longint);inline;
          var l,f:longint;
          begin
               if (x=0) or (lef[x]=0) then exit;
               f:=x;l:=lef[x];
               lef[f]:=rig[l];
               rig[l]:=f;
               x:=l;
          end;
procedure lt(var x:longint);inline;
          var r,f:longint;
          begin
               if (x=0) or (rig[x]=0) then exit;
               f:=x;r:=rig[x];
               rig[f]:=lef[r];
               lef[r]:=f;
               x:=r;
          end;
function ins(var x:longint;y:longint):boolean;inline;
          begin
               ins:=true;
               if x=0 then
                  begin
                       x:=y;
                       exit;
                  end;
               if (b[y,1]<b[x,1]) or ((b[y,1]=b[x,1]) and (b[y,2]<b[x,2])) then
                  begin
                       if lef[x]=0 then lef[x]:=y else ins:=ins(lef[x],y);
                       if fix[lef[x]]<fix[x] then rt(x);
                  end
               else if (b[y,1]>b[x,1]) or ((b[y,1]=b[x,1]) and (b[y,2]>b[x,2])) then
                    begin
                         if rig[x]=0 then rig[x]:=y else ins:=ins(rig[x],y);
                         if fix[rig[x]]<fix[x] then lt(x);
                    end
               else exit(false);
          end;
function checkhash(t:pair):boolean;inline;
         begin
              inc(tot);
              b[tot,1]:=t.a0;b[tot,2]:=t.b0;
              lef[tot]:=0;rig[tot]:=0;fix[tot]:=random(maxlongint);
              checkhash:=ins(head,tot);
              if not(checkhash) then dec(tot);
         end;
function trans(x,y:longint):longint;inline;
         begin
              trans:=(x-1)*5+y;
         end;
function hashstate:pair;inline;
         var
            i,j:longint;x,y:int64;t:pair;
         begin
              x:=0;y:=0;
              for i:=1 to 7 do
                  begin
                       j:=trans(c[i,1],c[i,2]);
                       x:=(x+list[j,1]) mod q;
                       y:=(y+list[j,2]) mod p;
                  end;
              t.a0:=x;t.b0:=y;
              exit(t);
         end;
procedure hashstartup;inline;
          var i:longint;
          begin
               list[0,1]:=1;list[0,2]:=1;
               for i:=1 to 25 do
                   begin
                        list[i,1]:=(list[i-1,1]*p) mod q;
                        list[i,2]:=(list[i-1,2]*q) mod p;
                   end;
          end;
procedure dfs(z,t:longint);inline;
          var i,j,k,l:longint;
          begin
               if (z-t)>4 then exit;
               if z>7 then
                  begin
                       if checkhash(hashstate) then
                          begin
                               inc(ans);
                          end;
                       exit;
                  end;
               l:=av;
               for i:=1 to l do
                   begin
                        if e[d[i,1],d[i,2]]<>1 then continue;
                        c[z,1]:=d[i,1];c[z,2]:=d[i,2];
                        e[d[i,1],d[i,2]]:=2;
                        if e[d[i,1]-1,d[i,2]]=0 then
                           begin
                                inc(av);
                                d[av,1]:=d[i,1]-1;
                                d[av,2]:=d[i,2];
                                e[d[i,1]-1,d[i,2]]:=1;
                           end;
                        if e[d[i,1]+1,d[i,2]]=0 then
                           begin
                                inc(av);
                                d[av,1]:=d[i,1]+1;
                                d[av,2]:=d[i,2];
                                e[d[i,1]+1,d[i,2]]:=1;
                           end;
                        if e[d[i,1],d[i,2]-1]=0 then
                           begin
                                inc(av);
                                d[av,1]:=d[i,1];
                                d[av,2]:=d[i,2]-1;
                                e[d[i,1],d[i,2]-1]:=1;
                           end;
                        if e[d[i,1],d[i,2]+1]=0 then
                           begin
                                inc(av);
                                d[av,1]:=d[i,1];
                                d[av,2]:=d[i,2]+1;
                                e[d[i,1],d[i,2]+1]:=1;
                           end;
                        dfs(z+1,t+a[d[i,1],d[i,2]]);
                        while av>l do
                              begin
                                   e[d[av,1],d[av,2]]:=0;
                                   d[av,1]:=0;d[av,2]:=0;
                                   dec(av);
                              end;
                        e[d[i,1],d[i,2]]:=1;
                   end;
          end;
begin
     hashstartup;
     tot:=0;head:=0;ans:=0;av:=0;
     randomize;
     fillchar(e,sizeof(e),0);
     for i:=0 to 6 do
         begin
              e[i,0]:=1;e[0,i]:=1;
              e[i,6]:=1;e[6,i]:=1;
         end;
     for i:=1 to 5 do
         begin
              for j:=1 to 5 do
                  begin
                       read(ch);
                       case upcase(ch) of
                            'H':a[i,j]:=0;
                            'J':a[i,j]:=1;
                       end;
                  end;
              readln;
         end;
     for i:=1 to 5 do
         begin
              for j:=1 to 5 do c[i-1,j]:=1;
              for j:=1 to 5 do
                  begin
                       av:=0;
                       c[1,1]:=i;c[1,2]:=j;
                       if e[i-1,j]=0 then
                          begin
                               inc(av);
                               d[av,1]:=i-1;d[av,2]:=j;
                               e[i-1,j]:=1;
                          end;
                       if e[i+1,j]=0 then
                          begin
                               inc(av);
                               d[av,1]:=i+1;d[av,2]:=j;
                               e[i+1,j]:=1;
                          end;
                       if e[i,j-1]=0 then
                          begin
                               inc(av);
                               d[av,1]:=i;d[av,2]:=j-1;
                               e[i,j-1]:=1;
                          end;
                       if e[i,j+1]=0 then
                          begin
                               inc(av);
                               d[av,1]:=i;d[av,2]:=j+1;
                               e[i,j+1]:=1;
                          end;
                       e[i,j]:=2;
                       dfs(2,a[i,j]);
                       while av>0 do
                             begin
                                  e[d[av,1],d[av,2]]:=0;
                                  d[av,1]:=0;d[av,2]:=0;
                                  dec(av);
                             end;
                       e[i,j]:=0;
                  end;
         end;
     writeln(ans);
     readln;
end.