billy_don
Senior Member
á à cắt ghép chuỗi dám dùng thẳng String![]()
@billy_don mang cẩu đầu trảm ra xử lý nào, quê mặt hội java quá![]()
á à cắt ghép chuỗi dám dùng thẳng String![]()
@billy_don mang cẩu đầu trảm ra xử lý nào, quê mặt hội java quá![]()
á à cắt ghép chuỗi dám dùng thẳng String![]()
@billy_don mang cẩu đầu trảm ra xử lý nào, quê mặt hội java quá![]()
huhu e biết lỗi r mà mấy a ơi
class Solution {
int index = -1;
public String reverseParentheses(String s) {
char[] arr = s.toCharArray();
return buildString(arr);
}
public String buildString(char[] arr){
index++;
StringBuilder sb = new StringBuilder();
while(index<arr.length) {
if(arr[index]=='(') {
String temp = buildString(arr);
sb.append(temp);
}
else if(arr[index]==')') {
sb = sb.reverse();
break;
}
else
sb.append(arr[index]);
index++;
}
return sb.toString();
}
}
impl Solution {
pub fn reverse_parentheses(s: String) -> String {
let s = s.as_bytes();
let goto = {
let mut goto = vec![0; s.len()];
let mut ops = Vec::new();
s.iter().enumerate().for_each(|(i, c)| {
match *c {
b'(' => ops.push(i),
b')' => {
let from = unsafe { ops.pop().unwrap_unchecked() };
goto[from] = i;
goto[i] = from
}
_ => {}
}
});
goto
};
let mut out = Vec::new();
let (mut direction, mut pos) = (1i32, 0i32);
while (pos as usize) < s.len() {
match s[pos as usize] {
b'(' | b')' => {
pos = goto[pos as usize] as i32;
direction = -direction;
}
_ => out.push(s[pos as usize]),
}
pos += direction;
}
unsafe { String::from_utf8_unchecked(out) }
}
}
Thông thường là nếu càng đưa nhiều ràng buộc thì compiler backend càng có nhiều cơ hội để thực hiện các phép tối ưu. Trong trường hợp bài này thì có ràng buộc 2 <= logs.length, và chỉ cần so sánh đúng chuỗi con chiều dài bằng 2 là đủ để tách các trường hợp.
Nếu không tận dụng điều kiện này, mà so sánh haistrtrực tiếp, thì compiler backend sẽ sinh mã cho phép kiểm tra nếu chiều dài của logs khác 2 (mặc dù trên thực tế nhánh khác 2 sẽ không bao giờ được chạy tới).
Phép so sánh cmp sẽ luôn được chạy mà luôn có kết quả bằng 2, do vậy block LBB0_13 sẽ không bao giờ chạy tới (nhưng compiler backend vẫn bắt buộc phải sinh ra).
2 <= logs[i].length <= 10, nên vẫn có trường hợp logs[i].length != 2 chứ nhỉ 
Còn bài của fen xì O mấy đâu sao k thấy, anh tự do nay cũng lủi đâu r chưa thấy làmnày sao O(n) được fency ơi![]()
Mình đang tính thế này:này sao O(n) được fency ơi![]()
tự do bảo chấp cả nhóm hết kì euro này mà. Trong thớt euro thấy trận nào cũng kêu bú đẫm, chắc khỏi cần làm thợ gõ nữa rồi.Còn bài của fen xì O mấy đâu sao k thấy, anh tự do nay cũng lủi đâu r chưa thấy làm Xem tệp đính kèm 2572378

tự do bảo chấp cả nhóm hết kì euro này mà. Trong thớt euro thấy trận nào cũng kêu bú đẫm, chắc khỏi cần làm thợ gõ nữa rồi.![]()
ko nhận card dưới 500k nha @freedom.9xét chuỗi có độ dài n có dạng ((...(abc...)...))Mình đang tính thế này:
Overall, sẽ là O(N) theo cách tính của mình.
- Khởi tạo list hết O(N)
- Mỗi lần call hàm Reverse sẽ tốn maximum là O(N), vì mình call theo từng cặp parentheses. (Index sẽ giảm dần). Cho nên cái này tính là O(N). Ví dụ, n = 10 , maximum là 5 cặp "()" thì số lần chạy sẽ là : 8 + 6 + 4 + 2.
- Loop cuối cùng để tạo result - O(N).
class Solution {
public:
string reverseParentheses(string str) {
stack<int> stk;
string result;
for (char ch : str) {
if (ch == '(') {
stk.push(result.size());
} else if (ch == ')') {
int start = stk.top();
stk.pop();
reverse(result.begin() + start, result.end());
} else {
result += ch;
}
}
return result;
}
};
tự do bảo chấp cả nhóm hết kì euro này mà. Trong thớt euro thấy trận nào cũng kêu bú đẫm, chắc khỏi cần làm thợ gõ nữa rồi.![]()
Mấy nay đủ combo nên ko luyện leetcode, euro, chuyển nhà, vợ mang bầuko nhận card dưới 500k nha @freedom.9

