算法

Question

如果我们在

中有这些数字

array [][]
{1, 2, 3, 4},
{1, 2, 20, 4},
{1, 20, 2, 4},
{1, 2, 3, 4},};

它看起来应该是这样的

但我只能像这样输出代码......

我不明白如何纠正它，请帮助我，这是我的代码。谢谢！

package com.company;

public class Main {

    public static void main(String[] args) {

        int[][] array2 = {{1, 2, 3, 4},
                {1, 2, 20, 4},
                {1, 20, 2, 4},
                {1, 2, 3, 4},};

        int countMax = 0;
        int countIndexHorizontal = 0;
        int countIndexVertical = 0;
        int max = Integer.MIN_VALUE;
        int m, k,x;

        for (int i = 0; i < array2.length; i++) {
            for (int j = 0; j < array2[i].length; j++) {
                if (array2[i][j] > max) {
                    max = array2[i][j];   
                }
            }
        }

        for (k = 0; k < array2.length; k++) {
            for (m = 0; m < array2[k].length; m++) {
                if (array2[k][m] == max) {
                    countIndexHorizontal = k;
                    countIndexVertical = m;
                    for (x = 0; x < array2.length; x++) {
                        for (int j = 0; j < array2[x].length; j++) {
                            if (countIndexVertical == x || j == countIndexHorizontal) {
                                array2[x][j] = 0;
                            }
                        }
                    }
                }
            }
        }

        for (int i = 0; i < array2.length; i++) {
            for (int j = 0; j < array2[i].length; j++) {
                System.out.print(array2[i][j] + " ");
            }
            System.out.println();
        }
    }
}

看起来有很多代码和一些单词和网站不允许我最后发布我的问题，我真的很生气，也许这篇文章将帮助我解决这个问题。

Answer 1

您可以通过将条件更改为

来改进程序

if (countIndexHorizontal == x || j == countIndexVertical)

您的程序正在删除找到的前20行（包括其他20行）的错误行。

此更改将为您的具体案例提供正确的答案，但该程序仍然因此类示例而被打破

2  2
1  1

正确的输出是

0  0
0  0

但它不会起作用，因为当它找到前2时它将删除第二个2，但仍需要第二个2来清除右下角的0。您必须为要清除的位置保留单独的数据结构。我会把它留给你弄清楚。

Answer 2

算法

这是您只使用笔和纸的部分。基本上，我理解的问题如下：

给定一个矩阵，其中 n 行和 m 列Integer ¹：



找到最高值



持有最高值的行和列中的所有条目的值必须设为0



打印更新的矩阵

假设

我做了以下假设：

在 n 中不一定等于 m 。例如，您可以拥有数组：

Valid Input
1  2  3  4  5  6
7  8  9 10 11 12
7  8 12  5  6  4

必须给出，因为12是最高值：

Output
1  2  0  4  5  0
0  0  0  0  0  0
0  0  0  0  0  0

矩阵是一致的：每行都有 m 列，每列都有 n 行。例如，此类输入不正确：
```
Incorrect input
1  2  3
7  8  9 10
7  8
```

逻辑

在此阶段，您仍然只使用笔，纸和Google！

在我的问题理解中，我分成三部分，因为我认为这是你理解问题的方式。这是数学的理解。现在让我们将其转换为更多 Java 理解。首先，我们需要翻译一些词汇：

Mathematics wording |     Java wording
--------------------|---------------------
      matrix        |  2-dimensional array
      Integer       |  int (primitive type)

以Java方式提供：

给定一个二维int[][]数组：



找到最高值



查找 s 行



通过将行 s 的值设置为0并在2中找到列 s 来更新数组。



打印数组

在我的解决方案的特定情况下，我结合 1。 + 2。和我合并 3。 + 4.

你做了什么

让我们打开您最喜欢的IDE并将我的分析与您的输入进行比较：

找到最高值：好在这里 ::您使用变量max并扫描矩阵以查找最大值。您还假设矩阵可以是矩形（ n 行和 m 列，其中 n！= m ）。这很好

for (int i = 0; i < array2.length; i++) { for (int j = 0; j < array2[i].length; j++) { if (array2[i][j] > max) { max = array2[i][j]; } } }

