C++博客-Uriel's Corner-文章分类-字符串处理

[LeetCode]1239. Maximum Length of a Concatenated String with Unique Characters (Medium) Python-2024.01.23

Uriel — Tue, 23 Jan 2024 10:54:00 GMT

给出一些字符串，问取其中若干字符串能拼出的不含重复字母的最长字串
先过滤掉自身有重复字母的，然后设一个内含set的列表，每次扫一遍列表看能否加入当前字符串，最后取列表中最多字母的set

#1239
#Runtime: 97 ms (Beats 50%)
#Memory: 53.4 MB (Beats 8.49%)

class Solution(object):
    def maxLength(self, arr):
        """
        :type arr: List[str]
        :rtype: int
        """
        candidate = []
        for s in arr:
            u = set(s)
            if len(s) == len(u):
                candidate.append(u)
        ans = [set()]
        maxx = 0
        for i in candidate:
            for j in ans:
                if not i & j:
                    ans.append(i | j)
                    maxx = max(maxx, len(i | j))
        return maxx

Uriel 2024-01-23 18:54 发表评论

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

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

将一个字符串中的元音按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

翻转一个字符串中的每个单词，python很好实现，用空格分割然后各自翻转

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

判断一个字符串是不是由某个子串重复几次构成，参考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

求一列字符串中长度为k的子串最多有多少个元音字母，先预处理到第i个字符有多少个元音字母的累加和，再移动窗口扫一遍

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

给出一个字符串集合，其中每个字符串都由相同的字母组合通过不同排列构成，如果两个字符串可以通过交换两个字符变成相同字符串，则二者分为同一组，问所有字符串可以分成几组，并查集
这题加不加路径优化速度差不多

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

求最少增加几个字符可以将一个字符串变为回文子串，DP，结果=原字符串长度-最长回文子串长度，方法同516题（回文子串的定义是可以取不连续的字符）

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

处理一列字符串，遇到*就删除*和左边一个字符，输出操作完的字符串，字符串水题

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

求字符串haystack中子串needle第一次出现的位置

写了个简单粗暴的，先找出needle首字母在haystack所有出现位置，再看是否匹配

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

给出一堆候选公司名（str），每次从中任意选两个，如果交换首字母之后的两个单词在原先的候选名单里都没有出现，那么拼合这两个单词之后的公司名为最终候选公司名，问一共可以组成几个候选公司名
Python的set()用法，参考了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

给出两个字符串p和s，问p的某种排列是否是s的子串，如果存在，输出所有匹配的位置。类似第567题（http://www.cppblog.com/Uriel/articles/229660.html）
先用Counter计算p各个字符的出现次数，然后用sliding window，s出现在sliding window中的字符对应的Counter减1，发现某位置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

给出两个字符串s1和s2，问s1的某种排列是否是s2的子串，又一python Counter的应用，先用Counter计算s1各个字符的出现次数，然后用sliding window，s2出现在sliding window中的字符对应的Counter减1，然后判断是否存在某个sliding window让Counter中所有计数归零

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

给出26个字母的另一种顺序以及这个顺序下的几个单词，问是否符合字母序。
用dict构建原本的26个字母和新字母序列的映射，将新序的单词映射回原始26个字母序，再直接对比相邻字符串

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开始枚举，l～1

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

给定一堆单词组成的list，输出其中可以由至少两个list中其他单词组成的所有单词（可以重复使用单词）

DP，对于每一个单词w，开一个DP list，list长度为w的长度+1，dp[0]=1，之后若直到w的第i位可以用单词表中的其他单词组成，则dp[i]=1，若dp[len(w)]=1，则输出该单词
先将list转为set，加速后续查找单词的速度

复杂度O(n*L*L)，运行效率好像一般

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

给出一棵完全二叉树，求问一共多少个节点，题目要求复杂度小于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]151. Reverse Words in a String (Medium) Python-2022.11.13

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

将一串字符以空格分成不同单词，然后倒序输出，可能有连续多个空格，但倒序输出时只保留一个，例如

Input: s = "a good example"

Output: "example good a"

方法一：用Python自带的字符串split()，很方便

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])

方法二：手工切割字符串

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

给一个字符串，每次可以把头k位的其中一个字符调至字符尾端，操作次数不限，问可以得到的字典序最小的字符串是什么

若k=1，O(n^2)，模拟每次挪一位去末尾然后求最小可能
若k>2，则理论上可以实现任意交换元素位置，那只要把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

阿拉伯数字转罗马字符，简单字符串处理，用了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

摘要: 最近一直在准备省赛,基本都是复习算法和组队赛,基本没切什么题. 昨天想省赛前POJ刷到1200先,就跟光光对拍了下POJ过的题. 发现了这道字符串,顺便复习下KMP和后缀数组啥的. 这题跟POJ 3080基本完全一样,当年写过个解题报告 http://www.cppblog.com/Urie... 阅读全文

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

POJ 1625 Censored!---AC 自动机+DP+高精度

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

摘要: 第二道AC自动机，对DP状态转移有一点感觉了。。。这题基本和2778一样，不过要高精度，所以就想用JAVA试试，正好JAVA很久不碰了，跟没学过一样，Regional之前练习练习，结果做得我痛不欲生。。00：00-03：10，0... 阅读全文

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

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

//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次
            for(j=0;j<s;j++){ //枚举当前状态,不用考虑j=s,因为这时已经满足要求,不用算下去!!
                for(k=0;k<n;++k){ //枚举当前这次按哪个键
                    if(!j){ //如果当前状态是还没有按出正确串的前缀
                        if(ch[k]==st[0])dp[i][1]+=dp[i-1][0]*p[k]; //如果这次按的是川的第一个字母,状态从0变为1
                        else //否则0状态的概率累加
                            dp[i][0]+=dp[i-1][0]*p[k];
                    }
                    else if(ch[k]==st[j]){ //如果当前按对了该串当前状态的后一个字母
                        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]; //如果当前匹配失败,状态变为0，且累加状态0的概率
                        else //否则状态为tp+1,状态tp+1的概率累加
                            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的概率之和即为所求
        printf("%.2f%%\n",100*ans);
    }
    return 0;
}

        这么大水的题搞了这么久。。而且字符串又是我的任务。。杯具。。
        下周三去成都，39h45min，第一次坐这么长时间火车。。
        祈祷DSW Chengdu Regional 好运。。Regional是如此的宝贵。。不知道以后还有没有机会。。

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

POJ 3080 Blue Jeans---KMP

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

摘要: 后缀数组还是没懂。。Regional之前应该是来不及了。。这题可以练后缀数组的。。KMP水过去了。。后来发现strstr也行。。跟KMP一样16Ms。。。 strstr版本： /**//*Problem: 3080&n... 阅读全文

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

POJ 3461 Oulipo---KMP

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

KMP变形。。匹配了一次之后不退出。。加上Next的值继续比下去，直到串尾

/*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

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

/*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 发表评论