1824. Minimum Sideway Jumps 贪心和DP方法

最新推荐文章于 2023-02-02 12:08:35 发布

Xurui_Luo

最新推荐文章于 2023-02-02 12:08:35 发布

阅读量193

点赞数

分类专栏：算法

本文链接：https://blog.csdn.net/Xurui_Luo/article/details/115803825

版权

算法专栏收录该内容

137 篇文章 1 订阅

订阅专栏

贪心

如果下一个位置i+1有障碍的话，从当前位置i进行跳跃就有两种情况
- 只有一个选择
  - 即当前i已经有了一个障碍，算上下一个的障碍，3-2=1 只需要选择剩下唯一的空跳即可
- 有两个选择
  - 这时候就要判断该选哪个了
  - 方法就是贪心。分别看两个选择往后，在不跳跃的情况下，最远能走多久
时间复杂度 $O(n^2)$

class Solution {
public:
    int minSideJumps(vector<int> &ob) {
        int len = ob.size();
        int res = 0;
        int num = 2;
        for (int i = 0; i < len; i++) {
            if (ob[i + 1] == num) {
                set<int> choice = {1, 2, 3};
                choice.erase(num);
                choice.erase(ob[i]);
                if (choice.size() == 1) {
                    num = *choice.begin();
                    res++;
                } else {
                    map<int, int> cntLen;
                    int a[6], t = 0;
                    for (auto &e: choice) {
                        int tmp = i;
                        while (tmp < len && ob[tmp] != e) tmp++;
                        cntLen[tmp] = e;
                        a[t++] = tmp;
                    }
                    num = cntLen[max(a[0], a[1])];
                    res++;
                }
            }
        }
        return res;
    }
};

DP

本来是 dp[i][1…3]
- i表示当前位置，3表示三个赛道
- dp[i][j] 表示到达第i个位置的第j个赛道，需要跳跃的最小次数
- 状态转移:
  $dp[i][j] = min(dp[i-1][j], dp[i-1][j_2] + 1, dp[i-1][j_3 + 1]$
后来发现 dp[i][j] 仅仅和 dp[i -1][j] 有关，因此可以只用一维数组来做
时间复杂度 $O (n)$

class Solution {
public:
    int minSideJumps(vector<int> &ob) {
        int len = ob.size();
        int dp[4];
        fill(dp, dp + 4, 1);
//        cout << dp[1] << " ";
        dp[2] = 0;
        for (int i = 1; i < len; i++) {

            int pre1 = dp[1];
            int pre2 = dp[2];
            int pre3 = dp[3];
            fill(dp, dp + 4, 0x7f7f7f);
            if (ob[i] != 1) dp[1] = pre1;
            if (ob[i] != 2) dp[2] = pre2;
            if (ob[i] != 3) dp[3] = pre3;

            if (ob[i] != 1) dp[1] = min(dp[1], min(dp[2], dp[3]) + 1);
            if (ob[i] != 2) dp[2] = min(dp[2], min(dp[1], dp[3]) + 1);
            if (ob[i] != 3) dp[3] = min(dp[3], min(dp[2], dp[1]) + 1);
        }
        return min(dp[1], min(dp[2], dp[3]));
    }
};