Question

我的问题是要在m * n矩阵中找到不同数量的位置元素，这些元素在其对应的行或列中为最小值或最大值。 下面是我的代码。

static void findSpecialElement(int[][] matrix)  
{  
    for (int i = 0; i < matrix.length; i++)  
    {  
        int rowMin = matrix[i][0];               
        int colIndex = 0;           
        boolean specialElement = true;

        for (int j = 1; j < matrix[i].length; j++)
        {
            if(matrix[i][j] < rowMin)
            {
                rowMin = matrix[i][j];                     
                colIndex = j;
            }
        } 
        for (int j = 0; j < matrix.length; j++)
        {
            if(matrix[j][colIndex] > rowMin)
            {
                specialElement = false;                     
                break;
            }
        }

        if(specialElement)
        {
            System.out.println("Special Element is : "+rowMin);
        }
    }
}

例如：给定尺寸为3 * 3的矩阵，元素的存储方式如下

1  3  4
5  2  9
8  7  6

预期输出为7

保留5 和 3 矩阵中的所有其他数字在行和列中具有最小或最大。因此， 7在9个数字中具有最小值或最大值。

然后 7 是输出

如果任何行或任何列具有最小下限或最大上限，请返回-1 元素...

我的错误是失败，无法按照问题 问题<<>获得预期的答案7 / strong>。

Answer 1

基于更新，我认为您的问题可以简化为：计算行或列中最小或最大的项目。如果可以，则您的算法是错误的，因为：

您正在检查列和行中的最小值（同时检查两者）
您没有检查最大值
您要打印找到的号码

因此，您的策略应类似于：

以零创建一个计数器
对于矩阵中的每个项目
- 检查他的行中是否为分钟
- 检查他的行中是否最大
- 检查他的栏中是否为分钟
- 检查他的栏中是否最大
- 如果一张支票还可以，请增加计数器
打印或退还计数器

那应该对您有帮助。

Answer 2

int maxNum = matrix[0][0];   int minNum = matrix[0][0];

for (int i = 0; i < matrix.length; i++) {
    for (int j = 0; j < matrix[i].length; j++) {
        if(maxNum < matrix[i][j]){
        maxNum = matrix[i][j];
    }
    else if (minNum > matrix[i][j]) {
        minNum = matrix[i][j];
    }    
  }   
}

Answer 3

可能您正在寻找这个

#include <bits/stdc++.h>

using namespace std;

string ltrim(const string &);
string rtrim(const string &);
vector<string> split(const string &);


// Complete the countSpecialElements function below.
int countSpecialElements(vector<vector<int>> matrix) {

int m = matrix.size();          //rows
int n = matrix[0].size();       //columns



int maxrow[102] , minrow[102];
int maxcol[102], mincol[102];
for(int p=0;p<102;p++){
    maxrow[p] =0 ;
    maxcol[p] = 0;
    minrow[p]=0;
    mincol[p]=0;
}

int k=0;
int i,j;

for(i=0;i<m;i++){
    int rminn = INT_MAX;
    int rmaxx = INT_MIN;
    for(j=0;j<n;j++){
        if(matrix[i][j]==rmaxx || matrix[i][j]==rminn) return -1;
        if(matrix[i][j] > rmaxx ) rmaxx = matrix[i][j];
        if(matrix[i][j] < rminn) rminn = matrix[i][j];
    }
    maxrow[i] = rmaxx;
    minrow[i] = rminn;

    for(j=0;j<n;j++){
        int cminn = INT_MAX;
        int cmaxx = INT_MIN;
        for(int p=0;p<m;p++){
            if(matrix[p][j]== cmaxx || matrix[p][j] == cminn) return -1;
            if(matrix[p][j] > cmaxx ) cmaxx = matrix[p][j];
            if(matrix[p][j] < cminn) cminn = matrix[p][j];
        }

        maxcol[j] = cmaxx;
        mincol[j] = cminn;
    }
}

    int cnt = 0;
    for(i=0;i<m;i++)
    {
        for(j=0;j<n;j++)
        {
            if((matrix[i][j]== maxrow[i])||(matrix[i][j]==minrow[i])||(matrix[i][j]==maxcol[j])||(matrix[i][j]==mincol[j]))
                cnt++;
        }
    }
    return cnt;
}

Answer 4

我认为它可以以更好=更快的方式完成，但我的O(n^2)：

import java.util.HashSet;
import java.util.Set;

public class Main {
    public static int[][] input = {
            {1, 3, 4},
            {5, 2, 9},
            {8, 7, 6}
    };

    public static void main(String[] args) {
        int numberOfElements = 0;
        Set<Integer> numberOfUniqueElements = new HashSet<>();

        Set<Integer> specialElements = new HashSet<Integer>();
        for (int i = 0; i < input.length; i++) {
            int maxInRow = Integer.MIN_VALUE;
            int minInRow = Integer.MAX_VALUE;
            int maxInColumn = Integer.MIN_VALUE;
            int minInColumn = Integer.MAX_VALUE;
            for (int j = 0; j < input[i].length; j++) {
                numberOfElements++;
                numberOfUniqueElements.add(input[i][j]);
                if (input[i][j] > maxInRow) {
                    maxInRow = input[i][j];
                }
                if (input[i][j] < minInRow) {
                    minInRow = input[i][j];
                }
                if (input[j][i] > maxInColumn) {
                    maxInColumn = input[j][i];
                }
                if (input[j][i] < minInColumn) {
                    minInColumn = input[j][i];
                }
            }

            specialElements.add(minInRow);
            specialElements.add(maxInRow);
            specialElements.add(minInColumn);
            specialElements.add(maxInColumn);
        }
        if (numberOfUniqueElements.size() != numberOfElements) {
            System.out.println("-1");
        } else {
            System.out.println(specialElements.size());
        }
    }
}

在m * n矩阵中查找特殊元素

4 个答案: