/*
* 对当前格子的4种覆盖方法构成板块的3个格子的相对位置(dy,dx)
* 因为假定从最左上的格子开始覆盖。
*/
const int coverType[4][3][2] =
{
{{0,0},{1,0},{0,1}},
{{0,0},{0,1},{1,1}},
{{0,0},{1,0},{1,1}},
{{0,0},{1,0},{1,-1}}
};
vector< vector<int> > board(4);
/*
* 把board的格子(y,x)用第type种方法进行覆盖或删除已覆盖的板块。
* delta=1表示用板块覆盖,delta=-1则删除已覆盖的板块
* 如果不能正常覆盖(超出游戏板的边界,重叠、覆盖黑色格子)时,返回false值
*/
bool set(vector<vector<int> >& board, int y, int x, int type, int delta)
{
bool ok = true;
for(int i = 0; i<3; i++)
{
const int ny = y+coverType[type][i][0];
const int nx = x+coverType[type][i][1];
if(ny<0 || ny>=board.size() || nx<0 || nx>=board[0].size())
ok = false;
else if((board[ny][nx]+=delta)>1)
ok = false;
}
return ok;
}
/*
- 返回覆盖board中保存着的所有空格的方法总数。
- board[j][i]=1表示已被覆盖的格子或黑色格子
- board[j][i]=0表示未被覆盖的白色格子
*/
int cover(vector<vector<int> >& board)
{
int y = -1, x = -1;
for(int i = 0; i<board.size(); i++)
{
for(int j = 0; j<board[i].size(); j++)
if(board[i][j] ==0)
{
y = i;
x = j;
break;
}
if(y!=-1)
break;
}
//初始部分:已覆盖所有的白色盒子,则返回1
if(y==-1)
return 1;
int ret = 0;
for(int type = 0; type<4; type++)
{
//如果能以type的形式覆盖board[y][x],就进行递归调用。
if(set(board, y, x,type,1))
ret+=cover(board);
set(board, y,x,type,-1);
}
return ret;
用link[i][j]存储i和j之间的连接关系,r[i][j]表示第i天j结点的路径数
初始化
R[init][0]=1;
For(i=1;i<=d;i++)
For(j=0;j<n;j++)
{
For(k=0;k<n;k++)
{
r[j][i]+=r[k][i-1]*link[j][k];
}
}
Double han[n];
Int num=0;
For(i=0;i<n;i++)
{
num+=r[i][d];
}
For(i=0;i<n;i++)
{
Han[i]=r[i][d]/num;
}
哈夫曼树,每次都选最小的两个
for(i=0;i<n-1;i++)
{
sort(length+i,length+n);
{
length[i+1]=length[i]+length[i+1];
}
}
return length[n-1];
Bool find(char **s,char a,char b)
{
}
Void backtrack(int t)
{
If(t==26) {
For(int i=0;i<26;i++)
{
Bestx[i]=x[i];
}
Return;
}
For(int i=t;j<26;j++)
{
If(find(x[t].x[i],s) //如果满足x[i]在x[t]之前
{
Swap(x[i],x[t]);
Backtrack(t+1);
Swap(x[i],x[t]);
}
return temp.depth;