<p>You are given <code>m</code> <code>arrays</code>, where each array is sorted in <strong>ascending order</strong>.</p>

<p>You can pick up two integers from two different arrays (each array picks one) and calculate the distance. We define the distance between two integers <code>a</code> and <code>b</code> to be their absolute difference <code>|a - b|</code>.</p>

<p>Return <em>the maximum distance</em>.</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>

<pre>
<strong>Input:</strong> arrays = [[1,2,3],[4,5],[1,2,3]]
<strong>Output:</strong> 4
<strong>Explanation:</strong> One way to reach the maximum distance 4 is to pick 1 in the first or third array and pick 5 in the second array.
</pre>

<p><strong class="example">Example 2:</strong></p>

<pre>
<strong>Input:</strong> arrays = [[1],[1]]
<strong>Output:</strong> 0
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>m == arrays.length</code></li>
	<li><code>2 &lt;= m &lt;= 10<sup>5</sup></code></li>
	<li><code>1 &lt;= arrays[i].length &lt;= 500</code></li>
	<li><code>-10<sup>4</sup> &lt;= arrays[i][j] &lt;= 10<sup>4</sup></code></li>
	<li><code>arrays[i]</code> is sorted in <strong>ascending order</strong>.</li>
	<li>There will be at most <code>10<sup>5</sup></code> integers in all the arrays.</li>
</ul>

class Solution {
public:
    int solve1(vector<int>& smallest, vector<int>& largest) {
        int n = smallest.size();
        int a = INT_MAX;
        int index = 0;
        // Find the smallest element and its index
        for (int i = 0; i < n; i++) {
            if (smallest[i] < a) {
                index = i;
                a = smallest[i];
            }
        }

        int b = INT_MIN;
        // Find the largest element in 'largest' except at 'index'
        for (int i = 0; i < n; i++) {
            if (i != index && largest[i] > b) {
                b = largest[i];
            }
        }
        return abs(b - a);
    }

    int solve2(vector<int>& smallest, vector<int>& largest) {
        int n = smallest.size();
        int a = INT_MIN;
        int index = 0;
        // Find the largest element and its index
        for (int i = 0; i < n; i++) {
            if (largest[i] > a) {
                index = i;
                a = largest[i];
            }
        }

        int b = INT_MAX;
        // Find the smallest element in 'smallest' except at 'index'
        for (int i = 0; i < n; i++) {
            if (i != index && smallest[i] < b) {
                b = smallest[i];
            }
        }
        return abs(b - a);
    }

    int maxDistance(vector<vector<int>>& arrays) {
        // Use vectors to store smallest and largest elements from each subarray
        vector<int> smallest;
        vector<int> largest;
        int ans = INT_MIN;
        
        // Populate 'smallest' and 'largest' with min and max of each subarray
        for (auto& temp : arrays) {
            int p = *min_element(temp.begin(), temp.end());
            int q = *max_element(temp.begin(), temp.end());
            smallest.push_back(p);
            largest.push_back(q);
        }
        
        // Calculate maximum distance using two strategies
        int p = solve1(smallest, largest);
        int q = solve2(smallest, largest);
        return max(p, q);
    }
};

113439