We have two integer sequences A and B of the same non-zero length.

We are allowed to swap elements A[i] and B[i].  Note that both elements are in the same index position in their respective sequences.

At the end of some number of swaps, A and B are both strictly increasing.  (A sequence is strictly increasing if and only if A[0] < A[1] < A[2] < ... < A[A.length - 1].)

Given A and B, return the minimum number of swaps to make both sequences strictly increasing.  It is guaranteed that the given input always makes it possible.

Example:
Input: A = [1,3,5,4], B = [1,2,3,7]
Output: 1
Explanation:
Swap A[3] and B[3]. Then the sequences are:
A = [1, 3, 5, 7] and B = [1, 2, 3, 4]
which are both strictly increasing.

Note:

  • A, B are arrays with the same length, and that length will be in the range [1, 1000].
  • A[i], B[i] are integer values in the range [0, 2000].

给两个长度相等的数组A和B,可在任意位置i交换A[i]和B[i]的值,使得数组A和B变成严格递增的数组,求最少需要交换的次数。

解法:dp

Java:

class Solution {
public int minSwap(int[] A, int[] B) {
int swapRecord = 1, fixRecord = 0;
for (int i = 1; i < A.length; i++) {
if (A[i - 1] >= B[i] || B[i - 1] >= A[i]) {
// In this case, the ith manipulation should be same as the i-1th manipulation
// fixRecord = fixRecord;
swapRecord++;
} else if (A[i - 1] >= A[i] || B[i - 1] >= B[i]) {
// In this case, the ith manipulation should be the opposite of the i-1th manipulation
int temp = swapRecord;
swapRecord = fixRecord + 1;
fixRecord = temp;
} else {
// Either swap or fix is OK. Let's keep the minimum one
int min = Math.min(swapRecord, fixRecord);
swapRecord = min + 1;
fixRecord = min;
}
}
return Math.min(swapRecord, fixRecord);
}
}  

Python:

class Solution(object):
def minSwap(self, A, B):
"""
:type A: List[int]
:type B: List[int]
:rtype: int
"""
dp_no_swap, dp_swap = [0]*2, [1]*2
for i in xrange(1, len(A)):
dp_no_swap[i%2], dp_swap[i%2] = float("inf"), float("inf")
if A[i-1] < A[i] and B[i-1] < B[i]:
dp_no_swap[i%2] = min(dp_no_swap[i%2], dp_no_swap[(i-1)%2])
dp_swap[i%2] = min(dp_swap[i%2], dp_swap[(i-1)%2]+1)
if A[i-1] < B[i] and B[i-1] < A[i]:
dp_no_swap[i%2] = min(dp_no_swap[i%2], dp_swap[(i-1)%2])
dp_swap[i%2] = min(dp_swap[i%2], dp_no_swap[(i-1)%2]+1)
return min(dp_no_swap[(len(A)-1)%2], dp_swap[(len(A)-1)%2])  

C++:

class Solution {
public:
int minSwap(vector<int>& A, vector<int>& B) {
int n = A.size();
vector<int> swap(n, n), noSwap(n, n);
swap[0] = 1; noSwap[0] = 0;
for (int i = 1; i < n; ++i) {
if (A[i] > A[i - 1] && B[i] > B[i - 1]) {
swap[i] = swap[i - 1] + 1;
noSwap[i] = noSwap[i - 1];
}
if (A[i] > B[i - 1] && B[i] > A[i - 1]) {
swap[i] = min(swap[i], noSwap[i - 1] + 1);
noSwap[i] = min(noSwap[i], swap[i - 1]);
}
}
return min(swap[n - 1], noSwap[n - 1]);
}
};

C++:

class Solution {
public:
int minSwap(vector<int>& A, vector<int>& B) {
int n1 = 0, s1 = 1, n = A.size();
for (int i = 1; i < n; ++i) {
int n2 = INT_MAX, s2 = INT_MAX;
if (A[i - 1] < A[i] && B[i - 1] < B[i]) {
n2 = min(n2, n1);
s2 = min(s2, s1 + 1);
}
if (A[i - 1] < B[i] && B[i - 1] < A[i]) {
n2 = min(n2, s1);
s2 = min(s2, n1 + 1);
}
n1 = n2;
s1 = s2;
}
return min(n1, s1);
}
};

  

