[Swift]LeetCode456. 132模式 | 32 Pattern

Given a sequence of n integers a1, a2, ..., an, a 132 pattern is a subsequence ai, aj, ak such that i < j < k and ai < ak < aj. Design an algorithm that takes a list of n numbers as input and checks whether there is a 132 pattern in the list.

Note: n will be less than 15,000.

Example 1:

Input: [1, 2, 3, 4]

Output: False

Explanation: There is no 132 pattern in the sequence. 

Example 2:

Input: [3, 1, 4, 2]

Output: True

Explanation: There is a 132 pattern in the sequence: [1, 4, 2]. 

Example 3:

Input: [-1, 3, 2, 0]

Output: True

Explanation: There are three 132 patterns in the sequence: [-1, 3, 2], [-1, 3, 0] and [-1, 2, 0].


给定一个整数序列:a1, a2, ..., an,一个132模式的子序列 ai, aj, ak 被定义为:当 i < j < k时,ai < ak < aj。设计一个算法,当给定有 n 个数字的序列时,验证这个序列中是否含有132模式的子序列。

注意:n 的值小于15000。

示例1:

输入: [1, 2, 3, 4]

输出: False

解释: 序列中不存在132模式的子序列。

示例 2:

输入: [3, 1, 4, 2]

输出: True

解释: 序列中有 1 个132模式的子序列: [1, 4, 2].

示例 3:

输入: [-1, 3, 2, 0]

输出: True

解释: 序列中有 3 个132模式的的子序列: [-1, 3, 2], [-1, 3, 0] 和 [-1, 2, 0].

164ms
 1 struct Stack<T> {
 2     var items = [T]()
 3     mutating func push(item: T) {
 4         items.append(item)
 5     }
 6     mutating func pop() -> T {
 7         return items.removeLast()
 8     }
 9     func top() -> T {
10         return items.last!
11     }
12     func empty() -> Bool {
13         return items.count == 0
14     }
15 }
16
17 class Solution {
18     func find132pattern(_ nums: [Int]) -> Bool {
19         var third = Int.min
20         var s = Stack<Int>()
21         for i in stride(from: nums.count - 1, through: 0, by: -1) {
22             if nums[i] < third {
23                 return true
24             }else {
25                 while !s.empty() && (nums[i] > s.top()) {
26                     third = s.top()
27                     _ = s.pop()
28                 }
29                 s.push(item: nums[i])
30             }
31         }
32         return false
33     }
34 }


324ms

 1 class Solution {
 2     func find132pattern(_ nums: [Int]) -> Bool {
 3         var hanoi = Array<Int>.init();
 4         var medNum = Int.min
 5         for index in stride(from: nums.count-1, through: 0, by: -1) {
 6             if nums[index] < medNum {
 7                 return true
 8             } else {
 9                 while (hanoi.count > 0 && hanoi.last! < nums[index]) {
10                     medNum = hanoi.last!
11                     hanoi.removeLast()
12                 }
13             }
14             hanoi.append(nums[index])
15         }
16         return false
17     }
18 }


1348ms

 1 class Solution {
 2     func find132pattern(_ nums: [Int]) -> Bool {
 3         if nums.count < 3{
 4             return false
 5         }
 6         var newNums = [nums[0]]
 7         for i in 1..<nums.count {
 8             if nums[i] != nums[i-1]{
 9                 newNums.append(nums[i]);
10             }
11         }
12         if newNums.count < 3{
13             return false
14         }
15         var minArr = [newNums[0]]
16         var min = newNums[0]
17         for i in newNums{
18             if i < min{
19                 min = i
20             }
21             minArr.append(min)
22         }
23         for i in 1..<newNums.count-1{
24             let a = minArr[i]
25             let b = newNums[i]
26             if a >= b{
27                 continue
28             }
29             for j in (i+1)..<newNums.count{
30                 let c = newNums[j]
31                 if c > a && c < b {
32                     return true
33                 }
34             }
35         }
36         return false
37     }
38 }


4388ms

 1 class Solution {
 2     func find132pattern(_ nums: [Int]) -> Bool {
 3         if nums.count < 3 {
 4             return false
 5         }
 6         var i = nums.count
 7         var min = nums[i - 1]
 8         while (i > 0) {
 9             min = nums[i - 1]
10             var j = nums.count
11             var max = min
12             while (j > i) {
13                 let t = nums[j - 1]
14                 if t > min {
15                     if max > min {
16                         if t > max {
17                             return true
18                         }else {
19                             max = t
20                         }
21                     }else {
22                         max = t
23                     }
24                 }
25                 j = j - 1
26             }
27             i = i - 1
28         }
29         return false
30     }
31 }


6656ms

 1 class Solution {
 2     func find132pattern(_ nums: [Int]) -> Bool {
 3         var n:Int = nums.count
 4         var i:Int = 0
 5         var j:Int = 0
 6         var k:Int = 0
 7         while (i < n) {
 8             while (i < n - 1 && nums[i] >= nums[i + 1])
 9             {
10                 i += 1
11             }
12             j = i + 1;
13             while (j < n - 1 && nums[j] <= nums[j + 1])
14             {
15                  j += 1
16             }
17             k = j + 1
18             while (k < n) {
19                 if nums[k] > nums[i] && nums[k] < nums[j]
20                 {
21                      return true
22                 }
23                 k += 1
24             }
25             i = j + 1
26         }
27         return false
28     }
29 }

