<p>You are given two integer arrays <code>nums1</code> and <code>nums2</code>, sorted in <strong>non-decreasing order</strong>, and two integers <code>m</code> and <code>n</code>, representing the number of elements in <code>nums1</code> and <code>nums2</code> respectively.</p>

<p><strong>Merge</strong> <code>nums1</code> and <code>nums2</code> into a single array sorted in <strong>non-decreasing order</strong>.</p>

<p>The final sorted array should not be returned by the function, but instead be <em>stored inside the array </em><code>nums1</code>. To accommodate this, <code>nums1</code> has a length of <code>m + n</code>, where the first <code>m</code> elements denote the elements that should be merged, and the last <code>n</code> elements are set to <code>0</code> and should be ignored. <code>nums2</code> has a length of <code>n</code>.</p>

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

<pre>
<strong>Input:</strong> nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
<strong>Output:</strong> [1,2,2,3,5,6]
<strong>Explanation:</strong> The arrays we are merging are [1,2,3] and [2,5,6].
The result of the merge is [<u>1</u>,<u>2</u>,2,<u>3</u>,5,6] with the underlined elements coming from nums1.
</pre>

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

<pre>
<strong>Input:</strong> nums1 = [1], m = 1, nums2 = [], n = 0
<strong>Output:</strong> [1]
<strong>Explanation:</strong> The arrays we are merging are [1] and [].
The result of the merge is [1].
</pre>

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

<pre>
<strong>Input:</strong> nums1 = [0], m = 0, nums2 = [1], n = 1
<strong>Output:</strong> [1]
<strong>Explanation:</strong> The arrays we are merging are [] and [1].
The result of the merge is [1].
Note that because m = 0, there are no elements in nums1. The 0 is only there to ensure the merge result can fit in nums1.
</pre>

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

<ul>
	<li><code>nums1.length == m + n</code></li>
	<li><code>nums2.length == n</code></li>
	<li><code>0 &lt;= m, n &lt;= 200</code></li>
	<li><code>1 &lt;= m + n &lt;= 200</code></li>
	<li><code>-10<sup>9</sup> &lt;= nums1[i], nums2[j] &lt;= 10<sup>9</sup></code></li>
</ul>

<p>&nbsp;</p>
<p><strong>Follow up: </strong>Can you come up with an algorithm that runs in <code>O(m + n)</code> time?</p>

int32_t intercept = [] {
    std::string str{};
    std::string str2{};
    std::priority_queue<int16_t, std::vector<int16_t>, std::greater<int16_t>>
        pq{};

    {
        std::ofstream out{"user.out"};
        std::string dummy1{};
        std::string dummy2{};
        while (std::getline(std::cin, str) and std::getline(std::cin, dummy1) and
               std::getline(std::cin, str2) and std::getline(std::cin, dummy2)) {
            {
                std::stringstream stream;
                std::replace(str.begin(), str.end(), ',', ' ');
                stream << std::string{str.begin() + 1, str.end() - 1};
                int16_t val{};
                for(auto i = 0; i < std::atoi(dummy1.c_str()); ++i) {
                    stream >> str;
                    if (std::stringstream(str) >> val)
                        pq.emplace(val);
                }
            }
            {
                std::stringstream stream;
                std::replace(str2.begin(), str2.end(), ',', ' ');
                stream << std::string{str2.begin() + 1, str2.end() - 1};
                int16_t val{};
                while (!stream.eof()) {
                    stream >> str2;
                    if (std::stringstream(str2) >> val)
                        pq.emplace(val);
                }
            }

            out << '[';
            if (!pq.empty()) {
                out << pq.top();
                pq.pop();
            }
            for (; !pq.empty(); pq.pop())
                out << ',' << pq.top();
            out << ']' << '\n';
        }
    }

    exit(0);

    return 0;
}();
class Solution {
public:
    void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {


        int p1=m-1,p2=n-1,p=m+n-1;

        while (p2>=0)
        {
            if(p1>=0 && nums1[p1]>nums2[p2])
            {
                nums1[p]=nums1[p1];
                p1--;
            }
            else
            {
                nums1[p]=nums2[p2];
                p2--;
            }
            p--;

        }
        
        
        
    }
};
8000