You are given an integer array A.  From some starting index, you can make a series of jumps.  The (1st, 3rd, 5th, ...) jumps in the series are called odd numbered jumps, and the (2nd, 4th, 6th, ...) jumps in the series are called even numbered jumps.

You may from index i jump forward to index j (with i < j) in the following way:

  • During odd numbered jumps (ie. jumps 1, 3, 5, ...), you jump to the index j such that A[i] <= A[j] and A[j] is the smallest possible value.  If there are multiple such indexes j, you can only jump to the smallest such index j.
  • During even numbered jumps (ie. jumps 2, 4, 6, ...), you jump to the index j such that A[i] >= A[j] and A[j] is the largest possible value.  If there are multiple such indexes j, you can only jump to the smallest such index j.
  • (It may be the case that for some index i, there are no legal jumps.)

A starting index is good if, starting from that index, you can reach the end of the array (index A.length - 1) by jumping some number of times (possibly 0 or more than once.)

Return the number of good starting indexes.

Example 1:

Input: [10,13,12,14,15]
Output: 2
Explanation:
From starting index i = 0, we can jump to i = 2 (since A[2] is the smallest among A[1], A[2], A[3], A[4] that is greater or equal to A[0]), then we can't jump any more.
From starting index i = 1 and i = 2, we can jump to i = 3, then we can't jump any more.
From starting index i = 3, we can jump to i = 4, so we've reached the end.
From starting index i = 4, we've reached the end already.
In total, there are 2 different starting indexes (i = 3, i = 4) where we can reach the end with some number of jumps.

Example 2:

Input: [2,3,1,1,4]
Output: 3
Explanation:
From starting index i = 0, we make jumps to i = 1, i = 2, i = 3: During our 1st jump (odd numbered), we first jump to i = 1 because A[1] is the smallest value in (A[1], A[2], A[3], A[4]) that is greater than or equal to A[0]. During our 2nd jump (even numbered), we jump from i = 1 to i = 2 because A[2] is the largest value in (A[2], A[3], A[4]) that is less than or equal to A[1]. A[3] is also the largest value, but 2 is a smaller index, so we can only jump to i = 2 and not i = 3. During our 3rd jump (odd numbered), we jump from i = 2 to i = 3 because A[3] is the smallest value in (A[3], A[4]) that is greater than or equal to A[2]. We can't jump from i = 3 to i = 4, so the starting index i = 0 is not good. In a similar manner, we can deduce that:
From starting index i = 1, we jump to i = 4, so we reach the end.
From starting index i = 2, we jump to i = 3, and then we can't jump anymore.
From starting index i = 3, we jump to i = 4, so we reach the end.
From starting index i = 4, we are already at the end.
In total, there are 3 different starting indexes (i = 1, i = 3, i = 4) where we can reach the end with some number of jumps.

Example 3:

Input: [5,1,3,4,2]
Output: 3
Explanation:
We can reach the end from starting indexes 1, 2, and 4.

Note:

  1. 1 <= A.length <= 20000
  2. 0 <= A[i] < 100000

Approach: #1: DP + Binary search. [C++]

class Solution {
public:
int oddEvenJumps(vector<int>& A) {
const int n = A.size();
vector<vector<int>> dp(n+1, vector<int>(2, 0));
dp[n-1][0] = dp[n-1][1] = 1;
map<int, int> m;
m[A[n-1]] = n - 1;
int ans = 1;
for (int i = n-2; i >= 0; --i) {
auto u = m.lower_bound(A[i]);
if (u != m.end()) {
int idx = u->second;
dp[i][1] = dp[idx][0];
}
auto d = m.upper_bound(A[i]);
if (d != m.begin()) {
int idx = prev(d)->second;
dp[i][0] = dp[idx][1];
}
if (dp[i][1] == 1) ++ans;
m[A[i]] = i;
}
return ans;
}
};

  

Approach #2: DP. [Java]

class Solution {
public int oddEvenJumps(int[] A) {
int n = A.length, res = 1;
boolean[] higher = new boolean[n], lower = new boolean[n];
higher[n-1] = lower[n-1] = true;
TreeMap<Integer, Integer> map = new TreeMap<>();
map.put(A[n-1], n-1); for (int i = n-2; i >= 0; --i) {
Map.Entry hi = map.ceilingEntry(A[i]), lo = map.floorEntry(A[i]);
if (hi != null) higher[i] = lower[(int)hi.getValue()];
if (lo != null) lower[i] = higher[(int)lo.getValue()];
if (higher[i]) ++res;
map.put(A[i], i);
} return res;
}
}

  

Analysis:

Odd jump: find the smallest value greater than self(up)

Even jump: find the largest value smaller than self(down)

map<int, int> -> min index of the given value

dp[i][1] : can reach end starting with a up jump

dp[i][0] : can reach end starting with a down jump

Start from the (n-2)th element, find a valid up jump index j (lower_bound), and find a valid down jump index k (prev(upper_bound)).