查找行 s 和列 s ：错误，如{{{ 3}}，当你找到一个最高值时，你擦除（设置为零）整列和整行的值，但也许相同的最高值存储在这行或列的其他地方

for (k = 0; k < array2.length; k++) { for (m = 0; m < array2[k].length; m++) { if (array2[k][m] == max) { countIndexHorizontal = k; countIndexVertical = m; // additional operation defined in 3. } // in ccp-beginner example of // 2, 2 // 1, 1 // if k=0 and m=0, you'll update the value // of the first row and first column giving: // 0, 0 // 0, 1 // but when k=0, m=1, you'll find 0 instead // of 2 so your program will consider that // this row / column does not contain the // highest value } }

我在这里假设

countIndexHorizontal = row

countIndexVertical = column

因此，当您将值设置为0时，需要跟踪行 s 和列 s

更新数组：错误（参见ccp-beginner回答）

for (x = 0; x < array2.length; x++) { for (int j = 0; j < array2[x].length; j++) { if (countIndexVertical == x || j == countIndexHorizontal) { array2[x][j] = 0; // In your example: // 1 2 3 4 // 1 2 20 4 // 1 20 2 4 // 1 2 3 4 // and if countIndexVertical=2 and countIndexHorizontal=1 // (the 20 of the second row between 2 and 4), you'll have // 1 0 3 4 // 1 0 20 4 // 0 0 0 0 // 1 0 3 4 // instead of // 1 2 0 4 // 0 0 0 0 // 1 20 0 4 // 1 2 0 4 } } }

你在countIndexVertical和countIndexHorizontal之间感到困惑，因为你有

x = row

j = column

你应该（请注意交换）

if (countIndexHorizontal == x || j == countIndexVertical) { array2[x][j] = 0; }

打印数组：好在这里，没什么特别要提的

for (int i = 0; i < array2.length; i++) { for (int j = 0; j < array2[i].length; j++) { System.out.print(array2[i][j] + " "); } System.out.println(); }

问题

基本上，您需要的是如何存储包含最高值的行和列。起初，我们可能想再次使用数组，比如

int[] rowsContainingHighestValue; int[] columnsContainingHighestValue;

但是你不知道你会遇到多少最高价值，所以你需要一些东西来存储动态大小的多个价值：我会使用List。

一些Java点

rowsContainingHighestValue和columnsContainingHighestValue成为：

List<Integer> rowsContainingHighestValue = new ArrayList<>(); List<Integer> columnsContainingHighestValue = new ArrayList<>();

您可能需要查看以下内容：

为什么ccp-beginner？

我的对象被声明为List，但我实例化 ²与ArrayList：List instead of array

为什么我使用What is a Interface and what is a Class

什么是List<Integer> instead of List<int>

一种解决方案

遍历矩阵以获取最大值，并存储所有行和包含此值的行而不是单个行/列组合（countIndexHorizontal和countIndexVertical）

如果找到新的最大值，请将其存储（与您一样） AND 存储当前行和列索引

如果某个值与当前最大值相同（例如，您有20两次），则将行和列索引追加到现有的相应行/列列表

第二次循环以更新和打印该值

它基本上结合了你的两个最后一个双循环：如果扫描的元素属于一行或一个保持最大值的列，那么该值必须设置为0（确切地说你的方式，但因为我已经有行/列列表而缩短了）

一旦值正确更新，只需进行简单打印
即可

在代码中给出了：

public static void main(String[] args) { int[][] array2 = { {1, 2, 3, 4}, {1, 2, 20, 4}, {1, 20, 2, 4}, {1, 2, 3, 4} }; // find the maximum value and store its position: // It's List instead of a single value as multiple // rows and columns can hold the same maximum value List<Integer> rowsWithMaxValue = new ArrayList<>(); List<Integer> colsWithMaxValue = new ArrayList<>(); int maxValue = Integer.MIN_VALUE; // First matrix-scan to fetch the maximum value and the // row(s) and column(s) to set the value at 0 for (int row = 0; row < array2.length; row++) { for (int col = 0; col < array2[row].length; col++) { // get the current value int value = array2[row][col]; // found a new maximum or an existing one? if (value > maxValue) { // this is a new maximum value, we can reset // the list as the previous rows and columns // are not relevant anymore maxValue = value; rowsWithMaxValue = new ArrayList<>(); colsWithMaxValue = new ArrayList<>(); rowsWithMaxValue.add(row); colsWithMaxValue.add(col); } else if (value == maxValue) { // The same value (like 20) is found again // so multiple rows and columns will have // their value set at 0 rowsWithMaxValue.add(row); colsWithMaxValue.add(col); } } } // Second matrix-scan for updating the values and printing for (int row = 0; row < array2.length; row++) { for (int col = 0; col < array2[row].length; col++) { // is it in a forbidden row? If yes, set the value // at zero. One of the condition (row or column) is // enough to have its value set at 0 if (rowsWithMaxValue.contains(row) || colsWithMaxValue.contains(col)) { array2[row][col] = 0; } // Simply print the value System.out.print(array2[row][col] + " "); } System.out.println(); } }

¹ _{数学意义上的整数：无小数的正数或负数}

² _{我不解释这里的实例化。随意谷歌}

在数组中查找最大元素并删除包含它的所有行和列

2 个答案:

算法

假设

逻辑

你做了什么

问题

一些Java点

一种解决方案