算法导论思考题6-3（Young氏矩阵）

思考题6-3（Young氏矩阵）在一个m×nm\times nm×n的Young氏矩阵（Young tableau）中，每一行的数据都是从左到右排序的，每一列的数据都是从上到下排列的。Young氏矩阵中也会存在一些为∞\infin∞的数据项，表示那些不存在的数据。因此，Young氏矩阵可以用来村出r≤mnr \leq mnr≤mn个有限的数。

a. 画出一个包含元素{9，16，3，2，4，8，5，14，12}\{9，16，3，2，4，8，5，14，12\}{9，16，3，2，4，8，5，14，12}的4×44 \times 44×4Young氏矩阵。

第一题比较简单，只要满足插入和每行每列都是非递减就行。
下面示例：

[258∞3914∞41216∞∞∞∞∞]\begin{bmatrix} 2 & 5 & 8 & \infin \\ 3 & 9 & 14 & \infin \\ 4 & 12 & 16 & \infin \\ \infin & \infin & \infin & \infin \\ \end{bmatrix} ⎣⎢⎢⎡234∞5912∞81416∞∞∞∞∞⎦⎥⎥⎤
采用不同规则最终效果不同，只要满足其定义即可。

在后面的实现中我们为了简化边界检查，我们实际的矩阵实现行数和列数要比实际大2，Y的存储位置为[1,1][1,1][1,1]到[M,N][M,N][M,N]。
4×44 \times 44×4的Young氏矩阵的实际存储空间。
[−∞−∞−∞−∞−∞−∞−∞258∞∞−∞3914∞∞−∞41216∞∞−∞∞∞∞∞∞]\begin{bmatrix} -\infin& -\infin & -\infin & -\infin & -\infin &-\infin \\ -\infin& 2 & 5 & 8 & \infin & \infin\\ -\infin & 3 & 9 & 14 & \infin & \infin \\ -\infin & 4 & 12 & 16 & \infin & \infin \\ -\infin & \infin & \infin & \infin & \infin & \infin\\ \end{bmatrix} ⎣⎢⎢⎢⎢⎡−∞−∞−∞−∞−∞−∞234∞−∞5912∞−∞81416∞−∞∞∞∞∞−∞∞∞∞∞⎦⎥⎥⎥⎥⎤
采取这种方案，当达到边界时，不会越界。

b. 对于一个m×nm \times nm×n的Young氏矩阵来说，请证明：如果Y[1,1]=∞Y[1,1]=\infinY[1,1]=∞，则YYY为空；如果Y[m,n]<∞Y[m,n]< \infinY[m,n]<∞，则YYY为满（即包含mnmnmn个元素）。

这道题比较简单，根据定义就可以快速得出。
证明：根据Young氏矩阵的定义，Y[i,j]≤Y[i+k1,j+k2]，∀i,i+k1≤mY[i,j] \leq Y[i+k1,j+k2]，\forall i,i+k1 \leq mY[i,j]≤Y[i+k1,j+k2]，∀i,i+k1≤m 且 j,j+k2≤nj,j+k2 \leq nj,j+k2≤n。即Y[1,1]Y[1,1]Y[1,1]为矩阵的最小值，Y[m,n]Y[m,n]Y[m,n]为最大值。

如果Y[1,1]=∞Y[1,1]=\infinY[1,1]=∞，则矩阵其他元素均为∞\infin∞，即为空。若Y[m,n]<∞Y[m,n]< \infinY[m,n]<∞，则其他元素均小于∞\infin∞，故YYY为满。

c. 请给出一个在m×nm \times nm×n Young氏矩阵上时间复杂度为O(m+n)O(m+n)O(m+n)的EXTRACT-MIN的算法实现。你的算法可以考虑使用一个递归过程，它把一个规模为m×nm \times nm×n的问题分解为规模为(m−1)×n(m-1) \times n(m−1)×n或m×(n−1)m \times (n-1)m×(n−1)的子问题（提示：考虑使用MAX-HEAPFY）。这里，定义T§用来表示在任意m×nm \times nm×n的Young氏矩阵上的时间复杂度，其中p=m+np = m+np=m+n。给出并求解T(p)T(p)T(p)的递归表达式，其结果为O(m+n)O(m+n)O(m+n)。

这个实现上也比较简单。如下：