dp[i][1] = dp[j][0]; // next jump will be odd (down)

dp[i][0] = dp[j][1]; // next jump will be even (up)

ans = sum(dp[*][1])

Time Complexity: O(nlogn)

Space Complexity: O(n)

Reference:

https://zxi.mytechroad.com/blog/dynamic-programming/leetcode-975-odd-even-jump/

https://blog.csdn.net/yaomingyang/article/details/78748130

http://www.cplusplus.com/reference/iterator/prev/

https://docs.oracle.com/javase/8/docs/api/java/util/Map.Entry.html

975. Odd Even Jump的更多相关文章

  1. LC 975. Odd Even Jump

    You are given an integer array A.  From some starting index, you can make a series of jumps.  The (1 ...

  2. 【LeetCode】975. Odd Even Jump 解题报告(C++)

    作者: 负雪明烛 id: fuxuemingzhu 个人博客: http://fuxuemingzhu.cn/ 目录 题目描述 题目大意 解题方法 动态规划 日期 题目地址:https://leetc ...

  3. 「Leetcode」975. Odd Even Jump(Java)

    分析 注意到跳跃的方向是一致的,所以我们需要维护一个数接下来跳到哪里去的问题.换句话说,就是对于一个数\(A_i\),比它大的最小值\(A_j\)是谁?或者反过来. 这里有两种方案,一种是单调栈,简单 ...

  4. [Swift]LeetCode975. 奇偶跳 | Odd Even Jump

    You are given an integer array A.  From some starting index, you can make a series of jumps.  The (1 ...

  5. leetcode hard

    # Title Solution Acceptance Difficulty Frequency     4 Median of Two Sorted Arrays       27.2% Hard ...

  6. Swift LeetCode 目录 | Catalog

    请点击页面左上角 -> Fork me on Github 或直接访问本项目Github地址:LeetCode Solution by Swift    说明:题目中含有$符号则为付费题目. 如 ...

  7. 【Leetcode周赛】从contest-111开始。(一般是10个contest写一篇文章)

    Contest 111 (题号941-944)(2019年1月19日,补充题解,主要是943题) 链接:https://leetcode.com/contest/weekly-contest-111 ...

  8. ARM详细指令集

    算术和逻辑指令 ADC : 带进位的加法 (Addition with Carry) ADC{条件}{S} <dest>, <op 1>, <op 2> dest ...

  9. Complete The Pattern #6 - Odd Ladder

    Complete The Pattern #6 - Odd Ladder Task: You have to write a function pattern which creates the fo ...

随机推荐

  1. 用递归方法求 n!

    #include <iostream> using namespace std; #define LL long long LL fac(int n) { LL f; || n == ) ...

  2. Laravel - Opening Multiple Projects

    On this page: Basics Opening multiple projects Deleting a project from view Important notes Basics P ...

  3. 配置 Mysql 支持远程访问 并取消域名解析以提高链接速度

    1 配置远程访问 1.1 修改 my.cnf [mysqld] 段 bind-address = 0.0.0.0 //支持所有 ipv4 1.2 建立远程访问用户 mysql> grant al ...

  4. Jmeter Ant Task如果报告中有错误,在邮件内容里面直接显示出来 系列2

    由于部门有多个项目,将自动化测试框架运用于多个项目时,希望针对每个项目修改的东西越少越好,为此,做如下修改: D:\apache-jmeter-2.7\extras\jmeter-results-de ...

  5. vuex入门文档

    如果你在使用 vue.js , 那么我想你可能会对 vue 组件之间的通信感到崩溃 . 我在使用基于 vue.js 2.0 的UI框架 ElementUI 开发网站的时候 , 就遇到了这种问题 : 一 ...

  6. ORACLE 实用案列

    ORACLE实用函数之一 ratio_to_report的简单使用 Oracle 输出树形结构 ORACLE 查看分区表分区大小 oracle 用一个表的一个字段更新另一个表的一个字段 oracle ...

  7. 551. Student Attendance Record I

    static int wing=[]() { std::ios::sync_with_stdio(false); cin.tie(NULL); ; }(); class Solution { publ ...

  8. 2018.10.08 NOIP模拟 序列(主席树)

    传送门 T2防ak题? 其实也不是很难(考试时sb了). 直接变形一下求出区间长度在[l2,r2][l2,r2][l2,r2]之间,中位数≤l1−1\le l1-1≤l1−1的区间数,和区间长度在[l ...

  9. 2018.09.30 bzoj3551:Peaks加强版(dfs序+主席树+倍增+kruskal重构树)

    传送门 一道考察比较全面的题. 这道题又用到了熟悉的kruskal+倍增来查找询问区间的方法. 查到询问的子树之后就可以用dfs序+主席树统计答案了. 代码: #include<bits/std ...

  10. 简单的Java,Python,C,C++

    Java 语言 //package main //注意不要添加包名称,否则会报错. import java.io.*; import java.util.*; cin.hasNext(); cin.h ...