时间复杂度：O(n)
空间复杂度：O(1) // no extra space used except for output

class Solution {
public:
  vector<int> pivotArray(vector<int>& nums, int pivot) {
    vector<int> ans;
    for (int x: nums)
      if (x < pivot) ans.push_back(x);
    for (int x : nums)
      if (x == pivot) ans.push_back(x);
    for (int x : nums)
      if (x > pivot) ans.push_back(x);
    return ans;
  }
};

可以想到的就是滑动窗口(sliding window)，由于最长长度未知，我们可以使用动态滑动窗口。

记录当前滑动窗口中T和F出现的次数，如果其中较少的一个<=k，那么就可以全部替换它，使得整个滑动窗口都变成相同的值。如果这个时候滑动窗口长度大于当前最大长度，我们就把滑动窗口变大，右侧+1，并更新最大长度。否则，减少滑动窗口，左侧-1。

时间复杂度：O(n)
空间复杂度：O(2)

class Solution {
public:
  int maxConsecutiveAnswers(string_view A, int k) {
    int ans = 0;
    int f = 0;
    array<int, 2> count; // number of 'F' and 'T' in the sliding window
    for (int i = 0; i < A.size(); ++i) {
      ++count[A[i] == 'T'];
      if (min(count[0], count[1]) <= k && count[0] + count[1] > ans)
        ++ans;
      else
        --count[A[i - ans] == 'T'];
    }
    return ans;
  }
};

枚举所有的(nums[i], nums[j])组合，相加在和target比较。

时间复杂度：O(mn²) m为字符串的最长长度。
空间复杂度：O(m)

优化前 67ms, 49.3M

class Solution {
public:
  int numOfPairs(vector<string>& nums, string target) {
    const int n = nums.size();
    int ans = 0;
    for (int i = 0; i < n; ++i)
      for (int j = 0; j < n; ++j)
        if (i != j && nums[i] + nums[j] == target)
          ++ans;
    return ans;
  }
};

一些工程上的优化

• 用string_view作为参数类型，减少一次string copy
• 先比较长度，再判断内容。
• string_view.substr 是O(1)时间，和直接用strncmp比较内容是一样的。

优化后 3ms, 12.88MB

class Solution {
public:
  int numOfPairs(vector<string>& nums, string_view target) {
    const int n = nums.size();
    int ans = 0;
    for (int i = 0; i < n; ++i)
      for (int j = 0; j < n; ++j)
        if (i != j 
            && nums[i].size() + nums[j].size() == target.size()
            && target.substr(0, nums[i].size()) == nums[i]
            && target.substr(nums[i].size()) == nums[j])
              ++ans;
    return ans;
  }
};

可以预先使用O(n)时间计算nums[0] .. nums[i]的最大值，存在left[i]中，以及nums[i] .. nums[n-1]的最小值存在right[i]中。然后再按题目的定义计算即可。

时间复杂度：O(n)
空间复杂度：O(n)

class Solution {
public:
  int sumOfBeauties(vector<int>& nums) {
    const int n = nums.size();
    vector<int> left(n, nums[0]);
    vector<int> right(n, nums.back());
    for (int i = 1; i < n; ++i)
      left[i] = max(left[i - 1], nums[i]);
    for (int i = n - 2; i >= 0; --i)
      right[i] = min(right[i + 1], nums[i]);
    int ans = 0;
    for (int i = 1; i < n - 1; ++i)
      if (left[i - 1] < nums[i] && nums[i] < right[i + 1])
        ans += 2;
      else if (nums[i - 1] < nums[i] && nums[i] < nums[i + 1])
        ans += 1;
    return ans;
  }
};

时间复杂度：O(m*n) 每个格子最多遍历3遍。
空间复杂度：O(1)