类似题目:

Best Time to Buy and Sell Stock with Transaction Fee  

All LeetCode Questions List 题目汇总

[LeetCode] 801. Minimum Swaps To Make Sequences Increasing 最少交换使得序列递增的更多相关文章

  1. LeetCode 801. Minimum Swaps To Make Sequences Increasing

    原题链接在这里:https://leetcode.com/problems/minimum-swaps-to-make-sequences-increasing/ 题目: We have two in ...

  2. 801. Minimum Swaps To Make Sequences Increasing

    We have two integer sequences A and B of the same non-zero length. We are allowed to swap elements A ...

  3. 【LeetCode】801. Minimum Swaps To Make Sequences Increasing 解题报告(Python)

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

  4. 【leetcode】801. Minimum Swaps To Make Sequences Increasing

    题目如下: We have two integer sequences A and B of the same non-zero length. We are allowed to swap elem ...

  5. 801. Minimum Swaps To Make Sequences Increasing 为使两个数组严格递增,所需要的最小交换次数

    [抄题]: We have two integer sequences A and B of the same non-zero length. We are allowed to swap elem ...

  6. [LeetCode] Minimum Swaps To Make Sequences Increasing 使得序列递增的最小交换

    We have two integer sequences A and B of the same non-zero length. We are allowed to swap elements A ...

  7. [Swift]LeetCode801. 使序列递增的最小交换次数 | Minimum Swaps To Make Sequences Increasing

    We have two integer sequences A and B of the same non-zero length. We are allowed to swap elements A ...

  8. [LeetCode] 727. Minimum Window Subsequence 最小窗口序列

    Given strings S and T, find the minimum (contiguous) substring W of S, so that T is a subsequence of ...

  9. 【LeetCode】Minimum Depth of Binary Tree 二叉树的最小深度 java

    [LeetCode]Minimum Depth of Binary Tree Given a binary tree, find its minimum depth. The minimum dept ...

随机推荐

  1. xpath+多进程爬取八零电子书百合之恋分类下所有小说。

    代码 # 需要的库 import requests from lxml import etree from multiprocessing import Pool import os # 请求头 he ...

  2. 51nod 2489 小b和灯泡

    小b有n个关闭的灯泡,编号为1...n. 小b会进行n轮操作,第i轮她会将编号为i的倍数的灯泡的开关状态取反,即开变成关,关变成开. 求n轮操作后,有多少灯泡是亮着的. 收起   输入 输入一个数字表 ...

  3. linux ssh tunnel

    ssh -qTfnN -D 7070 ape@192.168.1.35

  4. cyyz: Day 6 平衡树整理

    一.平衡树 知识点: ,并且左右两个子树都是一棵平衡二叉树.平衡二叉树的常用实现方法有红黑树.AVL.替罪羊树.Treap.伸展树等. 最小二叉平衡树的节点的公式如下 F(n)=F(n-1)+F(n- ...

  5. [CSP-S 2019]括号树

    [CSP-S 2019]括号树 源代码: #include<cstdio> #include<cctype> #include<vector> inline int ...

  6. python 判断一个字符串组合后,是否在另一个字符串中

    code #coding=utf- def getdic(s): dic = {} for i in s: if (i not in dic): dic[i] = else: dic[i] += re ...

  7. Android中LayoutInflater()方法

    在实际开发中LayoutInflater这个类还是非常有用的,它的作用类似于findViewById().不同点是LayoutInflater是用来找res/layout/下的xml布局文件,并且实例 ...

  8. centos6 启动docker报错

    1.启动docker报错: # service docker stop Stopping docker: [ OK ] [root@RSING data2]# service docker start ...

  9. Markdown 打出上下标

    1. 打上标,下标 2<sup>10</sup> <!--下标--> 2.同时打上下标 $x^p_ {ij}$ <!--上标为p,下标为ij,{}是用来组合i ...

  10. 新版本Mariadb安装后相关问题的解决

    给新机器Ubuntu安装的Mariadb后无法登录,通过网上各种方法修改root用户密码,仍然无法解决,耗费几个小时! 经过看日志和查手册,发现原因如下: ubuntu确实安装没有启用root用户,所 ...