Posts tagged as “string”

花花酱 LeetCode 639. Decode Ways II

By zxi on November 18, 2017

Problem:

A message containing letters from A-Z is being encoded to numbers using the following mapping way:

'A' -> 1

'B' -> 2

...

'Z' -> 26

Beyond that, now the encoded string can also contain the character ‘*’, which can be treated as one of the numbers from 1 to 9.

Given the encoded message containing digits and the character ‘*’, return the total number of ways to decode it.

Also, since the answer may be very large, you should return the output mod 10⁹ + 7.

Example 1:

Input: "*"

Output: 9

Explanation: The encoded message can be decoded to the string:

"A", "B", "C", "D", "E", "F", "G", "H", "I".

Example 2:

1 2	Input: "1*" Output: 9 + 9 = 18

Note:

The length of the input string will fit in range [1, 10⁵].
The input string will only contain the character ‘*’ and digits ‘0’ – ‘9’.

Idea:

Time complexity: O(n)

Space complexity: O(1)

Solution:

C++

// Author: Huahua

// Runtime: 58 ms

class Solution {

public:

int numDecodings(string s) {

if (s.empty()) return 0;

// dp[-1] dp[0]

long dp[2] = {1, ways(s[0])};

for (int i = 1; i < s.length(); ++i) {

long dp_i = ways(s[i]) * dp[1] + ways(s[i - 1], s[i]) * dp[0];

dp_i %= kMod;

dp[0] = dp[1];

dp[1] = dp_i;

}

return dp[1];

}

private:

static constexpr int kMod = 1000000007;

int ways(char c) {

if (c == '0') return 0;

if (c == '*') return 9;

return 1;

}

int ways(char c1, char c2) {

if (c1 == '*' && c2 == '*')

return 15;

if (c1 == '*') {

return (c2 >= '0' && c2 <= '6') ? 2 : 1;

} else if (c2 == '*') {

switch (c1) {

case '1': return 9;

case '2': return 6;

default: return 0;

}

} else {

int prefix = (c1 - '0') * 10 + (c2 - '0');

return prefix >= 10 && prefix <= 26;

}

};

Related Problems:

[解题报告] LeetCode 91. Decode Ways

花花酱 LeetCode 72. Edit Distance

By zxi on October 15, 2017

Problem:

Given two words word1 and word2, find the minimum number of steps required to convert word1 to word2. (each operation is counted as 1 step.)

You have the following 3 operations permitted on a word:

a) Insert a character
b) Delete a character
c) Replace a character

Idea:

Dynamic Programming

Solution:

Recursive

// Author: Huahua

// Runtime: 13 ms

class Solution {

public:

int minDistance(string word1, string word2) {

int l1 = word1.length();

int l2 = word2.length();

d_ = vector<vector<int>>(l1 + 1, vector<int>(l2 + 1, -1));

return minDistance(word1, word2, l1, l2);

}

private:

vector<vector<int>> d_;

// minDistance from word1[0:l1-1] to word2[0:l2-1]

int minDistance(const string& word1, const string& word2, int l1, int l2) {

if (l1 == 0) return l2;

if (l2 == 0) return l1;

if (d_[l1][l2] >= 0) return d_[l1][l2];

int ans;

if (word1[l1 - 1] == word2[l2 - 1])

ans = minDistance(word1, word2, l1 - 1, l2 - 1);

else

ans = min(minDistance(word1, word2, l1 - 1, l2 - 1),

min(minDistance(word1, word2, l1 - 1, l2),

minDistance(word1, word2, l1, l2 - 1))) + 1;

return d_[l1][l2] = ans;

}

};

Iterative

// Author: Huahua

// Runtime: 9 ms

class Solution {

public:

int minDistance(string word1, string word2) {

int l1 = word1.length();

int l2 = word2.length();

// d[i][j] := minDistance(word1[0:i - 1], word2[0:j - 1]);

vector<vector<int>> d(l1 + 1, vector<int>(l2 + 1, 0));

for (int i = 0; i <= l1; ++i)

d[i][0] = i;

for (int j = 0; j <= l2; ++j)

d[0][j] = j;

for (int i = 1; i <= l1; ++i)

for (int j = 1; j <= l2; ++j) {

int c = (word1[i - 1] == word2[j - 1]) ? 0 : 1;

d[i][j] = min(d[i - 1][j - 1] + c,

min(d[i][j - 1], d[i - 1][j]) + 1);

}

return d[l1][l2];

}

};