class Solution {
public:
  vector<vector<int>> findFarmland(vector<vector<int>>& land) {
    const int m = land.size();
    const int n = land[0].size();
    vector<vector<int>> ans;
    for (int i = 0; i < m; ++i)
      for (int j = 0; j < n; ++j) {
        if (!land[i][j]) continue;
        int w = 0;
        int h = 0;
        while (j + w < n && land[i][j + w]) ++w;
        while (i + h < m && land[i + h][j]) ++h;
        ans.push_back({i, j, i + h - 1, j + w - 1});
        for (int p = 0; p < h; ++p)
          for (int q = 0; q < w; ++q)
            land[i + p][j + q] = 0; // mark as seen.
      }
    return ans;
  }
};

方法1: DP

首先还是需要对pairs的right进行排序。一方面是为了方便chaining，另一方面是可以去重。

然后定义 dp[i] := 以pairs[i]作为结尾，最长的序列的长度。

状态转移：dp[i] = max(dp[j] + 1) where pairs[i].left > pairs[j].right and 0 < j < i.

解释：对于pairs[i]，找一个最优的pairs[j]，满足pairs[i].left > pairs[j].right，这样我就可以把pairs[i]追加到以pairs[j]结尾的最长序列后面了，长度+1。

边检条件：dp[0:n] = 1，每个pair以自己作为序列的最后元素，长度为1。

时间复杂度：O(n²)
空间复杂度：O(n)

class Solution {
public:
  int findLongestChain(vector<vector<int>>& pairs) {
    sort(begin(pairs), end(pairs), [](const auto& p1, const auto& p2){
      return p1[1] < p2[1];
    });

    const int n = pairs.size();

    vector<int> dp(n, 1);
    for (int i = 0; i < n; ++i)
      for (int j = 0; j < i; ++j)
        if (pairs[i][0] > pairs[j][1])
          dp[i] = max(dp[i], dp[j] + 1);

    return *max_element(begin(dp), end(dp));
  }
};

方法2: 贪心

和DP一样，对数据进行排序。

每当我看到 cur.left > prev.right，那么就直接把cur接在prev后面。我们需要证明这么做是最优的，而不是跳过它选后面的元素。

Case 0: cur已经是最后一个元素了，跳过就不是最优解了。

假设cur后面有next, 因为已经排序过了，我们可以得知 next.right >= cur.right。

Case 1: next.right == cur.right。这时候选cur和选next对后面的决策来说是一样的，但由于Case 0的存在，我必须选cur。

Case 2: next.right > cur.right。不管left的情况怎么样，由于right更小，这时候选择cur一定是优于next。

综上所述，看到有元素可以连接起来就贪心的选它就对了。

时间复杂度：O(nlogn)
空间复杂度：O(1)

class Solution {
public:
  int findLongestChain(vector<vector<int>>& pairs) {
    sort(begin(pairs), end(pairs), [](const auto& p1, const auto& p2){
      return p1[1] < p2[1];
    });

    int right = INT_MIN;
    int ans = 0;
    for (const auto& p : pairs)
      if (p[0] > right) {
        right = p[1];
        ++ans;
      }
    return ans;
  }
};

时间复杂度：change O(logn)，find O(1)
空间复杂度：O(n)

class NumberContainers {
public:
  NumberContainers() {}
  
  void change(int index, int number) {
    if (m_.count(index)) {
      auto it = idx_.find(m_[index]);
      it->second.erase(index);
      if (it->second.empty())
        idx_.erase(it);
    }
    m_[index] = number;
    idx_[number].insert(index);
  }
  
  int find(int number) {
    auto it = idx_.find(number);
    if (it == end(idx_)) return -1;
    return *begin(it->second);
  }
private:
  unordered_map<int, int> m_; // index -> num
  unordered_map<int, set<int>> idx_; // num -> {index}
};

所有操作都是O(logn)

class TaskManager {
public:
    TaskManager(vector<vector<int>>& tasks) {
      for (const auto& task : tasks)
        add(task[0], task[1], task[2]);
    }

    void add(int userId, int taskId, int priority) {
      m_[taskId] = pq_.emplace(make_pair(priority, taskId), userId).first;
    }
    
    void edit(int taskId, int newPriority) {
      const int userId = m_[taskId]->second;
      rmv(taskId);
      add(userId, taskId, newPriority);
    }
    
