C++博客-Uriel's Corner-文章分类-递归 & 分治

[LeetCode]1457. Pseudo-Palindromic Paths in a Binary Tree (Medium) Python-2024.01.24

Uriel — Wed, 24 Jan 2024 11:26:00 GMT

思路参考->https://leetcode.com/problems/pseudo-palindromic-paths-in-a-binary-tree/solutions/2573237/leetcode-the-hard-way-explained-line-by-line/?envType=daily-question&envId=2024-01-24

1 #1457
2 #Runtime: 911 ms (Beats 96.43%)
3 #Memory: 136.7 MB (Beats 10.71%)
4
5 # Definition for a binary tree node.
6 # class TreeNode(object):
7 #     def __init__(self, val=0, left=None, right=None):
8 #         self.val = val
9 #         self.left = left
10 #         self.right = right
11 class Solution(object):
12     def pseudoPalindromicPaths (self, root, cnt = 0):
13         """
14         :type root: TreeNode
15         :rtype: int
16         """
17         if not root:
18             return 0
19         cnt ^= 1 << (root.val - 1)
20         if root.left is None and root.right is None:
21             return 1 if cnt & (cnt - 1) == 0 else 0
22         return self.pseudoPalindromicPaths(root.left, cnt) + self.pseudoPalindromicPaths(root.right, cnt)
23

Uriel 2024-01-24 19:26 发表评论

[LeetCode]808. Soup Servings (Medium) Python3-2023.07.29

Uriel — Sat, 29 Jul 2023 10:07:00 GMT

初始A，B两种汤都有n ml，每次可以执行如下四种操作之一，输出A先喝完的概率*1+AB同时喝完的概率*0.5，精度10^-5，递归+DP，但直接做会超过迭代深度，参考Discussion发现由输出精度可以推算n大于某个值的时候可以直接输出1

1 #808
2 #Runtime: 36 ms (Beats 100%)
3 #Memory: 17 MB (Beats 79.25%)
4
5 class Solution:
6     def soupServings(self, n: int) -> float:
7         if n >= 4276:
8             return 1.0
9         @lru_cache(None)
10         def dp(x, y):
11             if x <= 0 and y > 0:
12                 return 1
13             if x <= 0 and y <= 0:
14                 return 0.5
15             if x > 0 and y <= 0:
16                 return 0
17             return (dp(x - 100, y) + dp(x - 75, y - 25) + dp(x - 50, y - 50) + dp(x - 25, y - 75)) * 0.25
18
19         return dp(1.0 * n, 1.0 * n)

Uriel 2023-07-29 18:07 发表评论

[LeetCode]486. Predict the Winner (Medium) Python3-2023.07.28

Uriel — Fri, 28 Jul 2023 09:37:00 GMT

一个数列，每个值代表score，两个player每次可以从数列头or尾选一个数，问最后谁的总score最高，递归+DP，参考了Discussion -> https://leetcode.com/problems/predict-the-winner/solutions/3826270/python3-solution/

1 #486
2 #Runtime: 41 ms (Beats 96.36%)
3 #Memory: 16.7 MB (Beats 19.78%)
4
5 class Solution:
6     def PredictTheWinner(self, nums: List[int]) -> bool:
7         n = len(nums)
8         @lru_cache(None)
9         def dp(i, j):
10             return 0 if i > j else max(-dp(i + 1, j) + nums[i], -dp(i, j - 1) + nums[j])
11
12         return dp(0, n -1) >= 0

Uriel 2023-07-28 17:37 发表评论

[LeetCode]956. Tallest Billboard (Hard) Python-2023.06.24

Uriel — Sun, 25 Jun 2023 14:34:00 GMT

将一个二维数组分为加和相等的两拨，问最大的和是多少（不存在的话输出0）
递归DP+memorization，参考了Discussion -> https://leetcode.com/problems/tallest-billboard/solutions/3675264/python3-solution/

