diff --git a/solution/3300-3399/3332.Maximum Points Tourist Can Earn/README.md b/solution/3300-3399/3332.Maximum Points Tourist Can Earn/README.md index 5fb7d5f0fdf62..9c26ec0bbcdc8 100644 --- a/solution/3300-3399/3332.Maximum Points Tourist Can Earn/README.md +++ b/solution/3300-3399/3332.Maximum Points Tourist Can Earn/README.md @@ -81,25 +81,116 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3300-3399/3332.Ma #### Python3 ```python - +class Solution: + def maxScore( + self, n: int, k: int, stayScore: List[List[int]], travelScore: List[List[int]] + ) -> int: + f = [[-inf] * n for _ in range(k + 1)] + f[0] = [0] * n + for i in range(1, k + 1): + for j in range(n): + for h in range(n): + f[i][j] = max( + f[i][j], + f[i - 1][h] + + (stayScore[i - 1][j] if j == h else travelScore[h][j]), + ) + return max(f[k]) ``` #### Java ```java - +class Solution { + public int maxScore(int n, int k, int[][] stayScore, int[][] travelScore) { + int[][] f = new int[k + 1][n]; + for (var g : f) { + Arrays.fill(g, Integer.MIN_VALUE); + } + Arrays.fill(f[0], 0); + for (int i = 1; i <= k; ++i) { + for (int j = 0; j < n; ++j) { + for (int h = 0; h < n; ++h) { + f[i][j] = Math.max( + f[i][j], f[i - 1][h] + (j == h ? stayScore[i - 1][j] : travelScore[h][j])); + } + } + } + return Arrays.stream(f[k]).max().getAsInt(); + } +} ``` #### C++ ```cpp - +class Solution { +public: + int maxScore(int n, int k, vector>& stayScore, vector>& travelScore) { + int f[k + 1][n]; + memset(f, 0xc0, sizeof(f)); + memset(f[0], 0, sizeof(f[0])); + for (int i = 1; i <= k; ++i) { + for (int j = 0; j < n; ++j) { + for (int h = 0; h < n; ++h) { + f[i][j] = max(f[i][j], f[i - 1][h] + (j == h ? stayScore[i - 1][j] : travelScore[h][j])); + } + } + } + return *max_element(f[k], f[k] + n); + } +}; ``` #### Go ```go +func maxScore(n int, k int, stayScore [][]int, travelScore [][]int) (ans int) { + f := make([][]int, k+1) + for i := range f { + f[i] = make([]int, n) + for j := range f[i] { + f[i][j] = math.MinInt32 + } + } + for j := 0; j < n; j++ { + f[0][j] = 0 + } + for i := 1; i <= k; i++ { + for j := 0; j < n; j++ { + f[i][j] = f[i-1][j] + stayScore[i-1][j] + for h := 0; h < n; h++ { + if h != j { + f[i][j] = max(f[i][j], f[i-1][h]+travelScore[h][j]) + } + } + } + } + for j := 0; j < n; j++ { + ans = max(ans, f[k][j]) + } + return +} +``` +#### TypeScript + +```ts +function maxScore(n: number, k: number, stayScore: number[][], travelScore: number[][]): number { + const f: number[][] = Array.from({ length: k + 1 }, () => Array(n).fill(-Infinity)); + f[0].fill(0); + for (let i = 1; i <= k; ++i) { + for (let j = 0; j < n; ++j) { + for (let h = 0; h < n; ++h) { + f[i][j] = Math.max( + f[i][j], + f[i - 1][h] + (j == h ? stayScore[i - 1][j] : travelScore[h][j]), + ); + } + } + } + return Math.max(...f[k]); +} ``` diff --git a/solution/3300-3399/3332.Maximum Points Tourist Can Earn/README_EN.md b/solution/3300-3399/3332.Maximum Points Tourist Can Earn/README_EN.md index 5b5ff6bfc14a4..a81f33c55ef96 100644 --- a/solution/3300-3399/3332.Maximum Points Tourist Can Earn/README_EN.md +++ b/solution/3300-3399/3332.Maximum Points Tourist Can Earn/README_EN.md @@ -78,25 +78,116 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3300-3399/3332.Ma #### Python3 ```python - +class Solution: + def maxScore( + self, n: int, k: int, stayScore: List[List[int]], travelScore: List[List[int]] + ) -> int: + f = [[-inf] * n for _ in range(k + 1)] + f[0] = [0] * n + for i in range(1, k + 1): + for j in range(n): + for h in range(n): + f[i][j] = max( + f[i][j], + f[i - 1][h] + + (stayScore[i - 1][j] if j == h else travelScore[h][j]), + ) + return max(f[k]) ``` #### Java ```java - +class Solution { + public int maxScore(int n, int k, int[][] stayScore, int[][] travelScore) { + int[][] f = new int[k + 1][n]; + for (var g : f) { + Arrays.fill(g, Integer.MIN_VALUE); + } + Arrays.fill(f[0], 0); + for (int i = 1; i <= k; ++i) { + for (int j = 0; j < n; ++j) { + for (int h = 0; h < n; ++h) { + f[i][j] = Math.max( + f[i][j], f[i - 1][h] + (j == h ? stayScore[i - 1][j] : travelScore[h][j])); + } + } + } + return Arrays.stream(f[k]).max().getAsInt(); + } +} ``` #### C++ ```cpp - +class Solution { +public: + int maxScore(int n, int k, vector>& stayScore, vector>& travelScore) { + int f[k + 1][n]; + memset(f, 0xc0, sizeof(f)); + memset(f[0], 0, sizeof(f[0])); + for (int i = 1; i <= k; ++i) { + for (int j = 0; j < n; ++j) { + for (int h = 0; h < n; ++h) { + f[i][j] = max(f[i][j], f[i - 1][h] + (j == h ? stayScore[i - 1][j] : travelScore[h][j])); + } + } + } + return *max_element(f[k], f[k] + n); + } +}; ``` #### Go ```go +func maxScore(n int, k int, stayScore [][]int, travelScore [][]int) (ans int) { + f := make([][]int, k+1) + for i := range f { + f[i] = make([]int, n) + for j := range f[i] { + f[i][j] = math.MinInt32 + } + } + for j := 0; j < n; j++ { + f[0][j] = 0 + } + for i := 1; i <= k; i++ { + for j := 0; j < n; j++ { + f[i][j] = f[i-1][j] + stayScore[i-1][j] + for h := 0; h < n; h++ { + if h != j { + f[i][j] = max(f[i][j], f[i-1][h]+travelScore[h][j]) + } + } + } + } + for j := 0; j < n; j++ { + ans = max(ans, f[k][j]) + } + return +} +``` +#### TypeScript + +```ts +function maxScore(n: number, k: number, stayScore: number[][], travelScore: number[][]): number { + const f: number[][] = Array.from({ length: k + 1 }, () => Array(n).fill(-Infinity)); + f[0].fill(0); + for (let i = 1; i <= k; ++i) { + for (let j = 0; j < n; ++j) { + for (let h = 0; h < n; ++h) { + f[i][j] = Math.max( + f[i][j], + f[i - 1][h] + (j == h ? stayScore[i - 1][j] : travelScore[h][j]), + ); + } + } + } + return Math.max(...f[k]); +} ``` diff --git a/solution/3300-3399/3332.Maximum Points Tourist Can Earn/Solution.cpp b/solution/3300-3399/3332.Maximum Points Tourist Can Earn/Solution.cpp new file mode 100644 index 0000000000000..8696f3ca86752 --- /dev/null +++ b/solution/3300-3399/3332.Maximum Points Tourist Can Earn/Solution.cpp @@ -0,0 +1,16 @@ +class Solution { +public: + int maxScore(int n, int k, vector>& stayScore, vector>& travelScore) { + int f[k + 1][n]; + memset(f, 0xc0, sizeof(f)); + memset(f[0], 0, sizeof(f[0])); + for (int i = 1; i <= k; ++i) { + for (int j = 0; j < n; ++j) { + for (int h = 0; h < n; ++h) { + f[i][j] = max(f[i][j], f[i - 1][h] + (j == h ? stayScore[i - 1][j] : travelScore[h][j])); + } + } + } + return *max_element(f[k], f[k] + n); + } +}; diff --git a/solution/3300-3399/3332.Maximum Points Tourist Can Earn/Solution.go b/solution/3300-3399/3332.Maximum Points Tourist Can Earn/Solution.go new file mode 100644 index 0000000000000..ac5f34746f8d1 --- /dev/null +++ b/solution/3300-3399/3332.Maximum Points Tourist Can Earn/Solution.go @@ -0,0 +1,26 @@ +func maxScore(n int, k int, stayScore [][]int, travelScore [][]int) (ans int) { + f := make([][]int, k+1) + for i := range f { + f[i] = make([]int, n) + for j := range f[i] { + f[i][j] = math.MinInt32 + } + } + for j := 0; j < n; j++ { + f[0][j] = 0 + } + for i := 1; i <= k; i++ { + for j := 0; j < n; j++ { + f[i][j] = f[i-1][j] + stayScore[i-1][j] + for h := 0; h < n; h++ { + if h != j { + f[i][j] = max(f[i][j], f[i-1][h]+travelScore[h][j]) + } + } + } + } + for j := 0; j < n; j++ { + ans = max(ans, f[k][j]) + } + return +} diff --git a/solution/3300-3399/3332.Maximum Points Tourist Can Earn/Solution.java b/solution/3300-3399/3332.Maximum Points Tourist Can Earn/Solution.java new file mode 100644 index 0000000000000..8174aaa6d19cb --- /dev/null +++ b/solution/3300-3399/3332.Maximum Points Tourist Can Earn/Solution.java @@ -0,0 +1,18 @@ +class Solution { + public int maxScore(int n, int k, int[][] stayScore, int[][] travelScore) { + int[][] f = new int[k + 1][n]; + for (var g : f) { + Arrays.fill(g, Integer.MIN_VALUE); + } + Arrays.fill(f[0], 0); + for (int i = 1; i <= k; ++i) { + for (int j = 0; j < n; ++j) { + for (int h = 0; h < n; ++h) { + f[i][j] = Math.max( + f[i][j], f[i - 1][h] + (j == h ? stayScore[i - 1][j] : travelScore[h][j])); + } + } + } + return Arrays.stream(f[k]).max().getAsInt(); + } +} diff --git a/solution/3300-3399/3332.Maximum Points Tourist Can Earn/Solution.py b/solution/3300-3399/3332.Maximum Points Tourist Can Earn/Solution.py new file mode 100644 index 0000000000000..525bc4d32e29d --- /dev/null +++ b/solution/3300-3399/3332.Maximum Points Tourist Can Earn/Solution.py @@ -0,0 +1,15 @@ +class Solution: + def maxScore( + self, n: int, k: int, stayScore: List[List[int]], travelScore: List[List[int]] + ) -> int: + f = [[-inf] * n for _ in range(k + 1)] + f[0] = [0] * n + for i in range(1, k + 1): + for j in range(n): + for h in range(n): + f[i][j] = max( + f[i][j], + f[i - 1][h] + + (stayScore[i - 1][j] if j == h else travelScore[h][j]), + ) + return max(f[k]) diff --git a/solution/3300-3399/3332.Maximum Points Tourist Can Earn/Solution.ts b/solution/3300-3399/3332.Maximum Points Tourist Can Earn/Solution.ts new file mode 100644 index 0000000000000..0dc5fb1b4afe7 --- /dev/null +++ b/solution/3300-3399/3332.Maximum Points Tourist Can Earn/Solution.ts @@ -0,0 +1,15 @@ +function maxScore(n: number, k: number, stayScore: number[][], travelScore: number[][]): number { + const f: number[][] = Array.from({ length: k + 1 }, () => Array(n).fill(-Infinity)); + f[0].fill(0); + for (let i = 1; i <= k; ++i) { + for (let j = 0; j < n; ++j) { + for (let h = 0; h < n; ++h) { + f[i][j] = Math.max( + f[i][j], + f[i - 1][h] + (j == h ? stayScore[i - 1][j] : travelScore[h][j]), + ); + } + } + } + return Math.max(...f[k]); +} diff --git a/solution/3300-3399/3334.Find the Maximum Factor Score of Array/README.md b/solution/3300-3399/3334.Find the Maximum Factor Score of Array/README.md index 69f5a90ea6c80..b88c0719354be 100644 --- a/solution/3300-3399/3334.Find the Maximum Factor Score of Array/README.md +++ b/solution/3300-3399/3334.Find the Maximum Factor Score of Array/README.md @@ -82,25 +82,147 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3300-3399/3334.Fi #### Python3 ```python - +class Solution: + def maxScore(self, nums: List[int]) -> int: + n = len(nums) + suf_gcd = [0] * (n + 1) + suf_lcm = [0] * n + [1] + for i in range(n - 1, -1, -1): + suf_gcd[i] = gcd(suf_gcd[i + 1], nums[i]) + suf_lcm[i] = lcm(suf_lcm[i + 1], nums[i]) + ans = suf_gcd[0] * suf_lcm[0] + pre_gcd, pre_lcm = 0, 1 + for i, x in enumerate(nums): + ans = max(ans, gcd(pre_gcd, suf_gcd[i + 1]) * lcm(pre_lcm, suf_lcm[i + 1])) + pre_gcd = gcd(pre_gcd, x) + pre_lcm = lcm(pre_lcm, x) + return ans ``` #### Java ```java - +class Solution { + public long maxScore(int[] nums) { + int n = nums.length; + long[] sufGcd = new long[n + 1]; + long[] sufLcm = new long[n + 1]; + sufLcm[n] = 1; + for (int i = n - 1; i >= 0; --i) { + sufGcd[i] = gcd(sufGcd[i + 1], nums[i]); + sufLcm[i] = lcm(sufLcm[i + 1], nums[i]); + } + long ans = sufGcd[0] * sufLcm[0]; + long preGcd = 0, preLcm = 1; + for (int i = 0; i < n; ++i) { + ans = Math.max(ans, gcd(preGcd, sufGcd[i + 1]) * lcm(preLcm, sufLcm[i + 1])); + preGcd = gcd(preGcd, nums[i]); + preLcm = lcm(preLcm, nums[i]); + } + return ans; + } + + private long gcd(long a, long b) { + return b == 0 ? a : gcd(b, a % b); + } + + private long lcm(long a, long b) { + return a / gcd(a, b) * b; + } +} ``` #### C++ ```cpp - +class Solution { +public: + long long maxScore(vector& nums) { + int n = nums.size(); + vector sufGcd(n + 1, 0); + vector sufLcm(n + 1, 1); + for (int i = n - 1; i >= 0; --i) { + sufGcd[i] = gcd(sufGcd[i + 1], nums[i]); + sufLcm[i] = lcm(sufLcm[i + 1], nums[i]); + } + + long long ans = sufGcd[0] * sufLcm[0]; + long long preGcd = 0, preLcm = 1; + for (int i = 0; i < n; ++i) { + ans = max(ans, gcd(preGcd, sufGcd[i + 1]) * lcm(preLcm, sufLcm[i + 1])); + preGcd = gcd(preGcd, nums[i]); + preLcm = lcm(preLcm, nums[i]); + } + return ans; + } +}; ``` #### Go ```go +func maxScore(nums []int) int64 { + n := len(nums) + sufGcd := make([]int64, n+1) + sufLcm := make([]int64, n+1) + sufLcm[n] = 1 + for i := n - 1; i >= 0; i-- { + sufGcd[i] = gcd(sufGcd[i+1], int64(nums[i])) + sufLcm[i] = lcm(sufLcm[i+1], int64(nums[i])) + } + + ans := sufGcd[0] * sufLcm[0] + preGcd, preLcm := int64(0), int64(1) + for i := 0; i < n; i++ { + ans = max(ans, gcd(preGcd, sufGcd[i+1])*lcm(preLcm, sufLcm[i+1])) + preGcd = gcd(preGcd, int64(nums[i])) + preLcm = lcm(preLcm, int64(nums[i])) + } + return ans +} + +func gcd(a, b int64) int64 { + if b == 0 { + return a + } + return gcd(b, a%b) +} + +func lcm(a, b int64) int64 { + return a / gcd(a, b) * b +} +``` +#### TypeScript + +```ts +function maxScore(nums: number[]): number { + const n = nums.length; + const sufGcd: number[] = Array(n + 1).fill(0); + const sufLcm: number[] = Array(n + 1).fill(1); + for (let i = n - 1; i >= 0; i--) { + sufGcd[i] = gcd(sufGcd[i + 1], nums[i]); + sufLcm[i] = lcm(sufLcm[i + 1], nums[i]); + } + + let ans = sufGcd[0] * sufLcm[0]; + let preGcd = 0, + preLcm = 1; + for (let i = 0; i < n; i++) { + ans = Math.max(ans, gcd(preGcd, sufGcd[i + 1]) * lcm(preLcm, sufLcm[i + 1])); + preGcd = gcd(preGcd, nums[i]); + preLcm = lcm(preLcm, nums[i]); + } + return ans; +} + +function gcd(a: number, b: number): number { + return b === 0 ? a : gcd(b, a % b); +} + +function lcm(a: number, b: number): number { + return (a / gcd(a, b)) * b; +} ``` diff --git a/solution/3300-3399/3334.Find the Maximum Factor Score of Array/README_EN.md b/solution/3300-3399/3334.Find the Maximum Factor Score of Array/README_EN.md index 54ce620281d78..86019f7f7ca19 100644 --- a/solution/3300-3399/3334.Find the Maximum Factor Score of Array/README_EN.md +++ b/solution/3300-3399/3334.Find the Maximum Factor Score of Array/README_EN.md @@ -80,25 +80,147 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3300-3399/3334.Fi #### Python3 ```python - +class Solution: + def maxScore(self, nums: List[int]) -> int: + n = len(nums) + suf_gcd = [0] * (n + 1) + suf_lcm = [0] * n + [1] + for i in range(n - 1, -1, -1): + suf_gcd[i] = gcd(suf_gcd[i + 1], nums[i]) + suf_lcm[i] = lcm(suf_lcm[i + 1], nums[i]) + ans = suf_gcd[0] * suf_lcm[0] + pre_gcd, pre_lcm = 0, 1 + for i, x in enumerate(nums): + ans = max(ans, gcd(pre_gcd, suf_gcd[i + 1]) * lcm(pre_lcm, suf_lcm[i + 1])) + pre_gcd = gcd(pre_gcd, x) + pre_lcm = lcm(pre_lcm, x) + return ans ``` #### Java ```java - +class Solution { + public long maxScore(int[] nums) { + int n = nums.length; + long[] sufGcd = new long[n + 1]; + long[] sufLcm = new long[n + 1]; + sufLcm[n] = 1; + for (int i = n - 1; i >= 0; --i) { + sufGcd[i] = gcd(sufGcd[i + 1], nums[i]); + sufLcm[i] = lcm(sufLcm[i + 1], nums[i]); + } + long ans = sufGcd[0] * sufLcm[0]; + long preGcd = 0, preLcm = 1; + for (int i = 0; i < n; ++i) { + ans = Math.max(ans, gcd(preGcd, sufGcd[i + 1]) * lcm(preLcm, sufLcm[i + 1])); + preGcd = gcd(preGcd, nums[i]); + preLcm = lcm(preLcm, nums[i]); + } + return ans; + } + + private long gcd(long a, long b) { + return b == 0 ? a : gcd(b, a % b); + } + + private long lcm(long a, long b) { + return a / gcd(a, b) * b; + } +} ``` #### C++ ```cpp - +class Solution { +public: + long long maxScore(vector& nums) { + int n = nums.size(); + vector sufGcd(n + 1, 0); + vector sufLcm(n + 1, 1); + for (int i = n - 1; i >= 0; --i) { + sufGcd[i] = gcd(sufGcd[i + 1], nums[i]); + sufLcm[i] = lcm(sufLcm[i + 1], nums[i]); + } + + long long ans = sufGcd[0] * sufLcm[0]; + long long preGcd = 0, preLcm = 1; + for (int i = 0; i < n; ++i) { + ans = max(ans, gcd(preGcd, sufGcd[i + 1]) * lcm(preLcm, sufLcm[i + 1])); + preGcd = gcd(preGcd, nums[i]); + preLcm = lcm(preLcm, nums[i]); + } + return ans; + } +}; ``` #### Go ```go +func maxScore(nums []int) int64 { + n := len(nums) + sufGcd := make([]int64, n+1) + sufLcm := make([]int64, n+1) + sufLcm[n] = 1 + for i := n - 1; i >= 0; i-- { + sufGcd[i] = gcd(sufGcd[i+1], int64(nums[i])) + sufLcm[i] = lcm(sufLcm[i+1], int64(nums[i])) + } + + ans := sufGcd[0] * sufLcm[0] + preGcd, preLcm := int64(0), int64(1) + for i := 0; i < n; i++ { + ans = max(ans, gcd(preGcd, sufGcd[i+1])*lcm(preLcm, sufLcm[i+1])) + preGcd = gcd(preGcd, int64(nums[i])) + preLcm = lcm(preLcm, int64(nums[i])) + } + return ans +} + +func gcd(a, b int64) int64 { + if b == 0 { + return a + } + return gcd(b, a%b) +} + +func lcm(a, b int64) int64 { + return a / gcd(a, b) * b +} +``` +#### TypeScript + +```ts +function maxScore(nums: number[]): number { + const n = nums.length; + const sufGcd: number[] = Array(n + 1).fill(0); + const sufLcm: number[] = Array(n + 1).fill(1); + for (let i = n - 1; i >= 0; i--) { + sufGcd[i] = gcd(sufGcd[i + 1], nums[i]); + sufLcm[i] = lcm(sufLcm[i + 1], nums[i]); + } + + let ans = sufGcd[0] * sufLcm[0]; + let preGcd = 0, + preLcm = 1; + for (let i = 0; i < n; i++) { + ans = Math.max(ans, gcd(preGcd, sufGcd[i + 1]) * lcm(preLcm, sufLcm[i + 1])); + preGcd = gcd(preGcd, nums[i]); + preLcm = lcm(preLcm, nums[i]); + } + return ans; +} + +function gcd(a: number, b: number): number { + return b === 0 ? a : gcd(b, a % b); +} + +function lcm(a: number, b: number): number { + return (a / gcd(a, b)) * b; +} ``` diff --git a/solution/3300-3399/3334.Find the Maximum Factor Score of Array/Solution.cpp b/solution/3300-3399/3334.Find the Maximum Factor Score of Array/Solution.cpp new file mode 100644 index 0000000000000..ef12460b0ebf1 --- /dev/null +++ b/solution/3300-3399/3334.Find the Maximum Factor Score of Array/Solution.cpp @@ -0,0 +1,21 @@ +class Solution { +public: + long long maxScore(vector& nums) { + int n = nums.size(); + vector sufGcd(n + 1, 0); + vector sufLcm(n + 1, 1); + for (int i = n - 1; i >= 0; --i) { + sufGcd[i] = gcd(sufGcd[i + 1], nums[i]); + sufLcm[i] = lcm(sufLcm[i + 1], nums[i]); + } + + long long ans = sufGcd[0] * sufLcm[0]; + long long preGcd = 0, preLcm = 1; + for (int i = 0; i < n; ++i) { + ans = max(ans, gcd(preGcd, sufGcd[i + 1]) * lcm(preLcm, sufLcm[i + 1])); + preGcd = gcd(preGcd, nums[i]); + preLcm = lcm(preLcm, nums[i]); + } + return ans; + } +}; diff --git a/solution/3300-3399/3334.Find the Maximum Factor Score of Array/Solution.go b/solution/3300-3399/3334.Find the Maximum Factor Score of Array/Solution.go new file mode 100644 index 0000000000000..fd13304c31c55 --- /dev/null +++ b/solution/3300-3399/3334.Find the Maximum Factor Score of Array/Solution.go @@ -0,0 +1,30 @@ +func maxScore(nums []int) int64 { + n := len(nums) + sufGcd := make([]int64, n+1) + sufLcm := make([]int64, n+1) + sufLcm[n] = 1 + for i := n - 1; i >= 0; i-- { + sufGcd[i] = gcd(sufGcd[i+1], int64(nums[i])) + sufLcm[i] = lcm(sufLcm[i+1], int64(nums[i])) + } + + ans := sufGcd[0] * sufLcm[0] + preGcd, preLcm := int64(0), int64(1) + for i := 0; i < n; i++ { + ans = max(ans, gcd(preGcd, sufGcd[i+1])*lcm(preLcm, sufLcm[i+1])) + preGcd = gcd(preGcd, int64(nums[i])) + preLcm = lcm(preLcm, int64(nums[i])) + } + return ans +} + +func gcd(a, b int64) int64 { + if b == 0 { + return a + } + return gcd(b, a%b) +} + +func lcm(a, b int64) int64 { + return a / gcd(a, b) * b +} diff --git a/solution/3300-3399/3334.Find the Maximum Factor Score of Array/Solution.java b/solution/3300-3399/3334.Find the Maximum Factor Score of Array/Solution.java new file mode 100644 index 0000000000000..f4b165794d928 --- /dev/null +++ b/solution/3300-3399/3334.Find the Maximum Factor Score of Array/Solution.java @@ -0,0 +1,28 @@ +class Solution { + public long maxScore(int[] nums) { + int n = nums.length; + long[] sufGcd = new long[n + 1]; + long[] sufLcm = new long[n + 1]; + sufLcm[n] = 1; + for (int i = n - 1; i >= 0; --i) { + sufGcd[i] = gcd(sufGcd[i + 1], nums[i]); + sufLcm[i] = lcm(sufLcm[i + 1], nums[i]); + } + long ans = sufGcd[0] * sufLcm[0]; + long preGcd = 0, preLcm = 1; + for (int i = 0; i < n; ++i) { + ans = Math.max(ans, gcd(preGcd, sufGcd[i + 1]) * lcm(preLcm, sufLcm[i + 1])); + preGcd = gcd(preGcd, nums[i]); + preLcm = lcm(preLcm, nums[i]); + } + return ans; + } + + private long gcd(long a, long b) { + return b == 0 ? a : gcd(b, a % b); + } + + private long lcm(long a, long b) { + return a / gcd(a, b) * b; + } +} diff --git a/solution/3300-3399/3334.Find the Maximum Factor Score of Array/Solution.py b/solution/3300-3399/3334.Find the Maximum Factor Score of Array/Solution.py new file mode 100644 index 0000000000000..f3996b4217fce --- /dev/null +++ b/solution/3300-3399/3334.Find the Maximum Factor Score of Array/Solution.py @@ -0,0 +1,15 @@ +class Solution: + def maxScore(self, nums: List[int]) -> int: + n = len(nums) + suf_gcd = [0] * (n + 1) + suf_lcm = [0] * n + [1] + for i in range(n - 1, -1, -1): + suf_gcd[i] = gcd(suf_gcd[i + 1], nums[i]) + suf_lcm[i] = lcm(suf_lcm[i + 1], nums[i]) + ans = suf_gcd[0] * suf_lcm[0] + pre_gcd, pre_lcm = 0, 1 + for i, x in enumerate(nums): + ans = max(ans, gcd(pre_gcd, suf_gcd[i + 1]) * lcm(pre_lcm, suf_lcm[i + 1])) + pre_gcd = gcd(pre_gcd, x) + pre_lcm = lcm(pre_lcm, x) + return ans diff --git a/solution/3300-3399/3334.Find the Maximum Factor Score of Array/Solution.ts b/solution/3300-3399/3334.Find the Maximum Factor Score of Array/Solution.ts new file mode 100644 index 0000000000000..b2534779be215 --- /dev/null +++ b/solution/3300-3399/3334.Find the Maximum Factor Score of Array/Solution.ts @@ -0,0 +1,27 @@ +function maxScore(nums: number[]): number { + const n = nums.length; + const sufGcd: number[] = Array(n + 1).fill(0); + const sufLcm: number[] = Array(n + 1).fill(1); + for (let i = n - 1; i >= 0; i--) { + sufGcd[i] = gcd(sufGcd[i + 1], nums[i]); + sufLcm[i] = lcm(sufLcm[i + 1], nums[i]); + } + + let ans = sufGcd[0] * sufLcm[0]; + let preGcd = 0, + preLcm = 1; + for (let i = 0; i < n; i++) { + ans = Math.max(ans, gcd(preGcd, sufGcd[i + 1]) * lcm(preLcm, sufLcm[i + 1])); + preGcd = gcd(preGcd, nums[i]); + preLcm = lcm(preLcm, nums[i]); + } + return ans; +} + +function gcd(a: number, b: number): number { + return b === 0 ? a : gcd(b, a % b); +} + +function lcm(a: number, b: number): number { + return (a / gcd(a, b)) * b; +}