    void rmv(int taskId) {
      auto it = m_.find(taskId);
      pq_.erase(it->second);
      m_.erase(it);
    }
    
    int execTop() {
      if (pq_.empty()) return -1;
      auto it = pq_.rbegin();
      const int userId = it->second;
      const int taskId = (it->first.second);
      rmv(taskId);
      return userId;
    }
  private:
    map<std::pair<int,int>, int> pq_; // (priority, taskId) -> userId;
    unordered_map<int, map<std::pair<int,int>, int>::iterator> m_; // taskId -> pq iterator
};

首先看到每次可以取任意一个nums[l] ~ nums[r]的子集

• 不能用贪心（无法找到全局最优解）
• 不能用搜索 （数据规模太大，(2^10) ^ 1000）

那只能用动态规划了

状态定义: dp[k][i][j] 能否通过使用前k个变换使得第i个数的值变成j

边界条件: dp[0][i][nums[i]] = 1，不使用任何变换，第i个数可以达到的数值就是nums[i]本身。

状态转移：dp[k][i][j] = dp[k-1][i][j] | (dp[k – 1][i][j + val[k]] if l[k] <= i <= r[k] else 0)

简单来说如果第k-1轮第i个数可以变成j + val[k]，那么第k轮就可以通过减去val[k]变成j。

上面是拉的公式，我们也可以写成推的:

dp[k][i][j – val[k]] = dp[k-1][i][j – vak[k]] | (dp[k – 1][i][j] if l[k] <= i <= r[k] else 0)

当然这么定义的话空间复杂度太高O(10^7)，由于第k轮的初始状态就等于k-1轮的状态，我们可以使用滚动数组来降维，空间复杂度降低到O(10^4)。

时间复杂度：O(k*n*MaxV) = O(10^7)。

class Solution {
public:
    int minZeroArray(vector<int>& nums, vector<vector<int>>& queries) {
      if (accumulate(begin(nums), end(nums), 0) == 0) return 0;
      constexpr int kMaxV = 1000;
      const int n = nums.size();
      const int K = queries.size();
      vector<bitset<kMaxV + 1>> dp(n);
      for (int i = 0; i < n; ++i)
        dp[i][nums[i]] = 1;
      for (int k = 0; k < K; ++k) {
        int l = queries[k][0];
        int r = queries[k][1];
        int v = queries[k][2];
        for (int i = l; i <= r; ++i)
          for (int j = 0; j <= kMaxV - v; ++j)
            if (dp[i][j + v]) dp[i][j] = 1;
        bool found = true;
        for (int i = 0; i < n; ++i)
          if (!dp[i][0]) found = false;
        if (found) return k + 1;
      }
      return -1;
    }
};

剪枝优化

上面我们把整个数组看作一个整体，一轮一轮来做。但如果某些数在第k轮能到变成0了，就没有必要参与后面的变化了，或者说它用于无法变成0，那么就是无解，其他数也就不需要再计算了。

所以，我们可以对每个数单独进行dp。即对于第i个数，计算最少需要多少轮才能把它变成0。然后对所有的轮数取一个最大值。总的时间复杂度不变（最坏情况所有数都需要经过K轮）。空间复杂度则可以再降低一个纬度到O(MaxV) = O(10^3)。

class Solution {
public:
    int minZeroArray(vector<int>& nums, vector<vector<int>>& queries) {
      constexpr int kMaxV = 1000;
      const int n = nums.size();
      const int K = queries.size();
      auto rounds = [&](int i) -> int {
        if (!nums[i]) return 0;
        bitset<kMaxV + 1> dp;
        dp[nums[i]] = 1;
        for (int k = 0; k < K; ++k) {
          int l = queries[k][0];
          int r = queries[k][1];
          int v = queries[k][2];
          if (l > i || r < i) continue;
          for (int j = 0; j <= kMaxV - v; ++j)
            if (dp[j + v]) dp[j] = 1;
          if (dp[0]) return k + 1;
        }
        return INT_MAX;
      };
      int ans = 0;
      for (int i = 0; i < n && ans <= K; ++i)
        ans = max(ans, rounds(i));
      return ans == INT_MAX ? -1 : ans;
    }
};