1 #956
2 #Runtime: 960 ms (Beats 33.33%)
3 #Memory: 121.3 MB (Beats 11.11%)
4
5 class Solution(object):
6     def tallestBillboard(self, rods):
7         """
8         :type rods: List[int]
9         :rtype: int
10         """
11         ans = {}
12         def DFS(i, dif):
13             if (i, dif) in ans:
14                 return ans[(i, dif)]
15             if i >= len(rods):
16                 if dif:
17                     return float('-inf')
18                 return 0
19             l = DFS(i + 1, dif + rods[i])
20             skip = DFS(i + 1, dif)
21             s = DFS(i + 1, abs(rods[i] - dif)) + min(dif, rods[i])
22             ans[(i, dif)] = max(l, s, skip)
23             return ans[(i, dif)]
24
25
26         return DFS(0, 0)

Uriel 2023-06-25 22:34 发表评论

[LeetCode]1575. Count All Possible Routes (Hard) Python3-2023.06.25

Uriel — Sun, 25 Jun 2023 14:30:00 GMT

给出每个城市i的locations[i]，以及起始、终点城市和初始汽油量，从城市i到j需要耗费汽油｜locations[i]-locations[j]｜，问一共有多少条路线

递归DP+memorization（用python3的lru_cache）
参考了Discussion -> https://leetcode.com/problems/count-all-possible-routes/solutions/3678855/python3-solution/

1 #1575
2 #Runtime: 2024 ms (Beats 68.42%)
3 #Memory: 41.4 MB (Beats 12.3%)
4
5 class Solution:
6     def countRoutes(self, locations: List[int], start: int, finish: int, fuel: int) -> int:
7         MOD = 10 ** 9 + 7
8
9         @lru_cache(None)
10         def DP(p, x):
11             if x < 0:
12                 return 0
13             t = 0
14             if p == finish:
15                 t += 1
16             for i in range(len(locations)):
17                 if i != p:
18                     t += DP(i, x - abs(locations[i] - locations[p]))
19             return t
20
21         return DP(start, fuel) % MOD

Uriel 2023-06-25 22:30 发表评论

[LeetCode]2328. Number of Increasing Paths in a Grid (Hard) Python3-2023.06.18

Uriel — Sun, 18 Jun 2023 13:10:00 GMT

问一个二位数字矩阵中严格递增的path有几条（可以往上下左右走），DP+递归+Memorization
参考了Discussion-> https://leetcode.com/problems/number-of-increasing-paths-in-a-grid/solutions/3650130/python3-solution/

1 #2328
2 #Runtime: 2652 ms (Beats 28.65%)
3 #Memory: 78.9 MB (Beats 49.52%)
4
5 class Solution:
6     def countPaths(self, grid: List[List[int]]) -> int:
7         MOD = 10 ** 9 + 7
8         n, m = len(grid), len(grid[0])
9         dp = [[-1 for _ in range(m)] for _ in range(n)]
10
11         def cal(r, c, pre):
12             nonlocal n, m
13             if r < 0 or c < 0 or r >= n or c >= m or grid[r][c] <= pre:
14                 return 0
15             if dp[r][c] != -1:
16                 return dp[r][c]
17             dir = [[1, 0], [-1, 0], [0, -1], [0, 1]]
18             t = 1
19             for d in dir:
20                 tr = r + d[0]
21                 tc = c + d[1]
22                 t += cal(tr, tc, grid[r][c])
23             dp[r][c] = t
24             return t
25
26         ans = 0
27         for r in range(n):
28             for c in range(m):
29                 ans = (ans + cal(r, c, -1)) % MOD
30         return ans

Uriel 2023-06-18 21:10 发表评论

[LeetCode]1569. Number of Ways to Reorder Array to Get Same BST (Hard) Python3-2023.06.16

Uriel — Fri, 16 Jun 2023 09:23:00 GMT