花花酱 LeetCode 488. Zuma Game

By zxi on October 9, 2017

https://leetcode.com/problems/zuma-game/description/

Problem:

Think about Zuma Game. You have a row of balls on the table, colored red(R), yellow(Y), blue(B), green(G), and white(W). You also have several balls in your hand.

Each time, you may choose a ball in your hand, and insert it into the row (including the leftmost place and rightmost place). Then, if there is a group of 3 or more balls in the same color touching, remove these balls. Keep doing this until no more balls can be removed.

Find the minimal balls you have to insert to remove all the balls on the table. If you cannot remove all the balls, output -1.

Examples:
Input: “WRRBBW”, “RB”
Output: -1
Explanation: WRRBBW -> WRR[R]BBW -> WBBW -> WBB[B]W -> WW

Input: “WWRRBBWW”, “WRBRW”
Output: 2
Explanation: WWRRBBWW -> WWRR[R]BBWW -> WWBBWW -> WWBB[B]WW -> WWWW -> empty

Input:“G”, “GGGGG”
Output: 2
Explanation: G -> G[G] -> GG[G] -> empty

Input: “RBYYBBRRB”, “YRBGB”
Output: 3
Explanation: RBYYBBRRB -> RBYY[Y]BBRRB -> RBBBRRB -> RRRB -> B -> B[B] -> BB[B] -> empty

Note:

You may assume that the initial row of balls on the table won’t have any 3 or more consecutive balls with the same color.
The number of balls on the table won’t exceed 20, and the string represents these balls is called “board” in the input.
The number of balls in your hand won’t exceed 5, and the string represents these balls is called “hand” in the input.
Both input strings will be non-empty and only contain characters ‘R’,’Y’,’B’,’G’,’W’.

Idea: Search

Solution1: C++ / Search

// Author: Huahua

// Runtime: 3 ms

class Solution {

public:

int findMinStep(string board, string hand) {

vector<int> h(128, 0);

for (char color : hand) ++h[color];

return dfs(board, h);

}

private:

// Return the min # of balls needed in hand to clear the board.

// Returns -1 if not possible.

int dfs(const string& board, vector<int>& hand) {

if (board.empty()) return 0;

int ans = INT_MAX;

int i = 0;

int j = 0;

while (i < board.size()) {

while (j < board.size() && board[i] == board[j]) ++j;

// board[i] ~ board[j - 1] have the same color

const char color = board[i];

// Number of balls needed to clear board[i] ~ board[j - 1]

const int b = 3 - (j - i);

// Have sufficient balls in hand

if (hand[color] >= b) {

// Remove board[i] ~ board[j - 1] and update the board

string nb = update(board.substr(0, i) + board.substr(j));

// Find the solution on new board with updated hand

hand[color] -= b;

int r = dfs(nb, hand);

if (r >= 0) ans = min(ans, r + b);

// Recover the balls in hand

hand[color] += b;

}

i = j;

}

return ans == INT_MAX ? -1 : ans;

}

// Update the board by removing all consecutive 3+ balls.

// "YWWRRRWWYY" -> "YWWWWYY" -> "YYY" -> ""

string update(string board) {

int i = 0;

while (i < board.size()) {

int j = i;

while (j < board.size() && board[i] == board[j]) ++j;

if (j - i >= 3) {

board = board.substr(0, i) + board.substr(j);

i = 0;

} else {

++i;

}

return board;

}

};

花花酱 LeetCode 678. Valid Parenthesis String

By zxi on September 30, 2017

Problem:

Given a string containing only three types of characters: ‘(‘, ‘)’ and ‘*’, write a function to check whether this string is valid. We define the validity of a string by these rules:

Any left parenthesis '(' must have a corresponding right parenthesis ')'.
Any right parenthesis ')' must have a corresponding left parenthesis '('.
Left parenthesis '(' must go before the corresponding right parenthesis ')'.
'*' could be treated as a single right parenthesis ')' or a single left parenthesis '(' or an empty string.
An empty string is also valid.

Example 1:

1 2	Input: "()" Output: True

Example 2:

1 2	Input: "(*)" Output: True

Example 3:

1 2	Input: "(*))" Output: True

Note:

The string size will be in the range [1, 100].

Idea:

Dynamic Programming / Counting

Solution 1:

C++ / DP / Top-down O(n^3)

// Author: Huahua

// Runtime: 12 ms

class Solution {

public:

bool checkValidString(const string& s) {

int l = s.length();

m_ = vector<vector<int>>(l, vector<int>(l, -1));

return isValid(s, 0, l - 1);

}

private:

vector<vector<int>> m_;

bool isValid(const string& s, int i, int j) {

if (i > j) return true;

if (m_[i][j] >= 0) return m_[i][j];

if (i == j) return m_[i][j] = (s[i] == '*');

if ((s[i] == '(' || s[i] == '*')

&&(s[j] == ')' || s[j] == '*')

&& isValid(s, i + 1, j - 1))

return m_[i][j] = 1;

for (int p = i; p < j; ++p)

if (isValid(s, i, p) && isValid(s, p + 1, j))

return m_[i][j] = 1;

return m_[i][j] = 0;

}

};

C++ / DP/ Bottom-up O(n^3)

// Author: Huahua

// Runtime: 12 ms

class Solution {

public:

bool checkValidString(const string& s) {

int l = s.length();

if (l == 0) return true;

vector<vector<int>> dp(l, vector<int>(l, 0));

for (int i = 0; i < l; ++i)

if (s[i] == '*') dp[i][i] = 1;

for (int len = 2; len <= l; ++len)

for (int i = 0; i <= l - len; ++i) {

int j = i + len - 1;

// (...), *...), (...*, *...*

if ((s[i] == '(' || s[i] == '*')

&&(s[j] == ')' || s[j] == '*'))

if (len == 2 || dp[i + 1][j - 1]) {

dp[i][j] = 1;

continue;

}

for (int k = i; k < j; ++k)

if (dp[i][k] && dp[k + 1][j]) {

dp[i][j] = 1;

break;

}

return dp[0][l - 1];

}

};

C++ / Counting O(n)

// Author: Huahua

// Runtime: 3 ms

class Solution {

public:

bool checkValidString(string s) {

int min_op = 0;

int max_op = 0;

for (char c : s) {

if (c == '(') ++min_op; else --min_op;

if (c != ')') ++max_op; else --max_op;

if (max_op < 0) return false;

min_op = max(0, min_op);

}

return min_op == 0;

}

};

Java / DP / Bottom-up O(n^3)

class Solution {

public boolean checkValidString(String s) {

int l = s.length();

if (l == 0) return true;

boolean[][] dp = new boolean[l][l];

char[] ss = s.toCharArray();

for (int i = 0; i < l; ++i)

if (ss[i] == '*') dp[i][i] = true;

for (int len = 2; len <= l; ++len)

for (int i = 0; i + len <= l; ++i) {

int j = i + len - 1;

if ((ss[i] == '*' || ss[i] == '(')

&&(ss[j] == '*' || ss[j] == ')')) {

if (len == 2 || dp[i + 1][j - 1]) {

dp[i][j] = true;

continue;

}

for (int k = i; k < j; ++k)

if (dp[i][k] && dp[k + 1][j]) {

dp[i][j] = true;

break;

}

return dp[0][l - 1];

}

花花酱 LeetCode 127. Word Ladder

By zxi on September 25, 2017

https://leetcode.com/problems/word-ladder/description/

Problem:

Given two words (beginWord and endWord), and a dictionary’s word list, find the length of shortest transformation sequence from beginWord to endWord, such that:

Only one letter can be changed at a time.
Each transformed word must exist in the word list. Note that beginWord is not a transformed word.

For example,

Given:
beginWord = "hit"
endWord = "cog"
wordList = ["hot","dot","dog","lot","log","cog"]

As one shortest transformation is "hit" -> "hot" -> "dot" -> "dog" -> "cog",
return its length 5.

Note:

Return 0 if there is no such transformation sequence.
All words have the same length.
All words contain only lowercase alphabetic characters.
You may assume no duplicates in the word list.
You may assume beginWord and endWord are non-empty and are not the same.

Idea:

BFS

Time Complexity: O(n*26^l) -> O(n*26^l/2), l = len(word), n=|wordList|

Space Complexity: O(n)

Solution 1: BFS

C++

// Author: Huahua

// Running time: 93 ms

class Solution {

public:

int ladderLength(string beginWord, string endWord, vector<string>& wordList) {

unordered_set<string> dict(wordList.begin(), wordList.end());

if (!dict.count(endWord)) return 0;

queue<string> q;

q.push(beginWord);

int l = beginWord.length();

int step = 0;

while (!q.empty()) {

++step;

for (int size = q.size(); size > 0; size--) {

string w = q.front();

q.pop();

for (int i = 0; i < l; i++) {

char ch = w[i];

for (int j = 'a'; j <= 'z'; j++) {

w[i] = j;

// Found the solution

if (w == endWord) return step + 1;

// Not in dict, skip it

if (!dict.count(w)) continue;

// Remove new word from dict

dict.erase(w);

// Add new word into queue

q.push(w);

}

w[i] = ch;

}

return 0;

}

};

Java

// Author: Huahua

// Running time: 92 ms (<76.61%)

class Solution {

public int ladderLength(String beginWord, String endWord, List<String> wordList) {

Set<String> dict = new HashSet<>();

for (String word : wordList) dict.add(word);

if (!dict.contains(endWord)) return 0;

Queue<String> q = new ArrayDeque<>();

q.offer(beginWord);

int l = beginWord.length();

int steps = 0;

while (!q.isEmpty()) {

++steps;

for (int s = q.size(); s > 0; --s) {

String w = q.poll();

char[] chs = w.toCharArray();

for (int i = 0; i < l; ++i) {

char ch = chs[i];

for (char c = 'a'; c <= 'z'; ++c) {

if (c == ch) continue;

chs[i] = c;

String t = new String(chs);

if (t.equals(endWord)) return steps + 1;

if (!dict.contains(t)) continue;

dict.remove(t);

q.offer(t);

}

chs[i] = ch;

}

return 0;

}

Solution 2: Bidirectional BFS

C++

// Author: Huahua

// Running time: 32 ms (better than 96.6%)

class Solution {

public:

int ladderLength(string beginWord, string endWord, vector<string>& wordList) {

unordered_set<string> dict(wordList.begin(), wordList.end());

if (!dict.count(endWord)) return 0;

int l = beginWord.length();

unordered_set<string> q1{beginWord};

unordered_set<string> q2{endWord};

int step = 0;

while (!q1.empty() && !q2.empty()) {

++step;

// Always expend the smaller queue first

if (q1.size() > q2.size())

std::swap(q1, q2);

unordered_set<string> q;

for (string w : q1) {

for (int i = 0; i < l; i++) {

char ch = w[i];

for (int j = 'a'; j <= 'z'; j++) {

w[i] = j;

if (q2.count(w)) return step + 1;

if (!dict.count(w)) continue;

dict.erase(w);

q.insert(w);

}

w[i] = ch;

}

std::swap(q, q1);

}

return 0;

}

};

Java

// Author: Huahua

// Running time: 31 ms (<95.17%)

class Solution {

public int ladderLength(String beginWord, String endWord, List<String> wordList) {

Set<String> dict = new HashSet<>();

for (String word : wordList) dict.add(word);

if (!dict.contains(endWord)) return 0;

Set<String> q1 = new HashSet<>();

Set<String> q2 = new HashSet<>();

q1.add(beginWord);

q2.add(endWord);

int l = beginWord.length();

int steps = 0;

while (!q1.isEmpty() && !q2.isEmpty()) {

++steps;

if (q1.size() > q2.size()) {

Set<String> tmp = q1;

q1 = q2;

q2 = tmp;

}

Set<String> q = new HashSet<>();

for (String w : q1) {

char[] chs = w.toCharArray();

for (int i = 0; i < l; ++i) {

char ch = chs[i];

for (char c = 'a'; c <= 'z'; ++c) {

chs[i] = c;

String t = new String(chs);

if (q2.contains(t)) return steps + 1;

if (!dict.contains(t)) continue;

dict.remove(t);

q.add(t);

}

chs[i] = ch;

}

q1 = q;

}

return 0;

}

Python

"""

Author: Huahua

Running time: 115 ms (better than 96.84%)

"""

class Solution(object):

def ladderLength(self, beginWord, endWord, wordList):

wordDict = set(wordList)

if endWord not in wordDict: return 0

l = len(beginWord)

s1 = {beginWord}

s2 = {endWord}

wordDict.remove(endWord)

step = 0

while len(s1) > 0 and len(s2) > 0:

step += 1

if len(s1) > len(s2): s1, s2 = s2, s1

s = set()

for w in s1:

new_words = [

w[:i] + t + w[i+1:] for t in string.ascii_lowercase for i in xrange(l)]

for new_word in new_words:

if new_word in s2: return step + 1

if new_word not in wordDict: continue

wordDict.remove(new_word)

s.add(new_word)

s1 = s

return 0