Question

不久前我正在研究this problem，并提出了以下解决方案：

Get('https://www.ratemyprofessors.com/ShowRatings.jsp?tid=282380', function(err, data) {
  let dom = document.createElement('html');
  dom.innerHTML = data;
  let elements = Array.from(dom.getElementsByClassName('grade'));
  elements.length = 3; // if you're need only 3 first elements.
  console.log(elements);
});

function Get(url, callback, responseType = 'text') { // you can manually set type.
  var xhr = new XMLHttpRequest();

  xhr.responseType = 'text';
  xhr.onload = function() {
    var status = xhr.status;
    if (status === 200) {
      callback(null, xhr.response);
    } else {
      callback(status, xhr.response);
    }
  };
  xhr.open('GET', url, true);
  xhr.send();
};

最初，我有一个不同的解决方案，但是更改了i和j的位置以使其起作用。导致我想到以下问题：在遍历2D数组时，可以假设我水平移动而j垂直移动吗？

Answer 1

只要您的思维模式是一致的，“水平”和“垂直”就是您想要的。您可以想到(x, y)个点，其中x在水平方向上，y在垂直方向上。或者，您可以将数组视为一个矩阵，其中i是行号，j是列号。这两种观点都将起作用。同样，一致性是重要的事情。

Answer 2

我检查了这个问题的乐趣。您可以创建某种蒙版来获取沙漏的当前值。然后，您可以从左到右和从右到左交替遍历数组。当到达右端或左端时，下降。像这样：

#include <bits/stdc++.h>

using namespace std;

// Complete the hourglassSum function below.
int maskArray(std::vector<std::pair<int, int>> &mask, std::vector<std::vector<int>> &array) {
    int sum = 0;
    for (auto& v : mask) {
        sum += array[v.first][v.second];
    }
    return sum;
}

void moveMaskLeft(std::vector<std::pair<int, int>>  &mask) {
    for (auto& v : mask) {
        --v.second;
    }
}

void moveMaskRight(std::vector<std::pair<int, int>>  &mask) {
    for (auto& v : mask) {
        ++v.second;
    }
}

void moveMaskDown(std::vector<std::pair<int, int>>  &mask) {
    for (auto& v : mask) {
        ++v.first;
    }
}

int hourglassSum(vector<vector<int>> arr) {
    int maxSum = std::numeric_limits<int>::min();
    std::vector<std::pair<int, int>> mask{{0,0}, {0,1}, {0,2},
                                                 {1,1},
                                          {2,0}, {2,1}, {2,2}};
    enum direction {R, L};
    direction dir = R;
    for (int y = 0; y < 4; ++y) {
        for (int x = 0; x < 4; ++x) {
            int localSum = maskArray(mask, arr);
            maxSum = std::max(maxSum, localSum);
            if (dir == R) {
                if (x < 3)
                moveMaskRight(mask);
            } else {
                if (x < 3)
                moveMaskLeft(mask);
            }
        }
        dir = dir == R ? L : R;
        moveMaskDown(mask);
    }
  return maxSum;
}

int main()
{
    ofstream fout(getenv("OUTPUT_PATH"));

    vector<vector<int>> arr(6);
    for (int i = 0; i < 6; i++) {
        arr[i].resize(6);

        for (int j = 0; j < 6; j++) {
            cin >> arr[i][j];
        }

        cin.ignore(numeric_limits<streamsize>::max(), '\n');
    }

    int result = hourglassSum(arr);

    fout << result << "\n";

    fout.close();

    return 0;
}

二维数组如何遍历？

2 个答案: