/*
ural1519
求经过全部可行点的哈密顿回路的个数
括号匹配法,转移有点复杂,可是时间空间比較小
*/
#include<cstdio>
#include<cstring>
#include<string>
#include<iostream>
#include<algorithm>
#include<cmath>
#include<map>
#include<queue>
#define LL long long
using namespace std;
const int maxn=30001;
int n,m,now,pre;
int mov[13]={0,2,4,6,8,10,12,14,16,18,20,22,24};//依据进制选择移位距离
char gp[20][20],fx,fy;//存图,最后一个可行点的坐标
inline int getbit(LL st,int k){ return (st>>mov[k])&3;}//获得第k位的状态
inline int pybit(LL st,int k){ return st<<mov[k];} //平移k位
inline LL clrbit(LL st,int i,int j){ return st&(~(3<<mov[i]))&(~(3<<mov[j]));}//清空第i位和第j位
struct node//状态离散hash
{
int head[maxn],next[maxn],size;
LL sum[maxn],sta[maxn];//保存所求和及状态
void clear()
{
memset(head,-1,sizeof(head));
memset(sum,0,sizeof(sum));
size=0;
}
void push(LL st,const LL v)
{
LL hash=st%maxn;
for(int i=head[hash];i>=0;i=next[i])
{
if(sta[i]==st)
{
sum[i]+=v;
return;
}
}
sta[size]=st,sum[size]=v;
next[size]=head[hash],head[hash]=size++;
}
}dp[2];
inline int fl(LL st,int pos)//从左往右找到和当前pos位置匹配的右括号
{
int cnt=1;
for(int i=pos+1;i<=m;i++)
{
int k=getbit(st,i);
if(k==1) cnt++;
else if(k==2) cnt--;
if(!cnt) return i;
}
}
inline int fr(LL st,int pos)//从右往左找到和当前pos位置匹配的左括号
{
int cnt=1;
for(int i=pos-1;i>=0;i--)
{
int k=getbit(st,i);
if(k==2) cnt++;
else if(k==1) cnt--;
if(!cnt) return i;
}
}
void DP(int x,int y,int k)//每种状态的转移,依据须要改动
{
int l=getbit(dp[pre].sta[k],y-1);
int up=getbit(dp[pre].sta[k],y);
LL st=clrbit(dp[pre].sta[k],y-1,y);
LL v=dp[pre].sum[k];
if(!l&&!up)
{
if(gp[x][y]=='*')
{
dp[now].push(st,v);
return;
}
if(x<n&&y<m&&gp[x+1][y]=='.'&&gp[x][y+1]=='.')
dp[now].push(st|pybit(1,y-1)|pybit(2,y),v);
}
else if(!l||!up)
{
int e=l+up;
if(x<n&&gp[x+1][y]=='.')
dp[now].push(st|pybit(e,y-1),v);
if(y<m&&gp[x][y+1]=='.')
dp[now].push(st|pybit(e,y),v);
}
else if(l==1&&up==1)
dp[now].push(st^pybit(3,fl(st,y)),v);
else if(l==2&&up==2)
dp[now].push(st^pybit(3,fr(st,y-1)),v);
else if(l==2&&up==1)
dp[now].push(st,v);
else if(x==fx&&y==fy)
dp[now].push(st,v);
}
LL solve()
{
dp[0].clear();//初状态
dp[0].push(0,1);
now=0,pre=1;
for(int i=1;i<=n;i++)//逐格逐状态枚举
{
pre=now,now^=1,dp[now].clear();
for(int k=0;k<dp[pre].size;k++)//轮廓线下移对齐
dp[now].push(pybit(dp[pre].sta[k],1),dp[pre].sum[k]);
for(int j=1;j<=m;j++)
{
pre=now,now^=1,dp[now].clear();
for(int k=0;k<dp[pre].size;k++)
{
DP(i,j,k);
}
}
}
for(int i=0;i<dp[now].size;i++)//寻找终于答案
if(dp[now].sta[i]==0)
return dp[now].sum[i];
return 0;
}
int main()
{
while(~scanf("%d%d",&n,&m))
{
for(int i=1;i<=n;i++)//都是从1開始的
scanf("%s",&gp[i][1]);
fx=0;
for(int i=n;i>0&&!fx;i--)//寻找最后一个可行点
{
for(int j=m;j>0&&!fx;j--)
{
if(gp[i][j]=='.')
fx=i,fy=j;
}
}
if(fx==0) puts("0");
else cout<<solve()<<endl;
}
return 0;
} /*
ural1519
求经过全部可行点的哈密顿回路的个数
最小表示法
转移简单,时间空间较大
*/
#include<cstdio>
#include<string>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<cmath>
#define LL long long
using namespace std;
const int maxn=30001,inc=3,bit=7;//3位二进制以及111的表示
int n,m,now,pre,code[20],bin[20],res[20];//用来表示状态的每一位的数值
char gp[20][20],fx,fy;//图和最后的可行点
struct node//离散化hash
{
int head[maxn],next[maxn],size;
LL sum[maxn],sta[maxn];
void clear()
{
memset(head,-1,sizeof(head));
size=0;
}
void push(LL st,const LL v)
{
LL hash=st%maxn;
for(int i=head[hash];i>=0;i=next[i])
{
if(sta[i]==st)
{
sum[i]+=v;
return ;
}
}
sta[size]=st,sum[size]=v;
next[size]=head[hash],head[hash]=size++;
}
}dp[2];
inline LL encode(int m)//将code转换成状态
{
LL st=0;
int cnt=1;
memset(bin,-1,sizeof(bin));
bin[0]=0;
for(int i=m;i>=0;i--)
{
if(bin[code[i]]==-1)
bin[code[i]]=cnt++;
code[i]=bin[code[i]];
st<<=inc;
st|=code[i];
}
return st;
}
inline void decode(LL st,int m)//将状态转换成code
{
for(int i=0;i<=m;i++)
{
code[i]=st&bit;
st>>=inc;
}
}
void DP(int x,int y,int k)//dp详细情况详细分析
{
decode(dp[pre].sta[k],m);
int l=code[y-1];
int up=code[y];
code[y-1]=code[y]=0;
memcpy(res,code,sizeof(code));
LL v=dp[pre].sum[k];
if(!l&&!up)
{
if(gp[x][y]=='*')
dp[now].push(encode(m),v);
else if(x<n&&y<m&&gp[x+1][y]=='.'&&gp[x][y+1]=='.')
{
code[y]=code[y-1]=bit;
dp[now].push(encode(m),v);
}
}
else if(!l||!up)
{
int e=l+up;
if(x<n&&gp[x+1][y]=='.')
{
code[y-1]=e;
dp[now].push(encode(m),v);
memcpy(code,res,sizeof(res));
}
if(y<m&&gp[x][y+1]=='.')
{
code[y]=e;
dp[now].push(encode(m),v);
}
}
else if(l!=up)
{
for(int i=0;i<=m;i++)
if(code[i]==up)
code[i]=l;
dp[now].push(encode(m),v);
}
else if(x==fx&&y==fy)
dp[now].push(encode(m),v);
}
LL solve()
{
dp[0].clear();//初始化状态
dp[0].push(0,1);
now=0,pre=1;
for(int i=1;i<=n;i++)//逐格逐状态枚举转移
{
pre=now,now^=1,dp[now].clear();
for(int k=0;k<dp[pre].size;k++)//轮廓线行转移
dp[now].push(dp[pre].sta[k]<<inc,dp[pre].sum[k]);
for(int j=1;j<=m;j++)
{
pre=now,now^=1,dp[now].clear();
for(int k=0;k<dp[pre].size;k++)
{
DP(i,j,k);
}
}
}
for(int i=0;i<dp[now].size;i++)
if(dp[now].sta[i]==0)
return dp[now].sum[i];
return 0;
}
int main()
{
while(~scanf("%d%d",&n,&m))
{
for(int i=1;i<=n;i++)//都是从1開始
scanf("%s",&gp[i][1]);
fx=fy=0;
for(int i=n;i>0&&!fx;i--)//寻找终于的位置
for(int j=m;j>0&!fx;j--)
if(gp[i][j]=='.')
fx=i,fy=j;
if(fx==0)puts("0");
else cout<<solve()<<endl;
}
} /*
单插头路径
zoj 3213 Beautiful Meadow
求随意可行路径所能得到的最优值,格子不须要全部走.
起始点是可行点的随意点,所以须要单插头(3),由于情况较多,所以作为单插头模板
*/
#include<cstdio>
#include<cstring>
#include<string>
#include<cmath>
#include<algorithm>
#include<iostream>
#define LL long long
using namespace std;
const int maxn=30001,INF=1<<30;
int mov[10]={0,2,4,6,8,10,12,14,16,18};
struct node
{
int size,head[maxn],next[maxn];
LL sta[maxn],sum[maxn];
void clear()
{
memset(head,-1,sizeof(head));
size=0;
}
void push(LL st,const LL v)
{
LL hash=st%maxn;
for(int i=head[hash];i>=0;i=next[i])
{
if(sta[i]==st)
{
sum[i]=max(sum[i],v);
return ;
}
}
sta[size]=st,sum[size]=v;
next[size]=head[hash],head[hash]=size++;
}
}dp[2];
inline int getbit(LL st,int k){return 3&(st>>mov[k]);}
inline int pybit(LL st,int k){return st<<mov[k];}
inline int clrbit(LL st,int a,int b){return st&(~(3<<mov[a]))&(~(3<<mov[b]));}
int fl(LL st,int k,int m)
{
int cnt=1;
for(int i=k+1;i<=m;i++)
{
int e=getbit(st,i);
if(e==2) cnt--;
else if(e==1) cnt++;
if(!cnt) return i;
}
}
int fr(LL st,int k)
{
int cnt=1;
for(int i=k-1;i>=0;i--)
{
int e=getbit(st,i);
if(e==2) cnt++;
else if(e==1) cnt--;
if(!cnt) return i;
}
}
int count(LL st)//统计单插头的个数
{
int cnt=0;
while(st)
{
if(getbit(st,0)==3)
cnt++;
st>>=2;
}
return cnt;
}
int n,m,gp[20][20];
LL DP()
{
LL ans=-INF;
dp[0].clear();
dp[0].push(0,0);
int now=0,pre=1;
for(int i=1;i<=n;i++)
{
pre=now,now^=1,dp[now].clear();
for(int j=0;j<dp[pre].size;j++)
dp[now].push(dp[pre].sta[j]<<2,dp[pre].sum[j]);
for(int j=1;j<=m;j++)
{
if(gp[i][j]!=0) ans=max(ans,(LL)gp[i][j]);
pre=now,now^=1,dp[now].clear();
for(int k=0;k<dp[pre].size;k++)
{
LL l=getbit(dp[pre].sta[k],j-1);
LL up=getbit(dp[pre].sta[k],j);
LL st=clrbit(dp[pre].sta[k],j,j-1);
LL v=dp[pre].sum[k]+gp[i][j];
if(!l&&!up)
{
dp[now].push(st,dp[pre].sum[k]);
if(gp[i][j]==0)
continue;
if(i<n&&j<m&&gp[i+1][j]&&gp[i][j+1])
dp[now].push(st|pybit(1,j-1)|pybit(2,j),v);
if(count(st)<=1)
{
if(i<n&&gp[i+1][j])
dp[now].push(st|pybit(3,j-1),v);
if(j<m&&gp[i][j+1])
dp[now].push(st|pybit(3,j),v);
}
}
else if(!l||!up)
{
int e=l+up;
if(i<n&&gp[i+1][j])
dp[now].push(st|pybit(e,j-1),v);
if(j<m&&gp[i][j+1])
dp[now].push(st|pybit(e,j),v);
if(e!=3&&count(st)<=1)
{
if(e==1) dp[now].push(st|pybit(3,fl(st,j,m)),v);
else dp[now].push(st|pybit(3,fr(st,j-1)),v);
}
else if(e==3&&st==0)
ans=max(ans,v);
}
else if(l==up)
{
if(l==1)
dp[now].push(st^pybit(3,fl(st,j,m)),v);
if(l==2)
dp[now].push(st^pybit(3,fr(st,j-1)),v);
if(l==3)
ans=max(ans,v);
}
else if(l==2&&j==1) dp[now].push(st,v);
else if(l==3||up==3)
{
int e=l==3?up:l;
if(e==1)
dp[now].push(st|pybit(3,fl(st,j,m)),v);
if(e==2)
dp[now].push(st|pybit(3,fr(st,j-1)),v); }
}
}
}
if(ans==-INF)
ans=0;
return ans;
}
int main()
{
int T;
scanf("%d",&T);
while(T--)
{
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++)
scanf("%d",&gp[i][j]);
cout<<DP()<<endl;
}
return 0;
} /*
广义路径
uva10572 black&white
求将一个棋盘染色,仅仅能染黑和白,同样颜色必须联通,并且不能出现4格同颜色田字型
的方案数和打印当中一种方案.
最小表示法,两条轮廓线,一条表示联通性(m),还有一条表示颜色状态(m+1).
是____————这样的状态,不是之前的折线型.
依据颜色来转移联通性.
*/
#include<cstdio>
#include<cstring>
#include<string>
#include<cmath>
#include<iostream>
#include<algorithm>
#define LL long long
using namespace std;
const int maxn=10007,bit=7,inc=3;
int pre[9][9][maxn];//指向前一个状态
bool res[9][9][maxn];//记录当前状态那一格的颜色
int bin[20],code[20];
struct node
{
int size,head[maxn],next[maxn];
LL sta[maxn],clo[maxn],sum[maxn];
void clear()
{
memset(head,-1,sizeof(head));
size=0;
}
void push(LL st,const LL v,LL cs,int x,int y,bool cl,int k)
{
int hash=((st*13)+cs)%maxn;
for(int i=head[hash];i>=0;i=next[i])
{
if(sta[i]==st&&clo[i]==cs)
{
sum[i]+=v;
return ;
}
}
sta[size]=st,clo[size]=cs,sum[size]=v;
res[x][y][size]=cl,pre[x][y][size]=k;
next[size]=head[hash],head[hash]=size++;
}
}dp[2];
LL encode(int m)//注意从0開始,由于可能有m个不同颜色的插头
{
LL st=0,cnt=0;
memset(bin,-1,sizeof(bin));
for(int i=m-1;i>=0;i--)
{
if(bin[code[i]]==-1)
bin[code[i]]=cnt++;
code[i]=bin[code[i]];
st<<=inc;
st|=code[i];
} return st;
}
void decode(LL st,int m)
{
for(int i=0;i<m;i++)
{
code[i]=st&bit;
st>>=inc;
}
}
int n,m,now,old;
char gp[20][20];
bool check(LL cs,int x,int y,int m,int nc)//检查当前状态是否是两个状态的分界线
{
int cnt=0,cnt1=0;
for(int i=0;i<m;i++)
{
if(code[i]==code[y])
cnt++;
if(((cs>>i)&1)==(nc^1))
cnt1++;
}
if(cnt==1)
{
if(cnt1>1)
return false;
char ch=nc==1?'o':'#';
for(int i=x-1;i<n;i++)
for(int j=i==x-1?y+1:0;j<m;j++)
{
if(gp[i][j]==ch)
return false;
if(i+1<n&&j+1<m)
return false;
}
}
return true;
}
void DP(int x,int y,int nc)
{
for(int k=0;k<dp[old].size;k++)
{
bool l=y==0?0:((dp[old].clo[k]>>(y-1))&1)==nc;
bool up=x==0?0:((dp[old].clo[k]>>y)&1)==nc;
bool lp=(x==0||y==0)?0:((dp[old].clo[k]>>m)&1)==nc;
decode(dp[old].sta[k],m);
if(x&&!up&&!check(dp[old].clo[k],x,y,m,nc))
continue;
if(!l&&!up&&!lp)
code[y]=10;
else if(l&&!up&&!lp)
code[y]=code[y-1];
else if(!l&&up&&!lp)
code[y]=code[y];
else if(!lp&&l&&up)
{
if(code[y-1]!=code[y])
{
for(int i=0,id=code[y];i<m;i++)
if(code[i]==id)
code[i]=code[y-1];
}
}
else if(lp&&!up&&!l)
{
if(x==n-1&&y==m-1)
continue;
code[y]=10;
}
else if(lp&&l&&!up)
code[y]=code[y-1];
else if(lp&&up&&!l)
code[y]=code[y];
else continue;
LL cs=dp[old].clo[k]&(~(1<<y))&(~(1<<m));
if(nc) cs|=1<<y;
if((up==0&&nc==0)||(up==1&&nc==1)) cs|=1<<m;
dp[now].push(encode(m),dp[old].sum[k],cs,x,y,nc,k);
}
}
void slove()
{
dp[0].clear();
dp[0].push(0,1,0,n,m,0,-1);
now=0,old=1;
for(int i=0;i<n;i++)
for(int j=0;j<m;j++)
{
old=now,now^=1,dp[now].clear();
if(gp[i][j]!='#')
DP(i,j,0);
if(gp[i][j]!='o')
DP(i,j,1);
}
int flag=-1,ans=0;
for(int i=0;i<dp[now].size;i++)//统计合法状态
{
decode(dp[now].sta[i],m);
int cnt=0;
memset(bin,-1,sizeof(bin));
for(int j=0;j<m;j++)
{
if(bin[code[j]]==-1)
bin[code[j]]=cnt++;
}
if(cnt<=2)
{
flag=i;
ans+=dp[now].sum[i];
}
}
//打印路径
if(flag==-1)
puts("0\n");
else
{
printf("%d\n",ans);
for(int i=n-1;i>=0;i--)
for(int j=m-1;j>=0;j--)
{
gp[i][j]=res[i][j][flag]==0?'o':'#';
flag=pre[i][j][flag];
}
for(int i=0;i<n;i++)
{
for(int j=0;j<m;j++)
printf("%c",gp[i][j]);
puts("");
}
puts("");
}
}
int main()
{
int T;
scanf("%d",&T);
while(T--)
{
scanf("%d%d",&n,&m);
for(int i=0;i<n;i++)
{
scanf("%s",gp[i]);
}
slove();
}
return 0;
}