给定一列不重复的数，依次插入一棵空树构成二叉搜索树，问若打乱这一列数的顺序，一共有多少种不同的打乱方式，可以得到一样的BST，递归分治思想
假设当前数列长l，那么第一个数字决定了root的位置，无法移动，之后的数字比root大的数和比root小的数的数量是一定的，假设有m个数比root大，n个数比root小（m+n+1=l）。那么打乱顺序还可以构成一样的BST的数量就是组合数C(m, m+n)。而左子树和右子树又将进行同样的计算。注意最终结果要-1（减去原本的那种排列方式）

1 #1569
2 #Runtime: 173 ms (Beats 71.74%)
3 #Memory: 21.8 MB (Beats 51.9%)
4
5 class Solution:
6     def numOfWays(self, nums: List[int]) -> int:
7         MOD = 10 ** 9 + 7
8
9         def cal(seq):
10             if not seq:
11                 return 1
12             root = seq[0]
13             l_tree = [num for num in seq if num < root]
14             r_tree = [num for num in seq if num > root]
15             return math.comb(len(l_tree) + len(r_tree), len(l_tree)) * cal(l_tree) * cal(r_tree) % MOD
16         return (cal(nums) - 1) % MOD

Uriel 2023-06-16 17:23 发表评论

[LeetCode]1547. Minimum Cost to Cut a Stick (Hard) Python-2023.05.28

Uriel — Sun, 28 May 2023 13:52:00 GMT

一根长度n的棍子，需要在上面cuts (list)的位置切割，每次切割的开销是当前这一小段的长度，问切割完的最小花费，递归DP
和Discussion再次学到lru_cache的用法

1 #1547
2 #Runtime: 761 ms (Beats 87.80%)
3 #Memory: 20.5 MB (Beats 5.95%)
4
5 class Solution:
6     def minCost(self, n: int, cuts: List[int]) -> int:
7         cuts.append(0)
8         cuts.append(n)
9         cuts.sort()
10
11         @functools.lru_cache(None)
12         def dp(x, y):
13             if x >= y - 1:
14                 return 0
15             return cuts[y] - cuts[x] + min((dp(x, k) + dp(k, y) for k in range(x + 1, y)), default = 0)
16         return dp(0, len(cuts) - 1)

Uriel 2023-05-28 21:52 发表评论

[LeetCode]87. Scramble String (Hard) Python-2023.03.30

Uriel — Thu, 30 Mar 2023 08:51:00 GMT

给出两个字符串，可以进行任意多次操作，每次将字符串切分成两个，选择对调两个子串or不对调，问字符串s1能否经过操作变为字符串

用了比较暴力的做法，穷举所有操作的可能性，用了Discussion中记录下已经暴力枚举过的结果，否则会TLE

https://leetcode.com/problems/scramble-string/solutions/3357439/easy-solutions-in-java-python-and-c-look-at-once-with-exaplanation

1 #1402
2 #Runtime: 222 ms (Beats 21.95%)
3 #Memory: 20.5 MB (Beats 7.32%)
4
5 class Solution(object):
6     def isScramble(self, s1, s2):
7         """
8         :type s1: str
9         :type s2: str
10         :rtype: bool
11         """
12         if len(s1) != len(s2):
13             return False
14         if s1 == s2:
15             return True
16         if len(s1) == 1:
17             return False
18         t = s1 + " " + s2
19         if t in self.solved:
20             return self.solved[t]
21         for i in range(1, len(s1)):
22             if self.isScramble(s1[0:i], s2[0:i]) and self.isScramble(s1[i:], s2[i:]):
23                 self.solved[t] = True
24                 return True
25             if self.isScramble(s1[0:i], s2[len(s1)-i:]) and self.isScramble(s1[i:], s2[0:len(s1)-i]):
26                 self.solved[t] = True
27                 return True
28         self.solved[t] = False
29         return False
30     solved = {}

Uriel 2023-03-30 16:51 发表评论

