对于一个整数矩阵，存在一种运算，对矩阵中任意元素加一时，需要其相邻（上下左右）某一个元素也加一

最新推荐文章于 2022-05-07 21:15:51 发布
最新推荐文章于 2022-05-07 21:15:51 发布
阅读量1.5k 收藏
点赞数
分类专栏： 数据结构 刀疤鸭 先疯盗骨 文章标签： null 算法

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

一个整数数组，长度为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

算法 原理的思想是将大问题转换成小问题。
就{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，则将程序转到第三步。


 

// p44_YahooReviewerQ.cpp : Defines the entry point for the console application.
//
//--------------------------------------------------------------------------------------
/*
	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 "stdafx.h"
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <iostream>
#include <stack>
#include <math.h>

using namespace std;

#define	INIT_SIZE	100

#define Q_MODE_		1	// 若为 1：表示第一题；若为 2：表示为第二题；

int nMaxtric[INIT_SIZE][INIT_SIZE];
int nXLen = 0;
int nYLen = 0;

int nArray[INIT_SIZE];
int nACurLen = 0;
// 判断是否可以由零矩阵转换而得
//-------------------------------------------------
// 注：算法 不知，只知道每次增加 5，即矩阵和为 5 的
//	   倍数。	
//-------------------------------------------------
// 判读改点是 模板否?...
bool testPosIsTemplate(int nMaxtric[INIT_SIZE][INIT_SIZE],int nXLen,int nYLen,int nXPos,int nYPos)
{
	bool bIs = false;
	int nUp_x = 0,nDown_x = 0,nLeft_x = 0,nRight_x = 0;
	int nUp_y = 0,nDown_y = 0,nLeft_y = 0,nRight_y = 0;

	nUp_x = nXPos-1;	nUp_y = nYPos;
	nDown_x = nXPos+1;nDown_y = nYPos;
	nLeft_x = nXPos;nLeft_y = nYPos-1;
	nRight_x = nXPos;nRight_y = nYPos+1;

	if(nUp_x <= 0)nUp_x = 0;
	if(nUp_x >= nXLen)nUp_x = nXLen - 1;
	if(nDown_x <= 0)nDown_x = 0;
	if(nDown_x >= nXLen)nDown_x = nXLen - 1;
	if(nLeft_x <= 0)nLeft_x = 0;
	if(nLeft_x >= nXLen)nLeft_x = nXLen - 1;
	if(nRight_x <= 0)nRight_x = 0;
	if(nRight_x >= nXLen)nRight_x = nXLen - 1;

	if(nUp_y <= 0)nUp_y = 0;
	if(nUp_y >= nYLen)nUp_y = nYLen - 1;
	if(nDown_y <= 0)nDown_y = 0;
	if(nDown_y >= nYLen)nDown_y = nYLen - 1;
	if(nLeft_y <= 0)nLeft_y = 0;
	if(nLeft_y >= nYLen)nLeft_y = nYLen - 1;
	if(nRight_y <= 0)nRight_y = 0;
	if(nRight_y >= nYLen)nRight_y = nYLen - 1;

	if(nMaxtric[nXPos][nYPos] && nMaxtric[nUp_x][nUp_y] && nMaxtric[nDown_x][nDown_y] &&
		nMaxtric[nLeft_x][nLeft_y] && nMaxtric[nRight_x][nRight_y])
		bIs = true;

	return bIs;
}
// 判读是否为零矩阵
bool isZeroMaxtric(int nMaxtric[INIT_SIZE][INIT_SIZE],int nXLen,int nYLen)
{
	bool bIsZ = true;

	for(int i = 0;i < nXLen;i ++)
		for(int j = 0;j < nYLen;j ++)
		{
			if(nMaxtric[i][j])
			{
				bIsZ = false;
				goto END;
			}
		}
END:
	return bIsZ;

}
// 减去模板矩阵
bool DecTeplateMaxtric(int nMaxtric[INIT_SIZE][INIT_SIZE],int nXLen,int nYLen,int nXPos,int nYPos)
{
	int nUp_x = 0,nDown_x = 0,nLeft_x = 0,nRight_x = 0;
	int nUp_y = 0,nDown_y = 0,nLeft_y = 0,nRight_y = 0;

	nUp_x = nXPos;	nUp_y = nYPos-1;
	nDown_x = nXPos;nDown_y = nYPos+1;
	nLeft_x = nXPos-1;nLeft_y = nYPos;
	nRight_x = nXPos+1;nRight_y = nYPos;
	
	nMaxtric[nXPos][nYPos] -= 1;
	if(nUp_x >= 0 && nUp_x < nXLen && nUp_y >= 0 && nUp_y < nYLen)nMaxtric[nUp_x][nUp_y] -= 1;
	if(nDown_x >= 0 && nDown_x < nXLen && nDown_y >= 0 && nDown_y < nYLen)nMaxtric[nDown_x][nDown_y] -= 1;
	if(nLeft_x >= 0 && nLeft_x < nXLen && nLeft_y >= 0 && nLeft_y < nYLen)nMaxtric[nLeft_x][nLeft_y] -= 1;
	if(nRight_x >= 0 && nRight_x < nXLen && nRight_y >= 0 && nRight_y < nYLen)nMaxtric[nRight_x][nRight_y] -= 1;
	
	return true;
}
// 递归判读
bool MaxtricTrans(int nMaxtric[INIT_SIZE][INIT_SIZE],int nXLen,int nYLen)
{
	if(isZeroMaxtric(nMaxtric,nXLen,nYLen))return true;

	for(int i = 0;i < nXLen;i ++)
		for(int j = 0;j <nYLen;j ++)
		{
			if(testPosIsTemplate(nMaxtric,nXLen,nYLen,i,j))
			{
				DecTeplateMaxtric(nMaxtric,nXLen,nYLen,i,j);
				goto END;
			}
		}

	return isZeroMaxtric(nMaxtric,nXLen,nYLen);
END:
	if(MaxtricTrans(nMaxtric,nXLen,nYLen))return true;
	else return false;
}
bool isMaxtricTrans(int nMaxtric[INIT_SIZE][INIT_SIZE],int nXLen,int nYLen)
{
	if(nMaxtric == NULL	||
		nXLen <=	0	||
		nYLen <=	0)
		return false;

	bool bTrue = false;
	
	bTrue = MaxtricTrans(nMaxtric,nXLen,nYLen);
	
	if(bTrue)cout << "可以" <<endl;
	else	 cout << "不可以" <<endl;

	return true;
}
// 判读数组最大可分的数组份数
bool getMaxAveSumOfArray(int nArray[INIT_SIZE],int nACurLen)
{
	if(nArray == NULL	||
		nACurLen <= 0)
		return false;
	

	return true;
}
//-----------------------------------------------------------------------------
// 答案：
//		此处也是经典案例啊!....
int testShares(int a[], int n, int m, int sum, int groupsum, int aux[], int goal, int& groupId)	// 注，此处必须加引用，不然出错，因为值传递错误
{
  if (goal == 0) 
  {
    groupId++;
    if (groupId == m+1) return 1;
 
	return 0;	// 增加返回，提供程序效率
  }
  for (int i=0; i <n; i++) 
  {
    if (aux[i] != 0) continue;
    aux[i] = groupId;

    if(testShares(a, n, m, sum, groupsum, aux, goal-a[i], groupId))
	{
      return 1;
    }
	else
		aux[i] = 0;
  }
  return 0;
}
int maxShares(int a[], int n)
{
  int sum = 0;
  int i, m;
  for (i=0; i <n; i++) sum += a[i];
  for (m=n; m >=2; m--) 
  {
    if (sum % m != 0) continue;
    int aux[INIT_SIZE]; 
	int groupId = 1;
	for (i=0; i < INIT_SIZE; i++) aux[i] = 0;
    if (testShares(a, n, m, sum, sum/m, aux, sum/m, groupId)) return m;
  }
  return 1;
}

int main(int argc, char* argv[])
{
	memset(nMaxtric,0,sizeof(int)*INIT_SIZE*INIT_SIZE);
	memset(nArray,0,sizeof(int)*INIT_SIZE);

	int nNum = 0;
#if(Q_MODE_  == 1)
	cout<<"请输入nMaxtric 相应的数据<输入符号时结束相应的 行/列 输入>:\n"<<endl;
	int nX = 1,nY = 1;
	while(1)
	{
		cout<<"请输入第"<<nX<<"行数据"<<endl;
		cin>>nNum;
		if (cin.fail())
		{
			break;
		}
		else
		{
			nMaxtric[nX-1][nY-1] = nNum;
			nY++;
		}
		// 继续输入改行的数据
		while(1)
		{
			cin>>nNum;
			if (cin.fail())
			{
				// 更新X轴的最大值
				if(nY > nXLen)nXLen = nY-1;
				//清理缓冲区
				cin.clear();
				cin.ignore(1000,'\n');
				break;
			}
			else
			{
				nMaxtric[nX-1][nY-1] = nNum;
				nY++;
			}
		}

		nX++;
		nY = 1;
	}
	nYLen = nX-1;

	if(!isMaxtricTrans(nMaxtric,nYLen,nXLen))
	{
		cout << "Param Error!..."<<endl;
	}
#else if(Q_MODE_ == 2)
	cout<<"请输入数组相应的数据<输入符号时结束输入>:\n"<<endl;	
	while(nACurLen <= INIT_SIZE)
	{
		cin>>nNum;
		if (cin.fail())
		{
			break;
		}
		else
		{
			nArray[nACurLen ++] = nNum;
		}
	}

	cout << "最大的可分份数为 "<< maxShares(nArray,nACurLen)<< endl;
#endif

	cin.ignore(1000,'\n');  //清理缓冲区
	getch();
	return 0;
}


会飞牛牛
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
代数与规划模型-一种矩阵密码问题.pptx
11-24
然后，查明文字母表得到每组的表值，并构造三维列向量作模26运算（每个元素都加减26的整数倍，使其化为0~25的一个整数）得反查明文字母表得到每对表值对应的字母为：DYW XUG QHW，这就得到了密文“DYWXUGQ”。...
对于一个整数矩阵，存在一种运算，对矩阵中任意元素加一时，需要其相邻（上下左右）某一个元素也加一， 现给出一正数矩阵，判断其是否能够由一个全零矩阵经过上述运算得到。
crasyangel的专栏
09-05 3155
以4*4矩阵为例 1、全部红线元素设为集合A，全部黑线元素设为集合B；A或者B里面的元素彼此互不相邻，对其值没有贡献；也就是说对A里面的元素的值产生贡献的都是B集合里面的元素，sum（A）=sum（B）。 2、任一元素必须小于等于其相邻元素（上下左右）之和 3、以上两点均为必要性，其实满足以上两点的正整数矩阵一定可以由一个全零矩阵经过该运算得到。 考虑以下这种情况，无论A集合中哪个或者哪几
对于一个整数矩阵，存在一种运算，对矩阵中任意元素加一时，需要其相邻（上下左右），某一个元素也加一，现给出一正数矩阵，判断其是否能够由一个全零矩阵经过上述运算得到。
Edwards_June的专栏
01-15 1060
#define M 3 #define N 3 //二维坐标和为奇数的元素和与坐标和为偶数的元素和是否相等 bool getSum(int matrix[M][N], int m, int n) { if (!matrix) { return false; } int sumA = 0; int sumB = 0; for (int i = 0; i < m; ++i) { f
算法习题45：对于一个整数矩阵，存在一种运算，对矩阵中任意元素加一时，需要其相邻（上下左右）某一个元素也加一；；；一个整数数组，长度为n，将其分为m份，使各份的和相等，求m的最大值
ylf13的专栏
11-05 1812
.雅虎： 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}
【100题】第四十五题 雅虎面试两道题（矩阵判断、数组划分）
weixin_33845477的博客
08-20 116
一，对于一个整数对于一个整数矩阵矩阵，存在一种运算，对矩阵中任意元素加一时，需要其相邻（上下左右）某一个元素也加一，现给出一正数矩阵，判断其是否能够由一个全零矩阵经过上述运算得到。 分析：对任意一个位置,他的值不大于周围(上下左右)4个临格的数值的和，如果大于则该矩阵不能由全零矩阵得到 解法一：可能是我能想到的最复杂的方法 ...
在矩阵/图像中绘制圆：使用整数中点圆算法在二维矩阵中绘制圆-matlab开发
05-30
由于在实际计算中我们处理的是整数坐标，因此算法需要在每次迭代时处理两个相邻的像素，以确保圆的边界正确无误。 首先，我们需要定义圆的参数，包括圆心坐标（x0, y0）和半径r。然后，算法开始在(x0-r, y0)到(x0+r...
python_game_2048:我们将使用python创建一个游戏2048
05-16
2. **用户输入处理**：游戏需要监听用户的键盘输入，Python的`input()`函数可以捕获用户对上下左右的按键选择，然后进行相应的棋盘移动操作。 3. **矩阵操作**：Python的numpy库提供了高效、灵活的矩阵运算功能，...
matlab矩阵和数组区别.docx
最新发布
09-20
MATLAB 是一个强大的矩阵运算工具，主要用于处理矩阵和数组。在 MATLAB 中，矩阵和数组都是多维数组，数据类型无关。矩阵是指通常用来进行线性代数运算的二维数组。 创建矩阵和数组 -------------------- 在 ...
20年春福师大《近世代数》在线作业一满分答案.docx
10-22
1. **群**：群是一种代数结构，由一个集合及定义在该集合上的一个二元运算构成，满足结合律、存在单位元以及对于集合内每个元素存在其逆元。例如，n阶方阵集合对于矩阵加法构成群。 2. **循环群**：循环群是由一个...
微软公司等数据结构+算法面试100题(第1-100题)全部出炉
热门推荐
结构之法 算法之道
12-06 23万+
微软等公司数据结构+算法面试100题(第1-100题)首次完整亮相                        作者:July、2010年12月6日。更新：现今，这100题的答案已经全部整理出来了，微软面试100题2010年版全部答案集锦：http://blog.csdn.net/v_july_v/article/details/6870251。关于此100道面试题的所有一切详情，包括答案，资源
数组元素值+1
m0_63112935的博客
05-07 1365
创建一个一维数组a，数组的长度通过键盘输入，然后通过键盘为数组每一个元素赋值，赋值后，对数组a中每一个元素的值+1，最后输出数组a的每一个元素。 输入格式: 第一行输入一个整数，为一个数组a的长度 第二行输入数组中每一个元素的值 输出格式: 每一行输出数组的一个元素 输入样例: 在这里给出一组输入。例如： 4 1 2 3 4 输出样例: 在这里给出相应的输出。例如： 2 3 4 5 代码样例： import java.util.Scanner; public cla..
算法题之（在一个二维数组中（每个一维数组的长度相同），左右和上下分别递增，求是否含有指定整数）
magic_xiang的博客
08-30 624
在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。 我们先假设一个二维数组列出来，形成一个矩阵，便于我们的理解 [10, 20, 40, 60], [20, 30, 70, 90], [40, 50, 80, 110], 根据题意我们可以得到如下理...
刷题笔记
weixin_30606461的博客
08-10 2万+
基本排序算法 基于比较的排序 冒泡排序 没什么可说的, 改进方法就是加一个标志位防止有序后重复遍历. 由于需要遍历两次, 所以时间复杂度O(N^2) 传送门 --> 冒泡排序 选择排序 外层从0开始默认outer是最小数的下标, 内存从outer+1位置开始遍历, 不稳定, 如{ 3, 3, 3, 2 }, 当比较最后一个4时, 是第一个3和2交换, 从而不稳定. 内外层遍历两...
hardmard积 用什么符号表示_简明算术教程——第四章 线性代数——第1节 矩阵环（二）...
weixin_28695161的博客
12-23 1718
尽管Hadamard积的应用有趣而精妙，但它并非通常研究意义上的矩阵环乘法，所以我们浅尝搁置。现在我们就要开始介绍“真正的”矩阵环乘法了，按照惯例，我们还是继续用一个有趣的应用来将矩阵环乘法的定义引出。考虑下图点的移动，其中单箭头表示单向路径，双箭头则表示双向路径。例如：现在我们有一个问题：设图中出现的点的个数为n，定义一步的操作为从一点移动到相邻另一点，那么问若以图中的点 为起点，经过m步后，到...
输出一个倍数为3且下标为3的数组
汉南最後の読書人
11-23 1330
/* *Copyright (c)2014,烟台大学计算机与控制工程学院 *All rights reserved. *文件名称：sum123.cpp *作 者：林海云 *完成日期：2014年11月23日 *版 本 号：v2.0 * *问题描述：输出数组中元素值为3的倍数的数和下标为3的倍数的数 *程序输入： *程序输出：符合要求的整型数组。 */
【编程题目】对于一个整数矩阵，存在一种运算，对矩阵中任意元素加一时，需要其相邻（上下左右）某一个元素也加一...
weixin_33835103的博客
08-11 179
45.雅虎（运算、矩阵）：1.对于一个整数矩阵，存在一种运算，对矩阵中任意元素加一时，需要其相邻（上下左右）某一个元素也加一，现给出一正数矩阵，判断其是否能够由一个全零矩阵经过上述运算得到。   这道题，是我目前为止做过的最最最最最麻烦、最繁琐的题目了。   思路： 把输入的矩阵一步步还原成 0 矩阵 一个数字，只可能伴随着它上下左右四个方向的数字变化。 ①如果数字比它周围四个数的和...
矩阵运算 【微软面试100题 第四十五题】
weixin_33816611的博客
11-07 150
题目要求： 　　对于一个整数矩阵，存在一种运算，对矩阵中任意元素加一时，需要其相邻（上下左右）某一个元素也加一，现给出以正数矩阵，判断其是否能够由一个全零矩阵经过上述运算得到。 题目分析： 　　使用贪心算法。 代码实现： 　　 #include <iostream> using namespace std; const int N = 3; bool ...
python：递归法和回溯法求解迷宫问题以及二维矩阵中相同上下左右元素标记为同一部分（岛问题）
weixin_39781462的博客
09-06 2449
1.递归法：先放程序： # 迷宫求解：分析和设计】 ''' 问题分析： 问题表示： 迷宫本身使用一个元素值为0/1的矩阵表示。迷宫入口、出口可以用一对下标表示。 A: 为了防止程序在某些局部兜圈子，必须采用某种方法记录已经探查过的位置：两种方法（1）采用专门的结构记录这种信息 （2）把已经探查过的标记在 迷宫上（将采用这种方式--把已经探查过的位置，对应矩...
Java第一行包含两个整数n和m，表示矩阵的行数和列数(1≤n≤100，1≤m≤100)。 接下来n行，每行m个整数，表示矩阵A的元素。 接下来n行，每行m个整数，表示矩阵B的元素。 相邻两个整数之间用单个空格隔开，每个元素均在1~1000之间。
06-07
这是一个关于读取两个矩阵数据的问题，以下是Java代码实现： ```java import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值