kiếm 10 năm subscription leetcode khó quá 
class Solution {
public:
string reverseParentheses(string s) {
stack<char> st;
queue<char> q;
for (int i = 0; i < s.size(); i++) {
if (s[i] != ')') {
st.push(s[i]);
} else {
char charTop = st.top();
while (charTop != '(') {
st.pop();
q.push(charTop);
charTop = st.top();
}
// remove '('
st.pop();
while (!q.empty()) {
char charFront = q.front();
q.pop();
st.push(charFront);
}
}
}
string result = "";
while (!st.empty()) {
char c = st.top();
st.pop();
result = c + result;
}
return result;
}
};

class Solution:
def reverseParentheses(self, s: str) -> str:
pos = [-1] * len(s)
stack = []
for i, c in enumerate(s):
if c == '(':
stack.append(i)
elif c == ')':
prev = stack.pop()
pos[prev] = i
pos[i] = prev
ans = []
def backward_traverse(l, r):
while r >= l:
if s[r] == ')':
forward_traverse(pos[r]+1, r-1)
r = pos[r]-1
else:
ans.append(s[r])
r -= 1
def forward_traverse(l, r):
while l <= r:
if s[l] == '(':
backward_traverse(l+1, pos[l]-1)
l = pos[l]+1
else:
ans.append(s[l])
l += 1
forward_traverse(0, len(s) - 1)
return ''.join(ans)
Vấn đề là n giảm dần, chứ n không cố định.xét chuỗi có độ dài n có dạng ((...(abc...)...))
gọi k là số cặp ngoặc '()', x là độ dài chuỗi 'abc...'
ta phải reverse k lần chuỗi x => time complex = k * x
dễ thấy 2k + x = n, k * x lớn nhất khi k = n / 4, x = n / 2 (AM-GM)
=> time complex = n^2 / 8 = O(n^ 2)
n của mình là độ dài của chuỗi input, không đổi.

N của mình là tính theo start index và end index của mỗi cặp parentheses. Ví dụ (abc(de)ghj). Lần 1 là n = 10 ( start index =1 , end index = 10 - abc(de)ghj), lần 2 thì là n = 2 - chuỗi cần reverse chỉ là de thôi, không phải reverse tất cả.n của mình là độ dài của chuỗi input, không đổi.
n của fence là gì á![]()
nếu vậy thì cần đánh giá dựa trên tổng tất các 'n'N của mình là tính theo start index và end index của mỗi cặp parentheses. Ví dụ (abc(de)ghj). Lần 1 là n = 10 ( start index =1 , end index = 10 - abc(de)ghj), lần 2 thì là n = 2 - chuỗi cần reverse chỉ là de thôi, không phải reverse tất cả.
via theNEXTvoz for iPhone
var maximumGain = function(s, x, y) {
const calculate = (pair, point) => {
const stack = [];
let total_points = 0;
for (const c of arr) {
if (c == pair[1] && stack.length > 0 && stack[stack.length - 1] == pair[0]) {
stack.pop();
total_points += point;
} else {
stack.push(c);
}
}
arr = stack;
return total_points;
}
let arr = s.split('');
let ans = 0;
let pairs = x > y ? ["ab", "ba"] : ["ba", "ab"];
let points = x > y ? [x, y] : [y, x];
ans += calculate(pairs[0], points[0]);
ans += calculate(pairs[1], points[1]);
return ans;
};
class Solution:
def maximumGain(self, s: str, x: int, y: int) -> int:
# Stack
def calculate(s, p1, s1,p2, s2 ):
stack = []
res = 0
for char in s:
if stack and stack[-1] + char == p1:
stack.pop()
res += s1
else:
stack.append(char)
rem = []
while stack:
c = stack.pop()
if rem and c + rem[-1] == p2:
res += s2
rem.pop()
else:
rem.append(c)
return res
if x > y:
return calculate(s, "ab",x, "ba", y)
else:
return calculate(s, "ba", y, "ab", x)
. Greedy mới chả stack 
function maximumGain(s: string, x: number, y: number): number {
let res = 0;
const remove = (str: string, type: string) => {
const stack: string[] = [];
for (let i = 0; i < str.length; i++) {
if (str[i] === type[1] && stack.length && stack[stack.length - 1] === type[0]) stack.pop()
else stack.push(str[i])
}
let ans = '';
while (stack.length) ans = stack.pop() + ans;
return ans
}
const str1 = remove(s, x > y ? 'ab' : 'ba');
let count = (s.length - str1.length) / 2;
res+= count * Math.max(x, y);
const str2 = remove(str1, x > y ? 'ba' : 'ab');
count = (str1.length - str2.length) / 2;
res+= count * Math.min(x, y);
return res;
};