在YYY非空时，将Y[1,1]Y[1,1]Y[1,1]用∞\infin∞替换

然后重新调整∞\infin∞的位置，记当前位置在Y[i,j]Y[i,j]Y[i,j]，让其满足定义。

取其下面元素Y[i+1,j]Y[i+1,j]Y[i+1,j]和右边元素Y[i,j+1]Y[i,j+1]Y[i,j+1]的最小值mixmixmix，若min≠∞min \neq \infinmin̸=∞交换它和∞\infin∞的位置。
当达到矩阵边界，或min=∞min = \infinmin=∞，此时结束。

下面是伪代码：

extractMin(Y)if(!Y.empty())//非空Y[1][1] = INF;//第一个元素置为INFMinFixup(Y,Loc{1,1});//调整MinFixup(Young,loc)t = Y[loc.x][loc.y]doif(Y[loc.x][loc.y+1] < Y[loc.x+1][loc.y])//获取下方和右边小的数的位置small = {loc.x,loc.y+1}elsesmall = {loc.x+1,loc.y}if(Y[small.x][small.y] < t)Y[loc.x][loc.y] = Y[small.x][small.y]loc = smallelse breakwhile(true)Y[loc.x][loc.y] = t

该过程相当于一个棋子从左上角向右下方行走，每次交换后i=i+1i=i+1i=i+1或j=j+1j=j+1j=j+1，最多交换m+nm+nm+n次，总是时间复杂度为O(m+m)O(m+m)O(m+m)。

d. 是说明如何在O(m+n)O(m+n)O(m+n)的时间内，将一个元素插入到一个未满的m×nm \times nm×n的Young氏矩阵中。

类似二叉堆的插入过程，我们将新的元素放置在矩阵的最后一个位置Y[m,n]Y[m,n]Y[m,n]，类似题目c相反，让它与上面的元素Y[m−1,n]Y[m-1,n]Y[m−1,n]或左边的元素Y[m,n−1]Y[m,n-1]Y[m,n−1]比较，取它们的最大值maxmaxmax，若max≤Y[m,n]max\leq Y[m,n]max≤Y[m,n]，那么此时满足，否则，取用maxmaxmax与它交换。直到达到达到边界或满足Young氏矩阵的定义。

下面是伪代码

insert(Y,x)if(!Y.full())Y[M][N] = xMaxFixup(Loc{M,N});MaxFixup(Y,loc)t = Y[loc.x][loc.y]doif(Y[loc.x][loc.y-1] < Y[loc.x-1][loc.y])lager = {loc.x,loc.y-1}elsesmall = {loc.x-1,loc.y}if(Y[lager.x][lager.y] > t)Y[loc.x][loc.y] = Y[lager.x][lager.y]loc = lagerelsebreakwhile(true)Y[loc.x][loc.y] = t

e. 在不用其他排序算法的情况下，是说明如何利用一个n×nn \times nn×n的Young氏矩阵在O(n3)O(n^3)O(n3)时间内将n2n^2n2个数进行排列。

将n×nn \times nn×n个元素插入Young氏矩阵中，花费O(n3)O(n^3)O(n3)，然后将他们意义取出即可，也是花费O(n3)O(n^3)O(n3)。故总的时间复杂度为O(n3)O(n^3)O(n3)。

f. 设计一个时间复杂度为O(m+n)O(m+n)O(m+n)的算法，它可以用来判断一个给定的数是否存储在m×nm \times nm×n的Young氏矩阵内。

查找一个数xxx，我们可以从左下角或右上角开始搜索。不能从左上角或右下角进行，例如左上角来说，当我们查找点元素大于Y[1,1]Y[1,1]Y[1,1]时，若往右或下均是大于xxx时，我们不知道往那个方向，有可能选择方向错误后，后面需要回过头来找尝试另一方向，花费额外时间。

但是如果我们从左下角开始查找，如果x<Y[m,1]x < Y[m,1]x<Y[m,1]，那么我们往上继续查找，若X>T[m,1]X > T[m,1]X>T[m,1]，那么我们往右边查找。这样可以在O(m+n)O(m+n)O(m+n)时间内完成。当然，从右上角开始也是一样的效果。

下面从左下角查找的伪代码：

search(Y,t)//查找tx = M,y=1while(Y[x][y] != INF && Y[x][y] != -INF)//未到达边界if(Y[x][y] == t)return trueelse if(t < Y[x][y])x = x + 1elsey = y - 1return false