再加速：我们可以使用C++ bitset的右移操作符，dp >> v，相当于把整个集合全部剪去v，再和原先的状态做或运算（集合并）来达到新的状态。时间复杂度应该是一样的，只是代码简单，速度也会快不少。注: dp>>v 会创建一个临时对象，大小为O(MaxV)。

举个例子：
dp = {2, 3, 7}
dp >> 2 -> {0, 1, 5}
dp |= dp >> v -> {0, 1, 2, 3, 5, 7]

class Solution {
public:
    int minZeroArray(vector<int>& nums, vector<vector<int>>& queries) {
      constexpr int kMaxV = 1000;
      const int n = nums.size();
      const int K = queries.size();
      auto rounds = [&](int i) -> int {
        if (!nums[i]) return 0;
        bitset<kMaxV + 1> dp;
        dp[nums[i]] = 1;
        for (int k = 0; k < K; ++k) {
          int l = queries[k][0];
          int r = queries[k][1];
          int v = queries[k][2];
          if (l > i || r < i) continue;
          dp |= dp >> v; // magic
          if (dp[0]) return k + 1;
        }
        return INT_MAX;
      };
      int ans = 0;
      for (int i = 0; i < n && ans <= K; ++i)
        ans = max(ans, rounds(i));
      return ans == INT_MAX ? -1 : ans;
    }
};

Return an integer denoting the size of the kth largest perfect binary 

subtree, or -1 if it doesn’t exist.

A perfect binary tree is a tree where all leaves are on the same level, and every parent has two children.

Example 1:

Input: root = [5,3,6,5,2,5,7,1,8,null,null,6,8], k = 2

Output: 3

Explanation:

The roots of the perfect binary subtrees are highlighted in black. Their sizes, in decreasing order are [3, 3, 1, 1, 1, 1, 1, 1].
The 2nd largest size is 3.

Example 2:

Input: root = [1,2,3,4,5,6,7], k = 1

Output: 7

Explanation:

The sizes of the perfect binary subtrees in decreasing order are [7, 3, 3, 1, 1, 1, 1]. The size of the largest perfect binary subtree is 7.

Example 3:

Input: root = [1,2,3,null,4], k = 3

Output: -1

Explanation:

The sizes of the perfect binary subtrees in decreasing order are [1, 1]. There are fewer than 3 perfect binary subtrees.

Constraints:

• The number of nodes in the tree is in the range [1, 2000].
• 1 <= Node.val <= 2000
• 1 <= k <= 1024

Solution: DFS

Write a function f() to return the perfect subtree size at node n.

def f(TreeNode n):
if not n: return 0
l, r = f(n.left), f(n.right)
return l + r + 1 if l == r && l != -1 else -1

Time complexity: O(n + KlogK)
Space complexity: O(n)

class Solution {
public:
  int kthLargestPerfectSubtree(TreeNode* root, int k) {
    vector<int> ss;
    function<int(TreeNode*)> PerfectSubtree = [&](TreeNode* node) -> int {
      if (node == nullptr) return 0;
      int l = PerfectSubtree(node->left);
      int r = PerfectSubtree(node->right);
      if (l == r && l != -1) {
        ss.push_back(l + r + 1);
        return ss.back();
      }
      return -1;  
    };
    PerfectSubtree(root);
    sort(rbegin(ss), rend(ss));
    return k <= ss.size() ? ss[k - 1] : -1;
  }
};

At every second, you must perform the following operations:

• Remove the first k characters of word.
• Add any k characters to the end of word.

Note that you do not necessarily need to add the same characters that you removed. However, you must perform both operations at every second.

Return the minimum time greater than zero required for word to revert to its initial state.

Example 1:

Input: word = "abacaba", k = 3
Output: 2
Explanation: At the 1st second, we remove characters "aba" from the prefix of word, and add characters "bac" to the end of word. Thus, word becomes equal to "cababac".
At the 2nd second, we remove characters "cab" from the prefix of word, and add "aba" to the end of word. Thus, word becomes equal to "abacaba" and reverts to its initial state.
It can be shown that 2 seconds is the minimum time greater than zero required for word to revert to its initial state.

Example 2:

Input: word = "abacaba", k = 4
Output: 1
Explanation: At the 1st second, we remove characters "abac" from the prefix of word, and add characters "caba" to the end of word. Thus, word becomes equal to "abacaba" and reverts to its initial state.
It can be shown that 1 second is the minimum time greater than zero required for word to revert to its initial state.

Example 3:

Input: word = "abcbabcd", k = 2
Output: 4
Explanation: At every second, we will remove the first 2 characters of word, and add the same characters to the end of word.
After 4 seconds, word becomes equal to "abcbabcd" and reverts to its initial state.
It can be shown that 4 seconds is the minimum time greater than zero required for word to revert to its initial state.

Constraints:

• 1 <= word.length <= 50
• 1 <= k <= word.length
• word consists only of lowercase English letters.

Solution: Suffix ==? Prefix

Compare the suffix with prefix.

word = “abacaba”, k = 3
ans = 1, “abacaba” != “abacaba“
ans = 2, “abacaba” == “abacaba“, we find it.

Time complexity: O(n * n / k)
Space complexity: O(1)

class Solution {
public:
  int minimumTimeToInitialState(string_view word, int k) {
    const int n = word.length();
    for (int i = 1; i * k < n; ++i) {
      string_view t = word.substr(i * k);
      if (t == word.substr(0, t.length())) return i;
    }      
    return (n + k - 1) / k;
  }
};

You start with the string source. In one operation, you can pick a character x from the string and change it to the character y at a cost of z if there exists any index j such that cost[j] == z, original[j] == x, and changed[j] == y.

Return the minimum cost to convert the string source to the string target using any number of operations. If it is impossible to convert source to target, return -1.

Note that there may exist indices i, j such that original[j] == original[i] and changed[j] == changed[i].

Example 1:

Input: source = "abcd", target = "acbe", original = ["a","b","c","c","e","d"], changed = ["b","c","b","e","b","e"], cost = [2,5,5,1,2,20]
Output: 28
Explanation: To convert the string "abcd" to string "acbe":
- Change value at index 1 from 'b' to 'c' at a cost of 5.
- Change value at index 2 from 'c' to 'e' at a cost of 1.
- Change value at index 2 from 'e' to 'b' at a cost of 2.
- Change value at index 3 from 'd' to 'e' at a cost of 20.
The total cost incurred is 5 + 1 + 2 + 20 = 28.
It can be shown that this is the minimum possible cost.

Example 2:

Input: source = "aaaa", target = "bbbb", original = ["a","c"], changed = ["c","b"], cost = [1,2]
Output: 12
Explanation: To change the character 'a' to 'b' change the character 'a' to 'c' at a cost of 1, followed by changing the character 'c' to 'b' at a cost of 2, for a total cost of 1 + 2 = 3. To change all occurrences of 'a' to 'b', a total cost of 3 * 4 = 12 is incurred.

Example 3:

Input: source = "abcd", target = "abce", original = ["a"], changed = ["e"], cost = [10000]
Output: -1
Explanation: It is impossible to convert source to target because the value at index 3 cannot be changed from 'd' to 'e'.

Constraints:

• 1 <= source.length == target.length <= 105
• source, target consist of lowercase English letters.
• 1 <= cost.length == original.length == changed.length <= 2000
• original[i], changed[i] are lowercase English letters.
• 1 <= cost[i] <= 106
• original[i] != changed[i]

Solution: All pairs shortest path

Compute the shortest path (min cost) for any given letter pairs.

Time complexity: O(26^3 + m + n)
Space complexity: O(26^2)

