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

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 元素...

我的错误是未能得到预期的answer 7作为per问题。

Answer 1

可能你正在寻找这个-

#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 2

根据更新，我认为您的问题可以简化为：计算一行或一列中最小或最大的项目。如果没问题，那么您的算法是错误的，因为：

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

所以，你的策略应该是这样的：

• 在零中创建一个计数器
• 对于矩阵中的每一项
  • 检查他的行中是否最小
  • 检查他的行是否是最大值
  • 检查他的列中是否为 min
  • 检查他的列中是否为最大值
  • 如果一次检查没问题，增加计数器
• 打印或退回计数器

这应该对你有帮助。

Answer 3

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 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());
        }
    }
}