国产综合视频,国产精品亚洲欧美,欧美精品一级

[LeetCode]2785. Sort Vowels in a String (Medium) Python-2023.11.13

Uriel — Mon, 13 Nov 2023 12:52:00 GMT

��一个字�W�串中的元音按ASCII码排序，其他字母位置不变

1 #2785
2 #Runtime: 175 ms (Beats 90.41%)
3 #Memory: 30 MB (Beats 6.85%)
4
5 class Solution(object):
6     def sortVowels(self, s):
7         """
8         :type s: str
9         :rtype: str
10         """
11         s, vols, pos = list(s), [], []
12         vol_set = set(['a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U'])
13         for i, ch in enumerate(s):
14             if ch in vol_set:
15                 vols.append(ch)
16                 pos.append(i)
17         vols.sort()
18         for i, ch in zip(pos, vols):
19             s[i] = ch
20         return ''.join(s)

Uriel 2023-11-13 20:52 发表评论

[LeetCode]557. Reverse Words in a String III (Easy) Python-2023.10.01

Uriel — Sun, 01 Oct 2023 09:00:00 GMT

��{一个字�W�串中的每个单词�Q�python很好实现�Q�用�I�格分割然后各自��{

1 #557
2 #Runtime: 14 ms (Beats 91.96%)
3 #Memory: 14.2 MB (Beats 88.75%)
4
5 class Solution(object):
6     def reverseWords(self, s):
7         """
8         :type s: str
9         :rtype: str
10         """
11         return ' '.join(s.split( )[::-1])[::-1]

Uriel 2023-10-01 17:00 发表评论

[LeetCode]459. Repeated Substring Pattern (Easy) Python-2023.08.21

Uriel — Mon, 21 Aug 2023 10:11:00 GMT

判断一个字�W�串是不是由某个子串重复几次构成�Q�参考Discussion get了绝妙解�?-> https://leetcode.com/problems/repeated-substring-pattern/solutions/826151/python-c-java-js-go-by-fold-and-find-w-simple-proof/

1 #459
2 #Runtime: 17 ms (Beats 88.78%)
3 #Memory: 13.7 MB (Beats 55.12%)
4
5 class Solution(object):
6     def repeatedSubstringPattern(self, s):
7         """
8         :type s: str
9         :rtype: bool
10         """
11         return s in (s + s)[1:-1]

Uriel 2023-08-21 18:11 发表评论

[LeetCode]1456. Maximum Number of Vowels in a Substring of Given Length (Medium) Python-2023.05.05

Uriel — Fri, 05 May 2023 07:06:00 GMT

求一列字�W�串中长度�ؓk的子串最多有多少个元韛_��母，先预处理到第i个字�W�有多少个元韛_��母的累加和，再移动窗口扫一�?br />

1 #1456
2 #Runtime: 135 ms (Beats 83.33%)
3 #Memory: 18.1 MB (Beats 6.94%)
4
5 class Solution(object):
6     def maxVowels(self, s, k):
7         """
8         :type s: str
9         :type k: int
10         :rtype: int
11         """
12         cnt = [0] * (len(s) + 1)
13         t, ans = 0, 0
14         for i, ch in enumerate(s):
15             if ch in 'aeiou':
16                 t += 1
17             cnt[i + 1] = t
18         for i in range(k, len(cnt)):
19             ans = max(ans, cnt[i] - cnt[i - k])
20         return ans

Uriel 2023-05-05 15:06 发表评论

[LeetCode]839. Similar String Groups (Hard) Python-2023.04.28

Uriel — Fri, 28 Apr 2023 16:55:00 GMT

�l�出一个字�W�串集合�Q�其中每个字�W�串都由相同的字母组合通过不同排列构成�Q�如果两个字�W�串可以通过交换两个字符变成相同字符�Ԍ��则二者分为同一�l�，问所有字�W�串可以分成几组�Q��ƈ查集
�q�题加不加�\径优化速度差不�?br />

1 #839
2 #Runtime: 341 ms (Beats 65.91%)
3 #Memory: 13.9 MB (Beats 79.55%)
4
5 class Solution(object):
6     def numSimilarGroups(self, strs):
7         """
8         :type strs: List[str]
9         :rtype: int
10         """
11         fa = [i for i in range(len(strs))]
12         #rank = [0] * len(strs)
13         def find(x):
14             i = x
15             while x != fa[x]:
16                 x = fa[x]
17             fa[i] = x
18             return x
19
20         def union(a, b):
21             fa[find(a)] = find(b)
22
23         def is_similar(x, y):
24             tp = 0
25             for i in range(len(x)):
26                 if x[i] != y[i]:
27                     tp += 1
28                     if tp > 2:
29                         return False
30             return True
31
32         n_group = len(strs)
33         for i in range(len(strs)):
34             for j in range(i + 1, len(strs)):
35                 if find(i) != find(j) and is_similar(strs[i], strs[j]):
36                     n_group -= 1
37                     union(i, j)
38         return n_group

Uriel 2023-04-29 00:55 发表评论

[LeetCode]1312. Minimum Insertion Steps to Make a String Palindrome (Hard) Python-2023.04.22

Uriel — Sat, 22 Apr 2023 12:23:00 GMT

求最��增加几个字�W�可以将一个字�W�串变�ؓ回文子串�Q�DP�Q�结�?原字�W�串长度-最长回文子串长度，�Ҏ��?16题（回文子串的定义是可以取不�q�箋的字�W�）

1 #1312
2 #Runtime: 398 ms (Beats 94.87%)
3 #Memory: 15 MB (Beats 94.87%)
4
5 class Solution(object):
6     def minInsertions(self, s):
7         """
8         :type s: str
9         :rtype: int
10         """
11         n = len(s)
12         dp = [[0] * n for _ in range(n)]
13         for i in range(n - 1, -1, -1):
14             dp[i][i] = 1
15             for j in range(i + 1, n):
16                 if s[i] == s[j]:
17                     dp[i][j] = dp[i + 1][j - 1] + 2
18                 else:
19                     dp[i][j] = max(dp[i + 1][j], dp[i][j - 1])
20         return len(s) - dp[0][n-1]

Uriel 2023-04-22 20:23 发表评论

[LeetCode]2390. Removing Stars From a String (Medium) Python-2023.04.11

Uriel — Tue, 11 Apr 2023 09:41:00 GMT

处理一列字�W�串�Q�遇�?��删�?和左边一个字�W�，输出操作完的字符�Ԍ��字符串水�?br />

1 #2390
2 #Runtime: 311 ms (Beats 87.74%)
3 #Memory: 16.5 MB (Beats 43.40%)
4
5 class Solution(object):
6     def removeStars(self, s):
7         """
8         :type s: str
9         :rtype: str
10         """
11         ss = []
12         for ch in s:
13             if ch == '*':
14                 ss.pop()
15             else:
16                 ss.append(ch)
17         return ''.join(ss)

Uriel 2023-04-11 17:41 发表评论

[LeetCode]28. Find the Index of the First Occurrence in a String (Medium) Python-2023.03.03

Uriel — Sat, 04 Mar 2023 14:13:00 GMT

求字�W�串haystack中子串needle�W�一�ơ出现的位置

写了个简单粗暴的�Q�先扑և�needle首字母在haystack所有出��C��|�，再看是否匚w��

1 #28
2 #Runtime: 11 ms (Beats 95.49%)
3 #Memory: 13.2 MB (Beats 98.73%)
4
5 class Solution(object):
6     def strStr(self, haystack, needle):
7         """
8         :type haystack: str
9         :type needle: str
10         :rtype: int
11         """
12         if len(needle) == 0:
13             return 0
14         occur_lst = [i for (i, ch) in enumerate(haystack) if needle[0]]
15         for i in occur_lst:
16             if haystack[i : i + len(needle)] == needle:
17                 return i
18         return -1

Uriel 2023-03-04 22:13 发表评论

[LeetCode]2306. Naming a Company (Hard) Python-2023.02.08

Uriel — Thu, 09 Feb 2023 11:46:00 GMT

�l�出一堆候选公司名�Q�str�Q�，每次从中��L��选两个，如果交换首字母之后的两个单词在原先的候选名单里都没有出玎ͼ�那么拼合�q�两个单词之后的公司名�ؓ最�l�候选公司名�Q�问一共可以组成几个候选公司名
Python的set()用法�Q�参考了Discussion->https://leetcode.com/problems/naming-a-company/solutions/3162477/clean-codes-full-explanation-set-of-array-c-java-python3/

1 #2306
2 #Runtime: 513 ms (Beats 66.67%)
3 #Memory: 33.1 MB (Beats 50%)
4
5 class Solution(object):
6     def distinctNames(self, ideas):
7         """
8         :type ideas: List[str]
9         :rtype: int
10         """
11         suf = [set() for _ in range(26)]
12         for c in ideas:
13             suf[ord(c[0]) - ord('a')].add(c[1:])
14         ans = 0
15         for i in range(25):
16             for j in range(i + 1, 26):
17                 cnt = len(suf[i] & suf[j])
18                 ans += 2 * (len(suf[i]) - cnt) * (len(suf[j]) - cnt)
19         return ans

Uriel 2023-02-09 19:46 发表评论

[LeetCode]438. Find All Anagrams in a String (Medium) Python-2023.02.05

Uriel — Sun, 05 Feb 2023 12:49:00 GMT

�l�出两个字符串p和s�Q�问p的某�U�排列是否是s的子�Ԍ��如果存在�Q�输出所有匹配的位置。类似第567题（http://www.shnenglu.com/Uriel/articles/229660.html�Q?br />先用Counter计算p各个字符的出现次敎ͼ�然后用sliding window�Q�s出现在sliding window中的字符对应的Counter�?�Q�发现某位置sliding window让Counter中所有计数归零时记录位置

1 #438
2 #Runtime: 371 ms (Beats 12.21%)
3 #Memory: 14.6 MB (Beats 29.63%)
4
5 class Solution(object):
6     def findAnagrams(self, s, p):
7         """
8         :type s: str
9         :type p: str
10         :rtype: List[int]
11         """
12         cnt_p = Counter(p)
13         l = len(p)
14         ans = []
15         for i in range(len(s)):
16             if s[i] in cnt_p:
17                 cnt_p[s[i]] -= 1
18             if i >= l and s[i-l] in cnt_p:
19                 cnt_p[s[i-l]] += 1
20             if all([cnt_p[j] == 0 for j in cnt_p]):
21                 ans.append(i - l + 1)
22         return ans

Uriel 2023-02-05 20:49 发表评论

[LeetCode]567. Permutation in String (Medium) Python-2023.02.04

Uriel — Sat, 04 Feb 2023 09:28:00 GMT

�l�出两个字符串s1和s2�Q�问s1的某�U�排列是否是s2的子�Ԍ��又一python Counter的应用，先用Counter计算s1各个字符的出现次敎ͼ�然后用sliding window�Q�s2出现在sliding window中的字符对应的Counter�?�Q�然后判断是否存在某个sliding window让Counter中所有计数归�?br />

1 #567
2 #Runtime: 299 ms (Beats 32.65%)
3 #Memory: 14 MB(Beats 23.38%)
4
5 class Solution(object):
6     def checkInclusion(self, s1, s2):
7         """
8         :type s1: str
9         :type s2: str
10         :rtype: bool
11         """
12         cnt_s1 = Counter(s1)
13         l1 = len(s1)
14         for i in range(len(s2)):
15             if s2[i] in cnt_s1:
16                 cnt_s1[s2[i]] -= 1
17             if i >= l1 and s2[i-l1] in cnt_s1:
18                 cnt_s1[s2[i-l1]] += 1
19             if all([cnt_s1[i] == 0 for i in cnt_s1]):
20                 return True
21         return False

Uriel 2023-02-04 17:28 发表评论

[LeetCode]953. Verifying an Alien Dictionary (Easy) Python-2023.02.02

Uriel — Thu, 02 Feb 2023 13:07:00 GMT

�l�出26个字母的另一�U�顺序以及这个顺序下的几个单词，问是否符合字母序�?br />用dict构徏原本�?6个字母和新字母序列的映射�Q�将新序的单词映��回原始26个字母序�Q�再直接�Ҏ��盔R��字符�?br />

1 #953
2 #Runtime: 18 ms (Beats 91.10%)
3 #Memory: 13.4 MB (Beats 76.87%)
4
5 class Solution(object):
6     def isAlienSorted(self, words, order):
7         """
8         :type words: List[str]
9         :type order: str
10         :rtype: bool
11         """
12         ori_id = dict()
13         a = "abcdefghijklmnopqrstuvwxyz"
14         for i in range(26):
15             ori_id[order[i]] = a[i]
16         for i in range(len(words)):
17             trans_s = []
18             for j in words[i]:
19                 trans_s.append(ori_id[j])
20             trans_s = ''.join(trans_s)
21             if i == 0:
22                 pre = trans_s
23             else:
24                 if pre > trans_s:
25                     return False
26                 pre = trans_s
27         return True

Uriel 2023-02-02 21:07 发表评论

[LeetCode]1071. Greatest Common Divisor of Strings (Easy) Python-2023.02.01

Uriel — Wed, 01 Feb 2023 07:34:00 GMT

�l�出两个字符�Ԍ��求他们的最长公共子�Ԍ��q�且两个字符串都是由�q�一公共子串重复若干�ơ构成�?br />水题�Q�从两个字符串中较短的一个的长度l开始枚举，l�?

1 #1071
2 #Runtime: 21 ms (Beats 73.53%)
3 #Memory: 13.6 MB (Beats 30.88%)
4
5 class Solution(object):
6     def gcdOfStrings(self, str1, str2):
7         """
8         :type str1: str
9         :type str2: str
10         :rtype: str
11         """
12         for s_len in range(1 + min(len(str1), len(str2)), 0, -1):
13             if len(str1) % s_len != 0 or len(str2) % s_len:
14                 continue
15             ss1 = str1[0:s_len] * (len(str1) // s_len)
16             ss2 = str1[0:s_len] * (len(str2) // s_len)
17             if ss1 == str1 and ss2 == str2:
18                 return str1[0:s_len]
19         return ""

Uriel 2023-02-01 15:34 发表评论

[LeetCode]472. Concatenated Words (Hard) Python-2023.01.27

Uriel — Fri, 27 Jan 2023 09:29:00 GMT

�l�定一堆单词组成的list�Q�输出其中可以由臛_��两个list中其他单词组成的所有单词（可以重复使用单词�Q?br />
DP�Q�对于每一个单词w�Q�开一个DP list�Q�list长度为w的长�?1�Q�dp[0]=1�Q�之后若直到w的第i位可以用单词表中的其他单词组成，则dp[i]=1�Q�若dp[len(w)]=1�Q�则输出该单�?br />先将list转�ؓset�Q�加速后�l�查扑֍�词的速度

复杂度O(n*L*L)�Q�运行效率好像一�?br />

1 #472
2 #Runtime: 1236 ms (Beats 20%)
3 #Memory: 16.6 MB (Beats 88.57%)
4
5 class Solution(object):
6     def findAllConcatenatedWordsInADict(self, words):
7         """
8         :type words: List[str]
9         :rtype: List[str]
10         """
11         word_dict = set(words)
12         ans = []
13         for w in words:
14             dp = [0] * (len(w) + 1)
15             dp[0] = 1
16             for i in range(len(w)):
17                 if not dp[i]:
18                     continue
19                 for j in range(i + 1, len(w) + 1):
20                     if j - i < len(w) and w[i:j] in word_dict:
21                         dp[j] = 1
22                 if dp[len(w)]:
23                     ans.append(w)
24                     break
25         return ans

Uriel 2023-01-27 17:29 发表评论

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

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

�l�出一��完全二叉树�Q�求问一共多��个节点�Q�题目要求复杂度��于O(n)�Q�不�q�我用两�U�O(logn)*O(logn)的写法都没有直接O(n)暴搜来得快。。�?br />
�Ҏ��一�Q�先DFS�Q�不断走左子树的路径�Q�算��Z��叉树层数max_depth�Q�那么最后一层节点的数量为[1, 2^(max_depth-1)]�Q�直接二分这个范��_��然后��出最后一个叶子结点落在哪里，理论复杂度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

�Ҏ��二：直接不断二分地递归扑ַ�叛_��树，直到遇到某个满二叉树节点�Q�然后sum(左子树的搜烦�l�果)+sum(叛_��树的搜烦�l�果)+1�Q�根�l�点�Q�，理论复杂度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整棵树求节点数量�Q�复杂度O(n)�Q�没惛_��q�个�Ҏ��反而最�?..

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]151. Reverse Words in a String (Medium) Python-2022.11.13

Uriel — Sun, 13 Nov 2022 10:56:00 GMT

��一串字�W�以�I�格分成不同单词�Q�然后倒序输出�Q�可能有�q�箋多个�I�格�Q�但倒序输出时只保留一个，例如

Input: s = "a good example"

Output: "example good a"

�Ҏ��一�Q�用Python自带的字�W�串split()�Q�很方便

1 #151
2 #Runtime: 34 ms
3 #Memory Usage: 13.7 MB
4
5 class Solution(object):
6     def reverseWords(self, s):
7         """
8         :type s: str
9         :rtype: str
10         """
11
12         return ' '.join(s.split()[::-1])

�Ҏ��二：手工切割字符�?br />

1 #151
2 #Runtime: 49 ms
3 #Memory Usage: 13.6 MB
4
5 class Solution(object):
6     def reverseWords(self, s):
7         """
8         :type s: str
9         :rtype: str
10         """
11         ans = []
12         tp = ""
13         for i in s:
14             if i == ' ':
15                 if len(tp) > 0:
16                     ans.append(tp)
17                     tp = ""
18             else:
19                 tp += i
20         if len(tp) > 0:
21             ans.append(tp)
22             tp = " "
23         return ' '.join(ans[i] for i in range(len(ans) - 1, -1, -1))

Uriel 2022-11-13 18:56 发表评论

[LeetCode]899. Orderly Queue (Hard) Python-2022.11.06

Uriel — Sun, 06 Nov 2022 09:05:00 GMT

�l�一个字�W�串�Q�每�ơ可以把头k位的其中一个字�W�调臛_��W�尾端，操作�ơ数不限�Q�问可以得到的字典序最��的字符串是什�?br />
若k=1�Q�O(n^2)�Q�模拟每�ơ挪一位去末尾然后求最��可�?br />若k>2�Q�则理论上可以实��C�Q意交换元素位�|�，那只要把string转�ؓlist直接sort输出

1 #899
2 #Runtime: 38 ms
3 #Memory Usage: 13.4 MB
4
5 class Solution(object):
6     def orderlyQueue(self, s, k):
7         """
8         :type s: str
9         :type k: int
10         :rtype: str
11         """
12         if k == 1:
13             t = s
14             for i in range(1, len(s)):
15                 if t > s[i : ] + s[0 : i]:
16                     t = s[i : ] + s[0 : i]
17         else:
18             t = ''.join(sorted(list(s)))
19         return t

Uriel 2022-11-06 17:05 发表评论

[LeetCode]12. Integer to Roman (Medium) Python-2022.11.02

Uriel — Wed, 02 Nov 2022 17:46:00 GMT

阿拉伯数字�{�|�马字符�Q�简单字�W�串处理�Q�用了python的dict

1 #12
2 #Runtime: 59 ms
3 #Memory Usage: 13.2 MB
4
5 class Solution(object):
6     def intToRoman(self, num):
7         """
8         :type num: int
9         :rtype: str
10         """
11         dict = {1 : 'I', 5 : 'V', 10 : 'X', 50 : 'L', 100 : 'C', 500 : 'D', 1000 : 'M'}
12         nt = 1
13         ans = []
14         while num > 0:
15             tp = num % 10
16             if tp == 4:
17                 ans.append(dict[nt] + dict[5*nt])
18             elif tp == 9:
19                 ans.append(dict[nt] + dict[10*nt])
20             elif tp < 4 and tp > 0:
21                 ans.append(dict[nt] * tp)
22             elif tp >= 5:
23                 ans.append(dict[5*nt] + dict[nt] * (tp - 5))
24             num = num // 10
25             nt = nt * 10
26         ans.reverse()
27         return ''.join(ans)

Uriel 2022-11-03 01:46 发表评论

POJ 3450 Corporate Identity---KMP or strstr or Suffix Array

Uriel — Tue, 10 May 2011 07:24:00 GMT

摘要: 最�q�一直在准备省赛,基本都是复习��法和组队赛,基本没切什么题. 昨天想省赛前POJ刷到1200�?��p��光光�Ҏ��了下POJ�q�的�? 发现了这道字�W�串,��Z��复习下KMP和后�~�数组啥的. �q�题跟POJ 3080基本完全一�?当年写过个解题报�?http://www.shnenglu.com/Urie... 阅读全文

Uriel 2011-05-10 15:24 发表评论

Uriel — Sat, 30 Oct 2010 15:40:00 GMT

摘要: �W�二道AC自动机，对DP状态�{�U�L��一�Ҏ��觉了。。�?nbsp; �q�题基本�?778一��P��不过要高�_�ֺ��Q�所以就想用JAVA试试�Q�正好JAVA很久不碰了，跟没学过一��P��Regional之前�l�习�l�习�Q�结果做得我痛不�Ʋ生。�?0�Q?0-03�Q?0�Q?... 阅读全文

Uriel 2010-10-30 23:40 发表评论

2010 Hangzhou Regional On-Site J Infinite monkey theorem---KMP+DP

Uriel — Fri, 29 Oct 2010 15:17:00 GMT

题意�Q�有n个键�Q�按每个键有一概率Pi�Q�给定一个字�W�串S�Q�问按m�ơ敲��个字�W�串的概�?br>            现场赛茫茫多的队伍过了这题，可以我们学校两队都没�q�。�? =
            在HDOJ上组队做杭州赛的题的时候纠�l�了半天也没�q�。。赛后听说思�\��是KMP�Q�DP�Q�我状态�{�U�d��理有问题。�?br>            今天又搞了一晚上�Q�请教Ziroy大牛之后发现错误原因在s状态不用处�?br>思�\�Q�dp转移方程很好惻I��dp[i][j]表示已经按了i�ơ，当前状态是j(S的第j个字�?�Q�概率是多少
            具体实现�q�程见代码及注释

//Problem: HDOJ 3689
//Source: 2010 Hangzhou Regional On-Site J Infinite monkey theorem
//Solution: KMP+DP(like DFA)
//Status: Accepted
//Running Time: 15Ms
//Author: Uriel
//2010.10.29

#include<stdio.h>
#include<string.h>
double dp[1050][20],dd[20];
char st[30],ch[30];
double p[30];
int nxt[30],s;

void GetNext(char* str){
    nxt[0]=-1;
    int i=0,j=-1;
    while(str[i]){
        if(j==-1 || str[i]==str[j]){
            i++; j++; nxt[i]=j;
        }
        else j=nxt[j];
    }
}

int main(){
    int n,m;
    int i,j,k;
    while(scanf("%d %d",&n,&m),n|m){
        for(i=0;i<n;i++){
            scanf("%s",st);
            ch[i]=st[0];
            scanf("%lf",&p[i]);
        }
        scanf("%s",st);
        for(i=0;i<=m;++i){
            for(j=0;j<=s;++j)dp[i][j]=0.0;
        }
        s=strlen(st);
        GetNext(st);
        dp[0][0]=1.0;
        for(i=1;i<=m;i++){ //共按m��?/span>
            for(j=0;j<s;j++){ //枚�D当前状�?不用考虑j=s,因�ؓ�q�时已经满��要求,不用��下�?!
                for(k=0;k<n;++k){ //枚�D当前�q�次按哪个键
                    if(!j){ //如果当前状态是�q�没有按出正��串的前�~�
                        if(ch[k]==st[0])dp[i][1]+=dp[i-1][0]*p[k]; //如果�q�次按的是川的第一个字�?状态从0变�ؓ1
                        else //否则0状态的概率累加
                            dp[i][0]+=dp[i-1][0]*p[k];
                    }
                    else if(ch[k]==st[j]){ //如果当前按对了该串当前状态的后一个字�?/span>
                        dp[i][j+1]+=dp[i-1][j]*p[k]; //状�?1
                    }
                    else{
                        int tp=j;
                        while(tp>-1 && ch[k]!=st[tp])tp=nxt[tp]; //利用KMP的Next函数当前状态计��按下k之后的状�?能匹配的前缀长度)
                        if(tp==-1)dp[i][0]+=dp[i-1][j]*p[k]; //如果当前匚w��p�|,状态变�?�Q�且累加状�?的概�?/span>
                        else //否则状态�ؓtp+1,状态tp+1的概率篏�?/span>
                            dp[i][tp+1]+=dp[i-1][j]*p[k];
                    }
                }
            }
        }
        double ans=0.0;
        for(i=1;i<=m;++i)ans+=dp[i][s];//所有长度能得到状态s的概率之和即为所�?/span>
        printf("%.2f%%\n",100*ans);
    }
    return 0;
}

�q�么大水的题搞了�q�么久。。而且字符串又是我的�Q务。。杯兗��?br> 下周三去成都�Q?9h45min�Q�第一�ơ坐�q�么长时间火车。�?br> ��祷DSW Chengdu Regional 好运。。Regional是如此的宝贵。。不知道以后�q�有没有��Z��。�?

Uriel 2010-10-29 23:17 发表评论

POJ 3080 Blue Jeans---KMP

Uriel — Tue, 13 Oct 2009 14:46:00 GMT

摘要: 后缀数组�q�是没懂。。Regional之前应该是来不及了。�?nbsp; �q�题可以�l�后�~�数组的。。KMP水过��M��。。后来发现strstr也行。。跟KMP一�?6Ms。。�?nbsp; strstr版本�Q?/**//*Problem: 3080&n... 阅读全文

Uriel 2009-10-13 22:46 发表评论

POJ 3461 Oulipo---KMP

Uriel — Fri, 28 Aug 2009 21:06:00 GMT

KMP变�Ş。。匹配了一�ơ之后不退出。。加上Next的值��l�比下去�Q�直��C��?br>

/*Problem: 3461  User: Uriel
  Memory: 1232K  Time: 125MS
  Language: C  Result: Accepted*/

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

int kmpMatch(char* Src, char* Pattern);
int GetNextdest(char* Pattern, int next[]);
int Next[10001];

int main()
{
    char source[1000001];
    char dest[10001];
    int i,n;
    scanf("%d",&n);
    for(i=0;i<n;i++)
    {
        memset(dest,0x00,sizeof(dest));
        memset(source,0x00,sizeof(source));
        scanf("%s",dest);
        scanf("%s",source);
        GetNextdest(dest,Next);
        printf("%d\n",kmpMatch(source, dest));
    }
    return 0;
}

int kmpMatch(char* Src, char* Pattern)
{
    int i=0,j=0;
    int s_len,p_len;
    int sum=0;
    s_len=strlen(Src);
    p_len=strlen(Pattern);

flag: while(i<s_len && j<p_len)
{
    if(j==-1||Src[i]==Pattern[j])
    {
        ++i;
        ++j;
    }
    else
    {
        j=Next[j];
    }
}
if (j==p_len && i<s_len){sum++;j=Next[j];goto flag;}
else if(j==p_len && i==s_len){sum++;return sum;}
else
    return sum;
}

int GetNextdest(char* Pattern, int next[])
{
    int i=1,j=0;
    int p_len=strlen(Pattern);

    next[0]=-1;
    while(i<p_len)
    {
        if(Pattern[i]==Pattern[j]||j==-1)
        {
            ++i;++j;
            if(Pattern[i]!=Pattern[j])next[i]=j;
            else
                next[i]= next[j];
        }
        else
            j=next[j];
    }
    return 0;
}

Uriel 2009-08-29 05:06 发表评论

POJ 2406 Power Strings---KMP

Uriel — Fri, 28 Aug 2009 21:00:00 GMT

求一个字�W�串有几�ơ匹配，KMP变�Ş。。去东华前一天做出来时很高兴啊。。可惜那天看的另两道字符串都没出�?br>

/*Problem: 2406  User: Uriel
Memory: 5100K  Time: 141MS
Language: C  Result: Accepted*/

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

int GetNextVal(char* Pattern, long next[]);
long Next[1000001];

char dest[1000001];

int main()
{
  long n,key;
  while(scanf("%s",dest)!=EOF)
  {
    if(dest[0]=='.')exit(0);
    n=strlen(dest);
    GetNextVal(dest,Next);
    key=n/(n-Next[n-1]);
    if(n%(n-Next[n-1])==0)printf("%d\n",key);
    else
        printf("1\n");
    memset(dest,0x00,sizeof(dest));
  }
    return 0;
}

int GetNextVal(char* Pattern, long next[])
{
   long i=1,j=0;
   long p_len=strlen(Pattern);

   next[0]=0;
   while(i<p_len)
   {
      if(Pattern[i]==Pattern[j])
      {
         next[i]=j+1;
         i++;
         j++;
      }
      else if(j>0)
      {
          j=next[j-1];
      }
      else
      {
          next[i]=0;
          i++;
      }
  }
  return 0;
}

Uriel 2009-08-29 05:00 发表评论