算法导论 第六章 思考题6-3 Young氏矩阵

这题利用二叉堆维持堆性质的办法来维持Young氏矩阵的性质，题目提示中写得很清楚，不过确实容易转不过弯来。

a,b两问很简单。直接看c小问：

按照Young氏矩阵的性质，最小值肯定在左上角取得，问题在于取出最小值后如何保持矩阵的性质。可以参照max_heapify中的做法，先取出最小值，然后将矩阵左上角置为最大值，这样左上角处的元素必然导致Young氏矩阵的性质违背，于是考虑该元素右边的元素和该元素下边的元素，问题是该与右边元素交换还是与下边元素交换呢？可以发现，如果与T(右)和T(下)中较小的一个元素交换，可以使得另一元素所在的行或列恢复Young氏矩阵性质，这样就把待调整的矩阵的规模减小到了(m - 1) X n 或 m X (n - 1)。递归运行这个过程，直到待调整的矩阵为空，因为每次都将m或n减小1，直到它们都减小到零为止，可知时间复杂度为O(m + n)

 

d小问实现插入过程，还是参照二叉堆中的插入过程，把新元素插入到矩阵末尾，然后向左上角调整直到到达合适的位置。调整过程的思路其实跟c中的思路类似。这次是与新元素左边元素和上边元素比较。可以发现，如果我把新元素和T(左)、T（上）中较大的元素进行交换，可以使得另一个元素所在的行（或列）恢复Young氏矩阵性质，于是同样把待调整的矩阵规模减小到(m - 1) X n 或m X （n - 1）

 

e比较直接，extract_min需要线性时间O(n),共有n^2个元素，于是复杂度就是O(n^3)

 

f问比较难想，我折腾了好久。关键是查找位置是从矩阵的左下角开始。这位置很巧妙，如果k大于它，那它所在的列就不用找了，如果k小于它，那它所在的行就不用找了，也是逐次减小矩阵规模查找元素。

部分实现的源码如下：

#include<iostream>

#include<vector>

using namespace std;

enum class Direction{DOWN, RIGHT, UP, LEFT, OVER};

void extract_helper(vector<vector<int> > &Young, int m, int n){

	Direction d = Direction::OVER;

	int val = Young[m][n];

	if (m + 1 < Young.size() && val > Young[m + 1][n]){

		d = Direction::DOWN;

		val = Young[m + 1][n];

	}

	if (n + 1 < Young[0].size() && val > Young[m][n + 1]){

		d = Direction::RIGHT;

		val = Young[m][n + 1];

	}

	switch (d){

	case Direction::DOWN:

		swap(Young[m][n], Young[m + 1][n]);

		extract_helper(Young, m + 1, n);

		break;

	case Direction::RIGHT:

		swap(Young[m][n], Young[m][n + 1]);

		extract_helper(Young, m, n + 1);

		break;

	case Direction::OVER:

		break;

    }

	return;

}

int extract_min(vector<vector<int>> &Young){

	int min = Young[0][0];

	Young[0][0] = INT_MAX;

	int m = 0;

	int n = 0;

	extract_helper(Young, m, n);

	return min;

}



void insert_helper(vector<vector<int>> &Young, int m, int n){ 

	Direction d = Direction::OVER; 

	int val = Young[m][n];

	if (m - 1 >= 0 && val < Young[m - 1][n]){

		val = Young[m - 1][n];

		d = Direction::UP;

	}

	if (n - 1 >= 0 && val < Young[m][n - 1]){

		val = Young[m][n - 1];

		d = Direction::LEFT;

	}

	switch (d){

	case Direction::UP:

		swap(Young[m][n], Young[m - 1][n]);

		insert_helper(Young, m - 1, n);

		break;

	case Direction::LEFT:

		swap(Young[m][n], Young[m][n - 1]);

		insert_helper(Young, m, n - 1);

		break;

	case Direction::OVER:

		break;

	}

}

void insert(vector<vector<int>> &Young, int key){

	int M = Young.size();

	int N = Young[0].size();

	Young[M - 1][N - 1] = key;

	int m = M - 1;

	int n = N - 1;

	insert_helper(Young, m, n);

}

void Young_sort(vector<vector<int>> &Young, vector<int>& result){

	while (Young[0][0] != INT_MAX){

		int key = extract_min(Young);

		result.push_back(key);

	}

}