zoj3256

好题，由m的范围知道这肯定是矩阵乘法加速插头dp，关键是怎么写

以往插头dp常用逐格递推，而这道题要求整行逐列递推

这样我们才能构造转移矩阵。

我们可以通过假象一个第0列来将路径转化为回路问题

逐列递推依然使用最小表示法，维护这一列每个格子向右的插头的连通性（最小表示法）

我们可以通过已知状态不断扩展出新的状态（初始显然只有无右插头和顶部底部有右插头两种情况）

对于一个已知列插头状态，我们穷举下一列每一个格子是否有插头，就知道了下一列每个格子是否有左插头和右插头

由于一个格子有且仅有两个插头，因此我们就确定了这一列的情况从而可以不断的扩展出新的合法状态

而最终合法状态不会超过150，接下来矩阵快速幂即可

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

 using namespace std;
 typedef long long ll;
 const int mo=;
 const int has=;
 int b[],v[],n,m,t;
 struct node
 {
     int len,st[],p[has],nex[];
     void clr()
     {
         len=;
         memset(p,,sizeof(p));
     }
     int push(int nw)
     {
         int x=nw%has;
         for (int i=p[x]; i>-; i=nex[i])
             if (st[i]==nw) return i;
         st[++len]=nw;
         nex[len]=p[x]; p[x]=len;
         return len;
     }
 } f;

 struct mat{
     int a[][];
     friend mat operator *(mat a,mat b)
     {
         mat c;
         for (int i=; i<=t; i++)
             for (int j=; j<=t; j++)
             {
                 ll s=;
                 for (int k=; k<=t; k++) s+=(ll)a.a[i][k]*b.a[k][j];
                 c.a[i][j]=s%mo;
             }
         return c;
     }
 } ans,c;

 void get(int st)
 {
     for (int i=n-; i>=; i--)
     {
         b[i]=st&;
         st>>=;
     }
 }

 int put()
 {
     memset(v,,sizeof(v)); v[]=;
     int t=,st=;
     for (int i=; i<n; i++)
     {
         if (v[b[i]]==-) v[b[i]]=++t;
         st<<=;
         st|=v[b[i]];
     }
     return st;
 }

 bool check(int cur,int nw)
 {
     get(cur);
     int pre=,k=,t=n;
     for (int i=; i<n; i++)
     {
         int x=(nw>>i)&;
         if (pre==)
         {
             if (!b[i]&&!x) return ;
             if (b[i]&&x) continue;
             if (b[i]) {pre=b[i];b[i]=;}
             else pre=-;
             k=i;
         }
         else {
             if (b[i]&&x) return ;
             if (!b[i]&&!x) continue;
             if (b[i])
             {
                 if (b[i]==pre&&(nw!=||i!=n-)) return ;
                 if (pre>)
                 {
                     for (int r=; r<n; r++)
                         if (i!=r&&b[r]==b[i]) b[r]=pre;
                     b[i]=;
                 }
                 else {b[k]=b[i],b[i]=;}
             }
             else {
                 if (pre>) b[i]=pre;
                 else b[i]=b[k]=++t;
             }
             pre=;
         }
     }
     return pre==;
 }

 void quick(int n)
 {
     memset(ans.a,,sizeof(ans.a));
     for (int i=; i<=t; i++) ans.a[i][i]=;
     while (n)
     {
         if (n&) ans=ans*c;
         c=c*c;
         n>>=;
     }
 }

 int main()
 {
     while (scanf("%d%d",&n,&m)!=EOF)
     {
         memset(b,,sizeof(b));
         memset(c.a,,sizeof(c.a));
         f.clr();
         f.push();
         b[]=b[n-]=; f.push(put());
         for (int i=; i<=f.len; i++)
             for (int j=; j<(<<n); j++)
                 if (check(f.st[i],j))
                 {
                     int k=f.push(put());
                     c.a[i][k]=;
                 }
         t=f.len;
         quick(m);
         if (ans.a[][]==) puts("Impossible");
         else printf("%d\n",ans.a[][]);
     }
 }