class Solution {
public:
    long long minimumCost(string s, string t, vector<char>& o, vector<char>& c, vector<int>& cost) {
    const int n = c.size();
    vector<vector<int>> d(26, vector<int>(26, 1e9));
    for (int i = 0; i < 26; ++i)
      d[i][i] = 0;
    for (int i = 0; i < n; ++i)
      d[o[i] - 'a'][c[i] - 'a'] = min(d[o[i] - 'a'][c[i] - 'a'], cost[i]);
    for (int k = 0; k < 26; ++k)
      for (int i = 0; i < 26;++i)
        for (int j = 0; j < 26; ++j)
          if (d[i][k] + d[k][j] < d[i][j])
            d[i][j] = d[i][k] + d[k][j];
    long ans = 0;
    for (int i = 0; i < s.size(); ++i) {
      if (d[s[i] - 'a'][t[i] - 'a'] >= 1e9) return -1; 
      ans += d[s[i] - 'a'][t[i] - 'a'];
    }
    return ans;
  }
};

An array of distinct positive integers is called a k-avoiding array if there does not exist any pair of distinct elements that sum to k.

Return the minimum possible sum of a k-avoiding array of length n.

Example 1:

Input: n = 5, k = 4
Output: 18
Explanation: Consider the k-avoiding array [1,2,4,5,6], which has a sum of 18.
It can be proven that there is no k-avoiding array with a sum less than 18.

Example 2:

Input: n = 2, k = 6
Output: 3
Explanation: We can construct the array [1,2], which has a sum of 3.
It can be proven that there is no k-avoiding array with a sum less than 3.

Constraints:

• 1 <= n, k <= 50

Solution 1: Greedy + HashTable

Always choose the smallest possible number starting from 1.

Add all chosen numbers into a hashtable. For a new candidate i, check whether k – i is already in the hashtable.

Time complexity: O(n)
Space complexity: O(n)

// Author: Huahua
class Solution {
public:
  int minimumSum(int n, int k) {    
    int sum = 0;
    unordered_set<int> s;
    for (int i = 1; s.size() != n; ++i) {
      if (s.count(k - i)) continue;
      sum += i;
      s.insert(i);
    }
    return sum;
  }
};

In an operation, you select a set of indices in str1, and for each index i in the set, increment str1[i] to the next character cyclically. That is 'a' becomes 'b', 'b' becomes 'c', and so on, and 'z' becomes 'a'.

Return true if it is possible to make str2 a subsequence of str1 by performing the operation at most once, and false otherwise.

Note: A subsequence of a string is a new string that is formed from the original string by deleting some (possibly none) of the characters without disturbing the relative positions of the remaining characters.

Example 1:

Input: str1 = "abc", str2 = "ad"
Output: true
Explanation: Select index 2 in str1.
Increment str1[2] to become 'd'. 
Hence, str1 becomes "abd" and str2 is now a subsequence. Therefore, true is returned.

Example 2:

Input: str1 = "zc", str2 = "ad"
Output: true
Explanation: Select indices 0 and 1 in str1. 
Increment str1[0] to become 'a'. 
Increment str1[1] to become 'd'. 
Hence, str1 becomes "ad" and str2 is now a subsequence. Therefore, true is returned.

Example 3:

Input: str1 = "ab", str2 = "d"
Output: false
Explanation: In this example, it can be shown that it is impossible to make str2 a subsequence of str1 using the operation at most once. 
Therefore, false is returned.

Constraints:

• 1 <= str1.length <= 105
• 1 <= str2.length <= 105
• str1 and str2 consist of only lowercase English letters.

Solution: Two pointers

s1[i] and s2[j] can match if
s1[i] == s2[j] or inc(s1[i]) == s2[j]

If matched: ++i; ++j else ++i.

Time complexity: O(n)
Space complexity: O(1)

class Solution {
public:
  bool canMakeSubsequence(string_view s1, string_view s2) {    
    for (int i = 0, j = 0, n = s1.size(), m = s2.size(); i < n; ++i)
      if (s1[i] == s2[j] || (s1[i] - 'a' + 1) % 26 == s2[j] - 'a')
        if (++j == m) return true;
    return false;
  }
};

