[Swift]LeetCode1013. 将数组分成和相等的三个部分 | Partition Array Into Three Parts With Equal Sum...

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号:山青咏芝(shanqingyongzhi)
➤博客园地址:山青咏芝(https://www.cnblogs.com/strengthen/)
➤GitHub地址:https://github.com/strengthen/LeetCode
➤原文地址: https://www.cnblogs.com/strengthen/p/10587854.html 
➤如果链接不是山青咏芝的博客园地址,则可能是爬取作者的文章。
➤原文已修改更新!强烈建议点击原文地址阅读!支持作者!支持原创!
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

Given an array A of integers, return true if and only if we can partition the array into three non-emptyparts with equal sums.

Formally, we can partition the array if we can find indexes i+1 < j with (A[0] + A[1] + ... + A[i] == A[i+1] + A[i+2] + ... + A[j-1] == A[j] + A[j-1] + ... + A[A.length - 1])

Example 1:

Input: [0,2,1,-6,6,-7,9,1,2,0,1]
Output: true
Explanation: 0 + 2 + 1 = -6 + 6 - 7 + 9 + 1 = 2 + 0 + 1

Example 2:

Input: [0,2,1,-6,6,7,9,-1,2,0,1]
Output: false

Example 3:

Input: [3,3,6,5,-2,2,5,1,-9,4]
Output: true
Explanation: 3 + 3 = 6 = 5 - 2 + 2 + 5 + 1 - 9 + 4

Note:

  1. 3 <= A.length <= 50000
  2. -10000 <= A[i] <= 10000

给定一个整数数组 A,只有我们可以将其划分为三个和相等的非空部分时才返回 true,否则返回 false

形式上,如果我们可以找出索引 i+1 < j 且满足 (A[0] + A[1] + ... + A[i] == A[i+1] + A[i+2] + ... + A[j-1] == A[j] + A[j-1] + ... + A[A.length - 1]) 就可以将数组三等分。

示例 1:

输出:[0,2,1,-6,6,-7,9,1,2,0,1]
输出:true
解释:0 + 2 + 1 = -6 + 6 - 7 + 9 + 1 = 2 + 0 + 1

示例 2:

输入:[0,2,1,-6,6,7,9,-1,2,0,1]
输出:false

示例 3:

输入:[3,3,6,5,-2,2,5,1,-9,4]
输出:true
解释:3 + 3 = 6 = 5 - 2 + 2 + 5 + 1 - 9 + 4

提示:

  1. 3 <= A.length <= 50000
  2. -10000 <= A[i] <= 10000

Runtime: 364 ms
Memory Usage: 19.5 MB
 1 class Solution {
 2     func canThreePartsEqualSum(_ A: [Int]) -> Bool {
 3         var sum:Int = 0
 4         var n:Int = A.count
 5         for i in 0..<n {sum += A[i]}
 6         if sum % 3 != 0 {return false}
 7         sum /= 3
 8         var cnt:Int = 0
 9         var ok:Int = 0
10         for i in 0..<n
11         {
12             cnt += A[i]
13             if sum == cnt && ok != 2
14             {
15                 cnt = 0
16                 ok += 1
17             }
18         }
19         return ok == 2 && sum == cnt        
20     }
21 }

364ms
 1 class Solution {
 2     func canThreePartsEqualSum(_ A: [Int]) -> Bool {
 3         var total = 0
 4         for i in 0..<A.count {
 5             total = total + A[i]
 6         }
 7         
 8         let target = total / 3
 9         if total % 3 != 0 {
10             return false
11         }
12         
13         var sum = 0
14         var count = 0
15         for i in 0..<A.count {
16             sum = sum + A[i]
17             if sum == target {
18                 count = count + 1
19                 sum = 0
20                 continue
21             }
22         }
23 
24         if count == 3 && sum == 0 {
25             return true
26         }
27         
28         return false
29     }
30 }

372ms

 1 class Solution {
 2     func canThreePartsEqualSum(_ A: [Int]) -> Bool {
 3         let count = A.count
 4         var sum = 0
 5         for item in A {
 6             sum = sum + item
 7         }
 8         guard sum % 3 == 0 else { return false }
 9         let part = Int(sum / 3)
10         print(part)
11         var i = -1
12         var j = count
13         var part1 = 0
14         var part2 = 0
15         while i+1<j {
16             i = i + 1
17             j = j - 1
18             var checkPart1 = true
19             if checkPart1 {
20                 checkPart1 = false
21                 while part1 != part && i < j+1 {
22                     part1 = part1 + A[i]
23                     i = i + 1
24                 }
25                 i = i - 1
26                 if i+1 > j {
27                     return false
28                 }
29             }
30             
31             var checkPart2 = true
32             if checkPart2 {
33                 checkPart2 = false
34                 while part2 != part && i < j+1 {
35                     part2 = part2 + A[j]
36                     j = j - 1
37                 }
38                 j = j + 1
39                 if i+1 > j {
40                     return false
41                 }
42             }
43 
44             if part1 == part2, part1 == part, i < j {
45                 return true
46             }
47         }
48         return false
49     }
50 }

376ms

 1 class Solution {
 2     func canThreePartsEqualSum(_ A: [Int]) -> Bool {
 3         let aSum = A.reduce(0, +)
 4         if aSum % 3 != 0 {
 5             return false
 6         }
 7         let expectedSectionSum = aSum / 3
 8         var expectedSectionSumSeenCount = 0
 9         var currentSectionSum = 0
10         for i in 0..<A.count {
11             let value = A[i]
12             if value == 0 {
13                 continue
14             }
15             currentSectionSum += value
16             if currentSectionSum == expectedSectionSum {
17                 expectedSectionSumSeenCount += 1
18                 currentSectionSum = 0
19             }
20         }
21         return expectedSectionSumSeenCount == 3
22     }
23 }

380ms

 1 class Solution {
 2     func canThreePartsEqualSum(_ A: [Int]) -> Bool {
 3         let sum = A.reduce(0, +)
 4         guard sum % 3 == 0 else { return false }
 5         let target = sum / 3
 6         var split = [Int](), currSum = 0
 7         for i in 0..<A.count {
 8             currSum += A[i]
 9             if currSum == target {
10                 split.append(i)
11                 currSum = 0
12             }
13         }
14         return split.count >= 2 && 0 <= split[0] && split[0] < split[1] && split[1] < A.count
15     }
16 }

400ms

 1 class Solution {
 2     func canThreePartsEqualSum(_ A: [Int]) -> Bool {
 3         guard A.count >= 3 else {
 4             return false
 5         }
 6         
 7         let sum = A.reduce(0) { $0 + $1 }
 8         guard sum % 3 == 0 else {
 9             return false
10         }
11         let partition = sum / 3
12         var count = 0 
13         var current = 0
14         for a in A {
15             current += a
16             if current == partition {
17                 count += 1
18                 current = 0
19             }
20         }
21         return count != 0 && count % 3 == 0
22     }
23 }

408ms

 1 class Solution {  
 2   func canThreePartsEqualSum(_ A: [Int]) -> Bool {
 3     var firstSum = 0
 4     let total = A.reduce(0, +)
 5     for (index, element) in A.enumerated() {
 6       firstSum += element
 7       let twoSums = total - firstSum
 8       if twoSums % 2 == 0 {
 9         if twoSums / 2 == firstSum && A.count - index > 2 {
10           let subarray: [Int] = Array(A[index..<A.count])
11           return validateSecondPart(subarray, withSum: firstSum)
12         }
13       }
14     }
15     return false
16   }
17   
18   func validateSecondPart(_ a: [Int], withSum sum: Int) -> Bool {
19     var leftover = a.reduce(0, +)
20     for (index, element) in a.enumerated() {
21       leftover -= element
22       if leftover == sum && a.count - index > 1 {
23         return true
24       }
25     }
26     return false
27   }
28 }

420ms

 1 class Solution {
 2     func canThreePartsEqualSum(_ A: [Int]) -> Bool {
 3         guard A.count >= 3 else { return false }
 4 
 5         var prefixSums = Array(repeating: 0, count: A.count + 1)
 6 
 7         for (i, num) in A.enumerated() {
 8             prefixSums[i + 1] = prefixSums[i] + num
 9         }
10 
11         let sum = prefixSums.last!
12 
13         guard sum % 3 == 0 else { return false }
14 
15         let partitionSum = sum / 3
16 
17         var a: Int?
18         var b: Int?
19 
20         for (i, num) in prefixSums.enumerated() {
21             if num == partitionSum && a == nil {
22                 a = i
23             } else if num == (partitionSum * 2) && b == nil && a != nil {
24                 b = i
25                 return true
26             }
27         }
28 
29         return false
30     }
31 }

440ms

 1 class Solution {
 2     func canThreePartsEqualSum(_ A: [Int]) -> Bool {
 3         if A.count < 3 {
 4             return false
 5         }
 6         if A.count == 3 {
 7             return (A[0] == A[1]) && (A[0] == A[2]) && (A[1] == A[2])
 8         }
 9         // start for the match.
10         var first = false
11         var second = false
12         var third = false
13         var firstSum = 0
14         var secondSum = 0
15         var thirdSum = 0
16         let totalSum = A.reduce(0,+)
17         if (totalSum % 3) != 0 {
18             return false
19         }
20         for number in A {
21             firstSum += number
22             if !first && (firstSum == (totalSum / 3)) {
23                 print("First met")
24                 first = true
25                 continue
26             }
27             if first && !second{
28                     secondSum += number
29                     if secondSum == (totalSum / 3) {
30                         print("Second met")
31                         second = true
32                         continue
33                     }
34             }
35             if second {
36                 thirdSum += number
37                     if thirdSum == (totalSum / 3) {
38                         print("Third met")
39                     }
40             }
41         }
42         if thirdSum == (totalSum / 3) {
43             return true
44         }
45         return false
46     }
47 }

452ms

 1 class Solution {
 2     func canThreePartsEqualSum(_ A: [Int]) -> Bool {
 3         var prefix: [Int] = [0]
 4         prefix.reserveCapacity(A.count + 1)
 5         for a in A {
 6             prefix.append(prefix.last! + a)
 7         }
 8         
 9         var first: Int?
10         var second: Int?
11         
12         guard prefix.last! % 3 == 0 else {
13             return false
14         }
15         
16         let oneThird = prefix.last! / 3
17         for (i, p) in prefix.enumerated() {
18             if p == oneThird {
19                 first = i
20                 break
21             }
22         }
23         
24         let twoThird = oneThird * 2
25         for (i, p) in prefix.enumerated().reversed() {
26              if p == twoThird {
27                 second = i
28                 break
29             }
30         }
31         
32         if let first = first,
33             let second = second {
34                 return first < second
35         }
36         
37         return false
38     }
39 }

 

转载于:https://www.cnblogs.com/strengthen/p/10587854.html

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/278116.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

京津冀产业协同升级 智慧城市等高端产业需求遇热

云计算、智慧交通、城市环保科技等高端智慧城市产业项目正成为京津冀产业协同的新关注点。 21日&#xff0c;在由北京市经信委、天津市工信委、河北省工信厅联合组织的京津冀产业协同发展招商推介专项行动上&#xff0c;超过200家与会企业共完成产业对接项目额达311.7亿元。与以…

Microsoft Teams:删除成员账户其历史聊天会发生什么?

介绍&#xff1a; 此博客文章的目的是演示从Office 365删除用户的账号后&#xff0c;此用户在Microsoft Teams群聊和私聊中的历史聊天记录会发生什么改变。 以下是Microsoft Teams聊天对话&#xff0c;其中Adele和其他团队成员正在参与对话&#xff1a; 此外, Adele和Mega还在…

PostgreSQL Huge Page 使用建议 - 大内存主机、实例注意

标签 PostgreSQL , Linux , huge page , shared buffer , page table , 虚拟地址 , 物理地址 , 内存地址转换表 背景 当内存很大时&#xff0c;除了刷脏页的调度可能需要优化&#xff0c;还有一方面是虚拟内存与物理内存映射表相关的部分需要优化。 1 脏页调度优化 1、主要包括…

Microsoft Teams:团队Owner离开公司后,我们该怎么做?

您是否曾在这么一个团队里&#xff0c;该团队唯一有Owner权限的人离开了公司&#xff1f;不幸的是,如果这个人不再在公司里&#xff0c;您可能觉得没有办法让其他团队成员再成为team的owner。我有一个简单易用的解决方案&#xff0c;但您需要成为Office 365租户的Admin或联系你…

python网络编程-socket编程

一、服务端和客户端 BS架构 &#xff08;腾讯通软件&#xff1a;serverclient&#xff09; CS架构 &#xff08;web网站&#xff09; C/S架构与socket的关系&#xff1a; 我们学习socket就是为了完成C/S架构的开发 二、OSI七层模型 互联网协议按照功能不同分为osi七层或tcp/ip五…

使用PowerShell配置Microsoft Teams

作为 IT 专业人员, 我一直在寻找自动化任务的方法, 并使日常操作简单。当使用Microsoft Teams时, 是否能够在团队中自动创建团队&#xff0c;渠道和设置对于Microsoft Teams组建的成功与否至关重要。PowerShell对Microsoft Teams的支持使您可以做到这一点&#xff0c;它为我提供…

常见Kotlin高频问题解惑

在笔者的Kotlin交流群里&#xff0c;不少同学反复遇到了一些相似的问题。这些问题大都比较基础&#xff0c;但又容易产生误解。因此&#xff0c;我决定写一篇文章&#xff0c;整理群里同学遇到的一些问题 变量和常量的使用 在Kotlin语言中&#xff0c;我们使用var声明变量&…

关于神经网络训练的一些建议笔记

关于网络训练时的参考建议&#xff1a; 1.train loss不断下降&#xff0c;test loss不断下降&#xff0c;网络正在学习 2.train loss不断下降&#xff0c;test loss趋于不变&#xff0c;网络过拟合&#xff0c;需要增大数据&#xff1b;减小网络规模dropout&#xff1b;权重衰减…

Microsoft Teams的保留策略

Microsoft Teams保留策略现在可在Office 365安全性和合规性中心里进行配置 今天&#xff0c;我们很自豪地宣布&#xff0c;我们正在开始推出针对Microsoft Teams的保留策略。 推出预计将在未来几周内完成。 通过此次发布&#xff0c;Teams管理员可以使用Office 365安全性和合规…

八年溯源,如何巧搭区块链

虎嗅注&#xff1a;区块链正在逐步商业化&#xff0c;但最大的挑战是共识。 为什么这样说&#xff1f;因为商品的溯源防伪业务在过去正是因为缺乏信任感而没有得到普及&#xff0c;这是每个溯源从业者最大的感受。 在虎嗅虎跑团每两周一次线上分享会上&#xff0c;溯源链创始人…

数字签名过程及数字证书

数字签名是什么&#xff1f; 作者&#xff1a;David Youd 翻译&#xff1a;阮一峰 原文网址&#xff1a;http://www.youdzone.com/signature.html 1.鲍勃有两把钥匙&#xff0c;一把是公钥&#xff0c;另一把是私钥。 2.Bob把公钥送给他的朋友们-Pat、Doug、Susan-- 每人一把…

Teams与OneDrive for Business和SharePoint的关系

作为一个相对看重个人信息安全与隐私的人&#xff0c;个人附件等资料在Microsoft Teams中的存储方式、文件访问权限、可见范围问题引起了我的好奇。 众所周知&#xff0c;Teams包含3大主要的模块&#xff1a;单人聊天、团队、会议。那下面让我们一起来看一下&#xff0c;对这三…

hadoop学习笔记(二):centos7三节点安装hadoop2.7.0

环境win7vamvare10centos7 一、新建三台centos7 64位的虚拟机 master 192.168.137.100 root/123456 node1 192.168.137.101 root/123456 node2 192.168.137.102 root/123456 二、关闭三台虚拟机的防火墙&#xff0c;在每台虚拟机里面执行&#xff1a; systemctl sto…

index.html 的默认301或者302跳转

index.html 的默认301或者302跳转 <!DOCTYPE html> <html> <head> <title>Google</title> <style> body { width: 35em; margin: 0 auto; font-family: Tahoma, Verdana, Arial, sans-serif; } </style> <script>window.locat…

在Microsoft Teams中的Visio协作

所有Team站点都带有专用文件库&#xff0c;用于存储所有工作组的内容。 您现在可以从桌面或云存储站点将Visio文件上载到此库&#xff0c;例如&#xff0c;您所在Team的资产都集中在一个位置&#xff0c;供具有权限的任何人进行访问。与其他存储文件一样&#xff0c;您可以直接…

用区块链打击假新闻 这可能是最2017年的一件事

据外媒报道&#xff0c;非营利性基金会PUBLIQ公布了一个基于区块链打造的平台。这是一个用于创建和分享原创新闻和媒体内容的平台&#xff0c;它将在近期推出。据了解&#xff0c;PUBLIQ创建这一平台则是希望能借用类似于比特币一样的系统来打击假新闻。 通过创建一个受信任的经…

oo面向对象第一单元总结

oo第一次作业主要考察了多项式的求导&#xff0c;从简单的幂函数求导到三角函数求导再到嵌套函数的求导&#xff0c;难度循序渐进&#xff0c;对我们对于面向对象的理解的要求也在一次一次提升。一行行代码打下来&#xff0c;一夜夜熬过去&#xff0c;我也来到了这个短暂的停靠…

Microsoft Teams免费版本初体验

Microsoft Teams推出有一段时间了&#xff0c;如果想要体验Teams&#xff0c;必须需要有Office365的订阅。最近微软为了进一步推广Teams&#xff0c;突然宣布Teams免费了。使用过Teams的读者知道Teams是基于Office365账号和组的&#xff0c;那它免费后&#xff0c;不使用Office…

JS:封装函数判断数据类型

思路 1 ).根据 typeof() 的返回值将数据分为2种情况 a.返回值为 string number boolean undefined function (直接返回 typeof() 的返回值) b.返回值为object 2 ).再将 typeof() 返回值为 object 的数据分为2种情况 a.null (直接返回自身) b.包装类 对象 数组 (再进行细分) var…

强制禁用gitlab的双因子认证:Two-Factor Authentication

&#xff08;一&#xff09;问题描述&#xff1a; 此博客解决如下问题&#xff1a;禁用gitlab的双因子认证 禁用前&#xff0c;如图&#xff08;此时&#xff0c;你在gitlab中什么也干不了&#xff09; &#xff08;二&#xff09;思路分析&#xff1a; 百度了很多方法&#xf…