原文地址:https://www.cnblogs.com/strengthen/p/10343200.html

时间: 2024-07-30 12:57:28

[Swift]LeetCode456. 132模式 | 32 Pattern的相关文章

[Leetcode456] 132模式 峰谷法/单调栈

题目:https://leetcode-cn.com/problems/132-pattern/ 思路: 如果某个数左边比它小的数的最小值,小于它右边小于它的某个数(不必找最大值),那么这个序列就符合132模式的定义.如下图三点所示. 于是有解法1(峰谷法): 1 public static boolean find132pattern(int[] nums) { 2 int min = Integer.MAX_VALUE; 3 int max = Integer.MIN_VALUE; 4 bo

策略模式(Strategy Pattern)

策略模式(Strategy Pattern) 抛开晦涩的定义,首先看一个例子: 我们想要创建一个模拟鸭子的游戏,在这个游戏中,会有各种类型的鸭子,比如mallard duck,red head duck,rubber duck(除了rubber duck(橡皮鸭),看见这其余两种鸭子很好奇,于是查找相关图片,发现mallard duck是绿头鸭,red head duck是红头鸭,自己生活中还没有见过,有趣,哈哈!三种鸭子图片如下所示). 回归话题,在这个模拟鸭子的游戏中,各种鸭子均有两种能力,

LeetCode——456.132模式

给定一个整数序列:a1, a2, ..., an,一个132模式的子序列 ai, aj, ak 被定义为:当 i < j < k 时,ai < ak < aj.设计一个算法,当给定有 n 个数字的序列时,验证这个序列中是否含有132模式的子序列. 注意:n 的值小于15000. 示例1: 输入: [1, 2, 3, 4] 输出: False 解释: 序列中不存在132模式的子序列. 示例 2: 输入: [3, 1, 4, 2] 输出: True 解释: 序列中有 1 个132模式的

设计模式之七:建造模式(Builder Pattern)

建造者模式就是将一个复杂对象的构造与它的表示分离,使同样的构建过程可以创建不同的表示. 适用范围: 当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时. 当构造过程必须允许被构造的对象有不同表示时. 建造者模式里面有四个角色: Builder: 给出一个抽象接口,以规范产品对象的各个组成部分的建造.一般而言,此接口独立于应用程序的业务逻辑.模式中直接创建产品对象的具体创建者角色.具体创建者角色必须实现这个接口的所有方法:一个是建造方法,另一个是结果返还方法. ConcreteBu

设计模式 - 代理模式(proxy pattern) 未使用代理模式 详解

代理模式(proxy pattern) 未使用代理模式 详解 本文地址: http://blog.csdn.net/caroline_wendy 部分代码参考: http://blog.csdn.net/caroline_wendy/article/details/37698747 如果需要监控(monitor)类的某些状态, 则需要编写一个监控类, 并同过监控类进行监控. 但仅仅局限于本地, 如果需要远程监控, 则需要使用代理模式(proxy pattern). 具体方法: 1. 类中需要提供

设计模式 - 迭代器模式(iterator pattern) Java 迭代器(Iterator) 详解

迭代器模式(iterator pattern) Java 迭代器(Iterator) 详解 本文地址: http://blog.csdn.net/caroline_wendy 参考迭代器模式(iterator pattern): http://blog.csdn.net/caroline_wendy/article/details/35254643 Java的标准库(util)中包含迭代器接口(iterator interface), import java.util.Iterator; 继承(

设计模式 - 外观模式(facade pattern) 详解

外观模式(facade pattern) 详解 本文地址: http://blog.csdn.net/caroline_wendy 外观模式(facade pattern): 提供了一个统一的接口, 用来访问子系统中的一群接口. 外观定义了一个高层接口, 让子系统更容易使用. 外观模式包含三个部分: 1. 子系统: 子类, 单个复杂子类 或 多个子类; 2. 外观(facade)类: 把子系统设计的更加容易使用; 3. 客户: 只需要调用外观类. 与适配器模式(adapter pattern)的

[翻译] 理解贷出模式 Loan Pattern

Loan Pattern as the name suggests would loan a resource to your function. So if you break out the sentence. It would Create a resource which you can use Loan the resources to the function which would use it This function would be passed by the caller

规约模式(Specification Pattern)

前期准备之规约模式(Specification Pattern) 一.前言 在专题二中已经应用DDD和SOA的思想简单构建了一个网上书店的网站,接下来的专题中将会对该网站补充更多的DDD的内容.本专题作为一个准备专题,因为在后面一个专题中将会网上书店中的仓储实现引入规约模式.本专题将详细介绍了规约模式. 二.什么是规约模式 讲到规约模式,自然想到的是什么是规约模式呢?从名字上看,规约模式就是一个约束条件,我们在使用仓储进行查询的时候,这时候就会牵涉到很多查询条件,例如名字包含C#的书名等条件.这