代码实现

#include<iostream>
#include<cassert>
#include<array>
#include<ctime>
#include<random>
using namespace std;
const int INF=0x3f3f3f3f;
struct Loc//位置定义
{unsigned x,y;
};
template<typename T,unsigned M,unsigned N=M>
class Youngtableau{public:Youngtableau();//构造函数void insert(const T&x);//插入void extractMin();//删除bool empty() {return matrix[1][1]==INF;}//判空bool full() {return matrix[M][N]!=INF;}//判满T top() {return matrix[1][1];}//返回首元素bool search(const T&t);//查找void print();//输出
private:void MinFixup(Loc loc);//调整函数void MaxFixup(Loc loc);
private://底层存储//为了方便边界处理，行列多开2个空间，方便处理边界array<array<T,N+2>,M+2> matrix;Loc ins;//插入位置[M,N]
};
/*Functions Definition*/
template<typename T,unsigned M,unsigned N>
Youngtableau<T,M,N>::Youngtableau():ins({M,N})
{matrix[0].fill(-INF);matrix[M+1].fill(INF);for(int i=1;i<matrix.size();++i){matrix[i][0]=-INF;for(int j=1;j<matrix[i].size();++j)matrix[i][j]=INF;}
}
template<typename T,unsigned M,unsigned N>
void Youngtableau<T,M,N>::print(){for(int i=1;i<=M;++i){for(int j=1;j<=N;++j){if(matrix[i][j]!=INF)cout << matrix[i][j] << " ";elsecout << "INF ";}       cout << endl;}}
template<typename T,unsigned M,unsigned N>
void Youngtableau<T,M,N>::insert(const T&x)
{if(!full()){matrix[ins.x][ins.y]=x;MaxFixup(ins);}
}
template<typename T,unsigned M,unsigned N>
void Youngtableau<T,M,N>::extractMin()
{if(!empty()){matrix[1][1]=INF;MinFixup(Loc{1,1});}
}
template<typename T,unsigned M,unsigned N>
bool Youngtableau<T,M,N>::search(const T&t)
{int x=M,y=1;while(matrix[x][y]!=INF&&matrix[x][y]!=-INF)//边界检查{if(t==matrix[x][y])return true;else if(t<matrix[x][y])--x;else++y;}return false;
}
template<typename T,unsigned M,unsigned N>
void Youngtableau<T,M,N>::MaxFixup(Loc loc){T t=matrix[loc.x][loc.y];Loc lager;do{if(matrix[loc.x][loc.y-1]>matrix[loc.x-1][loc.y])lager={loc.x,loc.y-1};elselager={loc.x-1,loc.y};if(matrix[lager.x][lager.y]>t){matrix[loc.x][loc.y]=matrix[lager.x][lager.y];loc=lager;}elsebreak;}while(true);matrix[loc.x][loc.y]=t;
}
template<typename T,unsigned M,unsigned N>
void Youngtableau<T,M,N>::MinFixup(Loc loc){T t=matrix[loc.x][loc.y];Loc small;do{if(matrix[loc.x][loc.y+1]<matrix[loc.x+1][loc.y])small={loc.x,loc.y+1};elsesmall={loc.x+1,loc.y};if(matrix[small.x][small.y]<t){matrix[loc.x][loc.y]=matrix[small.x][small.y];loc=small;}elsebreak;}while(true);matrix[loc.x][loc.y]=t;
}
template<unsigned M,unsigned N=M>
void Youngtableau_test(Youngtableau<int,M,N>&matrix)
{   static default_random_engine e(time(nullptr));static uniform_int_distribution<int> d(100,999);//等概率生成3位的随机整数cout << "Before insert" << endl;matrix.print();int i=0;while(i<M*N){matrix.insert(d(e));i++;}cout << "After insert" << endl;matrix.print();cout << "\nInput the number to check it if in the Young tableau,(-1 to stop):\n";while(cin >> i && i!=-1){cout << boolalpha << matrix.search(i) << endl;}int pre=-INF;while(!matrix.empty()){int t=matrix.top();assert(pre<=t);//不满足非递减终止pre=t;matrix.extractMin();}cout << "After delete" << endl;matrix.print();
}
int main()
{Youngtableau<int,5,10> matrix;Youngtableau_test(matrix);return 0;
}