[LeetCode]427. Construct Quad Tree (Medium) Python-2023.02.27

Uriel — Mon, 27 Feb 2023 12:57:00 GMT

基于一个值为0或1的方阵构建Quad Tree，DFS

1 #427
2 #Runtime: 100 ms (Beats 98.35%)
3 #Memory: 14.7 MB (Beats 86.50%)
4
5 class Node:
6     def __init__(self, val, isLeaf, topLeft = None, topRight = None, bottomLeft = None, bottomRight = None):
7         self.val = val
8         self.isLeaf = isLeaf
9         self.topLeft = topLeft
10         self.topRight = topRight
11         self.bottomLeft = bottomLeft
12         self.bottomRight = bottomRight
13
14
15 class Solution:
16     def isLeaf(self, grid, x, y, w):
17         for i in range(x, x + w):
18             for j in range(y, y + w):
19                 if grid[x][y] != grid[i][j]:
20                     return False
21         return True
22
23     def BuildTree(self, grid, x, y, w):
24         if self.isLeaf(grid, x, y, w):
25             return Node(grid[x][y] == 1, True)
26         r = Node(True, False)
27         r.topLeft = self.BuildTree(grid, x, y, w // 2)
28         r.topRight = self.BuildTree(grid, x, y + w // 2, w // 2)
29         r.bottomLeft = self.BuildTree(grid, x + w // 2, y, w // 2)
30         r.bottomRight = self.BuildTree(grid, x + w // 2, y + w // 2, w // 2)
31         return r
32
33     def construct(self, grid: List[List[int]]) -> Node:
34         return self.BuildTree(grid, 0, 0, len(grid))

Uriel 2023-02-27 20:57 发表评论

[LeetCode]222. Count Complete Tree Nodes (Medium) Python-2022.11.15

Uriel — Tue, 15 Nov 2022 10:58:00 GMT

给出一棵完全二叉树，求问一共多少个节点，题目要求复杂度小于O(n)，不过我用两种O(logn)*O(logn)的写法都没有直接O(n)暴搜来得快。。。

方法一：先DFS，不断走左子树的路径，算出二叉树层数max_depth，那么最后一层节点的数量为[1, 2^(max_depth-1)]，直接二分这个范围，然后算出最后一个叶子结点落在哪里，理论复杂度O(logn)*O(logn)

1 #222
2 #Runtime: 156 ms
3 #Memory Usage: 29.2 MB
4
5 # Definition for a binary tree node.
6 # class TreeNode(object):
7 #     def __init__(self, val=0, left=None, right=None):
8 #         self.val = val
9 #         self.left = left
10 #         self.right = right
11 class Solution(object):
12     def binarySearch(self, root, depth, mid, l, r):
13         if depth == self.max_depth - 1:
14             if root:
15                 return True
16             return False
17         if mid <= (l + r)//2:
18             return self.binarySearch(root.left, depth + 1, mid, l, (l + r)//2)
19         else:
20             return self.binarySearch(root.right, depth + 1, mid, (l + r)//2, r)
21
22     def countNodes(self, root):
23         """
24         :type root: TreeNode
25         :rtype: int
26         """
27         self.max_depth = 0
28         rt = root
29         while rt:
30             rt = rt.left
31             self.max_depth = self.max_depth + 1
32         if not self.max_depth:
33             return 0
34         l = 1
35         r = 2**(self.max_depth - 1)
36         while l < r:
37             mid = (l + r) // 2 + (l + r) % 2
38             if self.binarySearch(root, 0, mid, 1, 2**(self.max_depth - 1)):
39                 l = mid
40             else:
41                 r = mid - 1
42         return l + 2**(self.max_depth - 1) - 1

方法二：直接不断二分地递归找左右子树，直到遇到某个满二叉树节点，然后sum(左子树的搜索结果)+sum(右子树的搜索结果)+1（根结点），理论复杂度O(logn)*O(logn)

1 #222
2 #Runtime: 137 ms
3 #Memory Usage: 29.2 MB
4
5 # Definition for a binary tree node.
6 # class TreeNode(object):
7 #     def __init__(self, val=0, left=None, right=None):
8 #         self.val = val
9 #         self.left = left
10 #         self.right = right
11 class Solution(object):
12     def DFS(self, root, fg):
13         if not root:
14             return 1
15         if fg == 0:
16             return self.DFS(root.left, 0) + 1
17         return self.DFS(root.right, 1) + 1
18
19     def countNodes(self, root):
20         """
21         :type root: TreeNode
22         :rtype: int
23         """
24         if not root:
25             return 0
26         depth_l = self.DFS(root.left, 0)
27         depth_r = self.DFS(root.right, 1)
28         if depth_l == depth_r:
29             return 2**depth_l - 1
30         return self.countNodes(root.left) + self.countNodes(root.right) + 1

方法三：直接DFS整棵树求节点数量，复杂度O(n)，没想到这个方法反而最快...

1 #222
2 #Runtime: 87 ms
3 #Memory Usage: 29.4 MB
4
5 # Definition for a binary tree node.
6 # class TreeNode(object):
7 #     def __init__(self, val=0, left=None, right=None):
8 #         self.val = val
9 #         self.left = left
10 #         self.right = right
11 class Solution(object):
12     def DFS(self, root):
13         if not root:
14             return
15         self.ans += 1
16         self.DFS(root.left)
17         self.DFS(root.right)
18
19     def countNodes(self, root):
20         """
21         :type root: TreeNode
22         :rtype: int
23         """
24         self.ans = 0
25         self.DFS(root)
26         return self.ans

Uriel 2022-11-15 18:58 发表评论

[LeetCode]22. Generate Parentheses (Medium) Python-2022.10.21

Uriel — Fri, 21 Oct 2022 22:10:00 GMT

生成匹配的括号对，简单DFS

1 class Solution(object):
2     ans = []
3     def DFS(self, str, n, pp):
4         if n == 0:
5             if pp == 0:
6                 self.ans.append(str)
7                 str = ''
8                 return
9         if n > 0:
10             self.DFS(str+'(', n-1, pp+1)
11         if pp > 0:
12             self.DFS(str+')', n, pp-1)
13
14
15     def generateParenthesis(self, n):
16         """
17         :type n: int
18         :rtype: List[str]
19         """
20         self.ans = []
21         self.DFS('', n, 0)
22         return self.ans

Uriel 2022-10-22 06:10 发表评论

POJ 1977 Odd Loving Bakers---二分矩阵连乘

Uriel — Fri, 29 Jan 2010 19:17:00 GMT

摘要: ECUST寒假第二次练习赛的题，最后1h都在努力，结果还是没搞定，赛后纠结了好一会儿终于过了，原来矩阵乘法某处写错了，sample出了就没检查。。菜啊，完全离不开模板。。连个二分矩阵连乘都写不好。。转移矩阵是(A+I)%2,A就是按题目所给条件构造的矩阵，类似邻接矩阵。。最后用T(初始行向量)左乘该结果，构造时我完全没想字符串hash的事。。直接暴力找了。。注意：矩阵乘t-1次，相乘过程中不断%2... 阅读全文

Uriel 2010-01-30 03:17 发表评论

POJ 1747 Expression---递归

Uriel — Fri, 02 Oct 2009 17:36:00 GMT

暑假集训就看过这题，当时不会。。今天看了下Discuss之后很有感觉。。
加入下标应该不用这么麻烦。。sscanf那些神奇的东西都还不会。。就用猥琐方法硬来了。。。- -||
大牛们不吝指教。。加下标那里怎么改下。。

/*Problem: 1747  User: Uriel
   Memory: 1184K  Time: 141MS
   Language: C++  Result: Accepted*/

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

char str[105][10000];
char temp[102][4]={"0","1","2","3","4","5","6","7","8","9","10","11","12","13","14","15","16","17","18","19","20","21","22","23","24","25","26","27","28","29","30",
                   "31","32","33","34","35","36","37","38","39","40","41","42","43","44","45","46","47","48","49","50","51","52","53","54","55","56","57","58","59","60",
                   "61","62","63","64","65","66","67","68","69","70","71","72","73","74","75","76","77","78","79","80","81","82","83","84","85","86","87","88","89",
                   "90","91","92","93","94","95","96","97","98","99","100"};
int n,st;

int min(int a,int b)
{
    return a < b ? a: b;
}

void Sov(int a)
{
    if(a==1)return ;
    Sov(a-1);
    strcpy(str[a],"((A");
    strcat(str[a],temp[a-1]);
    strcat(str[a],"|B");
    strcat(str[a],temp[a-1]);
    strcat(str[a],")|(");
    strcat(str[a],str[a-1]);
    strcat(str[a],"|((A");
    strcat(str[a],temp[a-1]);
    strcat(str[a],"|A");
    strcat(str[a],temp[a-1]);
    strcat(str[a],")|(B");
    strcat(str[a],temp[a-1]);
    strcat(str[a],"|B");
    strcat(str[a],temp[a-1]);
    strcat(str[a],"))))");
}

int main()
{
    scanf("%d",&n);
    memset(str,0x00,sizeof(str));
    strcpy(str[1],"((A0|B0)|(A0|B0))");
    st=1;
    Sov(n);
    for(int i=0;i<min(strlen(str[n]),50*n);i++)
    {
        printf("%c",str[n][i]);
    }
    printf("\n");
    return 0;
}

Uriel 2009-10-03 01:36 发表评论

POJ 3233 Matrix Power Series---二分，转移矩阵

Uriel — Sun, 23 Aug 2009 14:32:00 GMT

/*Problem: 3233  User: Uriel
   Memory: 208K  Time: 172MS
   Language: C++  Result: Accepted*/
#include<stdio.h>
#include<stdlib.h>

const int MAX=65;
typedef int M[MAX][MAX];
int n,m;
M in;

void copy(M x,M y)
{
    int i,j;
    for(i=0;i<2*n;++i)
        for(j=0;j<2*n;++j)
        {
            x[i][j]=y[i][j];
        }
}

void mu(M x,M y)
{
    M C;
    int i,j,k;
    int t;
    for(i=0;i<2*n;++i)
    {
        for(j=0;j<2*n;++j)
        {
            t=0;
            for(k=0;k<2*n;++k)
            {
                if(x[i][k] && y[k][j])
                {
                    t=(t+x[i][k]*y[k][j])%m;
                }
            }
            C[i][j]=t;
        }
    }
    copy(x,C);
}

void BS(M x,int k)
{
    if(k==1)
    {
        copy(x,in);
        return;
    }
    BS(x,k/2);
    mu(x,x);
    if(k & 1)
    {
        mu(x,in);
    }
}

int main()
{
    int k;
    scanf("%d %d %d",&n,&k,&m) ;
    int i,j;
    for(i=0;i<n;i++)
     {
        for(j=0;j<n;j++)
        {
             scanf("%d",&in[i][j]);
             in[i][j+n]=in[i][j];
             in[i+n][j]=0;
             in[i+n][j+n]=0;
        }
        in[i+n][i+n]=1;
    }
    M x;
    BS(x,k);
    for(i=0;i<n;++i)
    {
        for(j=n;j<2*n;++j)
        {
            printf("%d ",x[i][j]) ;
        }
        printf("\n") ;
    }
    system("PAUSE");
    return 0 ;
}

这题搞了很久。。第一次写二分，第一次用做矩阵乘法。。
转移矩阵好强大
| A A |
| 0 I |

Uriel 2009-08-23 22:32 发表评论