[array] leetcode

leetcode-54. Spiral Matrix - Medium

descrition

GGiven a matrix of m x n elements (m rows, n columns), return all elements of the matrix in spiral order.

For example,
Given the following matrix:

[
 [ 1, 2, 3 ],
 [ 4, 5, 6 ],
 [ 7, 8, 9 ]
]
You should return [1,2,3,6,9,8,7,4,5].

解析

基本思路是按照规则一个个的取数，两份方法的区别在于处理的技巧不同。

方法 1:

小技巧（si,sj）,(ei, ej)，对角线可以唯一确定一个矩阵。循环获取结果，每次循环获取当前最外层的一圈数字。

从左到右，matrix[si][sj,...,ej]
从上到下，matrix[si,...,ej][ej]
从右到左，matrix[ei][ej-1,...,sj]
从下到上，matrix[ei-1,...,si-1][sj]

实现如代码所示，注意边界条件。

方法 2:

我们只需要模拟时钟的顺时针行走，每走一步获取一个元素，假设矩阵 matrix 有 m 行 n 列，那么只需要循环 m * n 次即可获取所有元素。算法描述如下：

定义两个辅助数组变量如下，dr 和 dc 分别表示行和列的方向变化。

dr={0, 1, 0, -1}
dc={1, 0, -1, 0}

两个数组共同组合有以下 4 种情况：

dr[0], dc[0]：行的增量为 0，列的增量为 1，对应方法 1 的情况 1
dr[1], dc[1]：行的增量为 1，列的增量为 0，对应方法 1 的情况 2
dr[2], dc[2]：行的增量为 0，列的增量为 -1，对应方法 1 的情况 3
dr[3], dc[3]：行的增量为 -1，列的增量为 0，对应方法 1 的情况 4

我们总共遍历 m * n 次，每次获取一个元素，而没个元素的状态都将是以上 4 种状态中的一种。令 r,c 分别表示当前的行和列的下标，cr, cc 分别表示 candidate，即下一个候选位置的下标，di 表示当前的方向（对应以上 4 种情况，即 dr,dc 的下标），visited[][] 对应 matrix，表示元素是否被访问过。

对于任意一次遍历，若 r,c 合法，即没有超出矩阵边界又没有被访问过，那么我们可以获取当前元素。否则，我们需要调换方向，即更新 di 的值，具体实现参考代码。

实际上方法 2 不是最优解，相比于方法 1，方法 2 需要一个辅助的数组，但其思想非常值得借鉴，尤其是状态控制的 dr[] 和 dc[] ，di

leetcode-solution

code

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

class Solution{
public:
	vector<int> spiralOrder(vector<vector<int> >& matrix){

		//return spiralOrderCycle(matrix);
		return spiralOrderSimilation(matrix);

	}


	// time-O(m*n), space-O(1) exclude the space used to return info.
	vector<int> spiralOrderCycle(vector<vector<int> >& matrix){
		vector<int> ans;
		if(matrix.empty())
			return ans;

		int rows = matrix.size(), cols = matrix[0].size();
		int si = 0, sj = 0;
		int ei = rows - 1, ej = cols - 1;

		while(si <= ei && sj<=ej){
			spiralOrderOneCycle(matrix, si, sj, ei, ej, ans);
			si++;
			sj++;
			ei--;
			ej--;
		}

		return ans;
	}

	void spiralOrderOneCycle(vector<vector<int> >& matrix, 
		                     int si, int sj, int ei, int ej,
		                     vector<int>& ans){
		// top row
		for(int j=sj; j<=ej; j++)
			ans.push_back(matrix[si][j]);

		// right column
		for(int i=si+1; i<=ei; i++)
			ans.push_back(matrix[i][ej]);

		// down row if exist
		if(si < ei){
			for(int j=ej-1; j>=sj; j--)
				ans.push_back(matrix[ei][j]);
		}

		// left column if exist
		if(sj < ej){
			for(int i=ei-1; i>si; i--)
				ans.push_back(matrix[i][sj]);
		}
	}

	// time-O(m*n), space=O(m*n)
	vector<int> spiralOrderSimilation(vector<vector<int> > &matrix){
		vector<int> ans;
		if(matrix.empty())
			return ans;
		int rows = matrix.size(), cols = matrix[0].size();
		vector<vector<bool> > visited(rows, vector<bool>(cols, false));
		int dr[] = {0, 1, 0, -1};
		int dc[] = {1, 0, -1, 0};
		// start from the left-top corner (r,c) = (0,0) and from left to right
		// di = 0, dr[0] and dc[0], correspond left to right.
		int di = 0, r = 0, c = 0; 
		
		for(int i=0; i<rows*cols; i++){
			ans.push_back(matrix[r][c]);
			visited[r][c] = true;
			int cr = r + dr[di];
			int cc = c + dc[di];
			if(0 <= cr && cr < rows && 0 <= cc && cc < cols && !visited[cr][cc]){
				r = cr;
				c = cc; 
			}else{
				// change direction
				di = (di + 1) % 4;
				r = r + dr[di];
				c = c + dc[di];
			}
		}

		return ans;
	}
};

int main()
{
	return 0;
}