100-45.雅虎（运算、矩阵）：

2019独角兽企业重金招聘Python工程师标准>>>

45.雅虎（运算、矩阵）：
1.对于一个整数矩阵，存在一种运算，对矩阵中任意元素加一时，需要其相邻（上下左右）
某一个元素也加一，现给出一正数矩阵，判断其是否能够由一个全零矩阵经过上述运算得到。
2.一个整数数组，长度为n，将其分为m份，使各份的和相等，求m的最大值
比如{3，2，4，3，6} 可以分成{3，2，4，3，6} m=1; 
{3,6}{2,4,3} m=2

{3,3}{2,4}{6} m=3 所以m的最大值为3

思路：

1.感觉比较难了，没什么思路，然后有网友说是可以用最大流来解，我目前对这一块还不熟悉，回头在回过来看看。先记录下。

2.这条思路也是从网上找到的，然后我自己用c++实现了。

算法原理的思想是将大问题转换成小问题。就{3，2，4，3，6}的操作步骤：
      第一步：想将数组递减排序得{6，4，3，3，2}，求出数组中所有数的和m=18,第一个最大的数b=6， m/b=3余数为0，当除数为1，余数为0时终止。当余数不为0时，转到第三步。当余数为0时将数组划分为{6}，{4，3，3，2}两个。把{4，3，3，2}看成一个新的数组。
      第二步：先用{4，3，3，2}中的最大数与b=6比较，即4<b，所以再将4与最右边的数即2相加与b比较，结果相等，则将这两个数从该数组中除去生成新的数组，转到第一步，现在的结果是{6},{4,2},{3,3},把{3,3}看成一个新的数组继续重复第二步。
      第三步，将数组中最大的数与最小的数取出构成一个新数组Z，剩余的构成一个数组，然后，判断m/Z中数字之和看是否余数为0，若为0，把b替换为Z中数字之和转第二步，若不为0，继续从剩余的数字中取出最小值加入到Z中，再判断m/Z中数字之和看是否余数为0，直到为0，转第二步为止。最后得到的结果是{6},{4,2},{3,3} 这时可以计算出m为3，也可以在程序中作记载。在第二步工程过，若出现两个数相加大于上一次的b，则将程序转到第三步。

贴上代码：

/*=====================================================*\
45.雅虎（运算、矩阵）：
1.对于一个整数矩阵，存在一种运算，对矩阵中任意元素加一时，需要其相邻（上下左右）
某一个元素也加一，现给出一正数矩阵，判断其是否能够由一个全零矩阵经过上述运算得到。
2.一个整数数组，长度为n，将其分为m份，使各份的和相等，求m的最大值
比如{3，2，4，3，6} 可以分成{3，2，4，3，6} m=1; 
{3,6}{2,4,3} m=2
{3,3}{2,4}{6} m=3 所以m的最大值为3
\*=====================================================*/
#include <iostream>
#include <queue>

using namespace std;

int partition(int *index,int begin,int end){
	int i = begin;
	int j = end;
	int temp = 0;
	while(i < j){
		while((i < j) && (index[i] >= index[j])){
			--j;
		}
		if(i < j){
			temp = index[i];
			index[i] = index[j];
			index[j] = temp;
		}
		while((i < j) && (index[i] > index[j])){
			++i;
		}
		if(i < j){
			temp = index[i];
			index[i] = index[j];
			index[j] = temp;
		}
	}
	return i;
}

//快速排序，按递减顺序
void quickSort(int *index,int begin,int end){
	if(begin >= end){
		return;
	}
	int p = partition(index,begin,end);
	quickSort(index,begin,p-1);
	quickSort(index,p+1,end);
}

bool findPartition(int *index,int length){
	quickSort(index,0,length-1);//快速排序，按递减顺序
	int sum = 0;
	for(int i = 0 ; i < length ; ++i){
		cout << index[i] << " ";
		sum += index[i];
	}
	cout << endl;
	int mMax = length;
	for(int i = mMax ; i > 1 ; --i){
		if(0 == sum % i){
			int aSum = sum / i;
			int pBegin = 0;//初始化数组索引，指向头
			int pEnd = length - 1;//初始化数组索引，指向尾
			queue<int> q;
			int j = 0;
			for(j = i ; j > 0 ; --j){//找到mMax个组中，每个组的元素组成情况
				if(aSum == index[pBegin]){
					q.push(index[pBegin]);
					q.push(-1);
					++pBegin;
				}else if(aSum > index[pBegin]){
					q.push(index[pBegin]);
					int temp = index[pBegin];
					++pBegin;
					while(temp < aSum){
						temp += index[pEnd];
						q.push(index[pEnd]);
						--pEnd;
					}
					if(temp == aSum){
						q.push(-1);
					}else{
						break;
					}
				}else{
					//不确定是否应该清空queue
					break;
				}
			}
			if(j == 0){
				while(!q.empty()){
					if(-1 != q.front()){
						cout << q.front() << " ";
						q.pop();
					}else{
						cout << endl;
						q.pop();
					}
				}
				cout << "mMax:" << i << endl;
				return true;
			}
		}
	}
	return false;
}

int main(){
	int index[] = {3,2,4,3,6};
	//int index[] = {3,3,3,3,3};
	findPartition(index,sizeof(index)/sizeof(int));
	return 1;
}

转载于:https://my.oschina.net/dapengking/blog/92183