湖南大学17年算法设计与分析期末试题

/*
 * 对当前格子的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;