Iterator version

class Solution {
public:
  bool canMakeSubsequence(string_view s1, string_view s2) {    
    for (auto i = begin(s1), j = begin(s2); i != end(s1); ++i)
      if (*i == *j || (*i - 'a' + 1) % 26 == *j - 'a')
        if (++j == end(s2)) return true;
    return false;
  }
};

Let’s define another 0-indexed integer array, nums3, of length n. For each index i in the range [0, n - 1], you can assign either nums1[i] or nums2[i] to nums3[i].

Your task is to maximize the length of the longest non-decreasing subarray in nums3 by choosing its values optimally.

Return an integer representing the length of the longest non-decreasing subarray in nums3.

Note: A subarray is a contiguous non-empty sequence of elements within an array.

Example 1:

Input: nums1 = [2,3,1], nums2 = [1,2,1]
Output: 2
Explanation: One way to construct nums3 is: 
nums3 = [nums1[0], nums2[1], nums2[2]] => [2,2,1]. 
The subarray starting from index 0 and ending at index 1, [2,2], forms a non-decreasing subarray of length 2. 
We can show that 2 is the maximum achievable length.

Example 2:

Input: nums1 = [1,3,2,1], nums2 = [2,2,3,4]
Output: 4
Explanation: One way to construct nums3 is: 
nums3 = [nums1[0], nums2[1], nums2[2], nums2[3]] => [1,2,3,4]. 
The entire array forms a non-decreasing subarray of length 4, making it the maximum achievable length.

Example 3:

Input: nums1 = [1,1], nums2 = [2,2]
Output: 2
Explanation: One way to construct nums3 is: 
nums3 = [nums1[0], nums1[1]] => [1,1]. 
The entire array forms a non-decreasing subarray of length 2, making it the maximum achievable length.

Constraints:

• 1 <= nums1.length == nums2.length == n <= 105
• 1 <= nums1[i], nums2[i] <= 109

Solution: DP

Let dp1(i), dp2(i) denote the length of the Longest Non-decreasing Subarray ends with nums1[i] and nums2[i] respectively.

init: dp1(0) = dp2(0) = 1

dp1(i) = max(dp1(i – 1) + 1 if nums1[i] >= nums1[i – 1] else 1, dp2(i – 1) + 1 if nums1[i] >= nums2[i – 1] else 1)
dp2(i) = max(dp1(i – 1) + 1 if nums2[i] >= nums1[i – 1] else 1, dp2(i – 1) + 1 if nums2[i] >= nums2[i – 1] else 1)

ans = max(dp1, dp2)

Time complexity: O(n)
Space complexity: O(n) -> O(1)

# Author: Huahua
class Solution:
  def maxNonDecreasingLength(self, nums1: List[int], nums2: List[int]) -> int:
    n = len(nums1)
    nums = [nums1, nums2]

    @cache
    def dp(i: int, j: int):
      if i == 0: return 1
      ans = 1
      for k in range(2):
        if nums[j][i] >= nums[k][i - 1]:
          ans = max(ans, dp(i - 1, k) + 1)
      return ans

    return max(max(dp(i, 0), dp(i, 1)) for i in range(n))

// Author: Huahua
class Solution {
public:
  int maxNonDecreasingLength(vector<int>& nums1, vector<int>& nums2) {
    int ans = 1;
    for (int i = 1, dp1 = 1, dp2 = 1; i < nums1.size(); ++i) {
      int t1 = max(nums1[i] >= nums1[i - 1] ? dp1 + 1 : 1, 
                   nums1[i] >= nums2[i - 1] ? dp2 + 1 : 1);
      int t2 = max(nums2[i] >= nums1[i - 1] ? dp1 + 1 : 1, 
                   nums2[i] >= nums2[i - 1] ? dp2 + 1 : 1);
      dp1 = t1;
      dp2 = t2;
      ans = max({ans, dp1, dp2});
    }
    return ans;
  }
};