thảo luận Leetcode mỗi ngày

class Solution:
    def minimumSteps(self, s: str) -> int:
        k, ans = 0, 0
        for i, ch in enumerate(s):
            if ch == '0':
                ans += i - k
                k += 1

        return ans

class Solution {
    public long minimumSteps(String s) {
        long res=0;
        int n = s.length();
        int l =0;
        int r = n-1;
        while(l<r){
            while(l<r && s.charAt(l)=='0') l++;
            while(r>l && s.charAt(r)=='1') r--;
            res+=r-l;
            l++;r--;
        }
        return res;
    }
}

class Solution {
    public long minimumSteps(String s) {
        long res=0;
        int n = s.length();
        int b =0;
        for(char c: s.toCharArray()){
            if(c=='1') b++;
        }
        b=n-b;

        for(int i =0 ;i < n;i++){
            if(s.charAt(i)=='1'){
                if(i<b){
                    res+=b-i;
                    b++;
                }
                else break;
            }
         
        }
        return res;
    }
}

class Solution {
    public long minimumSteps(String s) {
        int n = s.length();
        long swap = 0, group = 0;
        char[] arr = s.toCharArray();
        for (int i = 0; i < n; i++) {
            if (arr[i] == '1') group++;
            if (arr[i] == '0') swap += group;
        }
        return swap;
    }
}

func minimumSteps(s string) int64 {
    rs, countOne := 0, 0
    for _, ch := range s {
        if ch == '1' {
            countOne++
        } else {
            rs += countOne
        }
    }
    return int64(rs)
}

  [SPOILER="DD/MM Go"][CODE=CLike]
  [\/CODE][\/SPOILER]

class Solution {
    public long minimumSteps(String s) {
        int last0 = 0;
        long sum = 0;

        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) == '0') {
                sum += i - last0;
                last0++;
            }
        }
        return sum;
    }
}

class Solution {
    public long minimumSteps(String s) {
        int n = s.length();
        int right = 0;
        long ans = 0;
        for(int i = n - 1; i > 0; i--) {
            if(s.charAt(i) == '0') {
                right = i;
                break;
            }
        }
        int left = right - 1;
        while(left >= 0) {
            if(s.charAt(left) == '1') {
                ans += (right-left);
                right--;
            }
            left--;
        }
        return ans;
    }
}

class Solution {
    boolean[][] rows = new boolean[9][9];
    boolean[][] cols = new boolean[9][9];
    boolean[][] squares = new boolean[9][9];
 
    public void solveSudoku(char[][] board) {
        for(int i =0 ; i<9;i++){
            for(int j = 0 ; j<9;j++){
                if(board[i][j]=='.') continue;
                int num = board[i][j]-'1';
                rows[i][num]=true;
                cols[j][num]=true;
                squares[(i/3)*3+j/3][num]=true;
            }
        }
        backtrack(board,0);
    }
    public boolean backtrack(char[][] board, int index){
        if(index ==81 ) return true;
        int i=  index/9;
        int j = index%9;
        if(board[i][j]!='.') return backtrack(board, index+1);
        for(char charNum = '1'; charNum<='9';charNum++){
            int num = charNum -'1';
            if(isValid(i,j, num)){
                rows[i][num]=true;
                cols[j][num]=true;
                squares[(i/3)*3+j/3][num]=true;
                board[i][j] = charNum;
                if(backtrack(board,index+1)) return true;
                rows[i][num]=false;
                cols[j][num]=false;
                squares[(i/3)*3+j/3][num]=false;
                board[i][j]='.';
            }
        }
        return false;
    }
    public boolean isValid(int i, int j, int num) {
        if(rows[i][num]==true ||
            cols[j][num]==true ||
            squares[(i/3)*3+j/3][num]==true) return false;
        return true;
    }
}

class Solution {
    public long minimumSteps(String s) {
        int n = s.length();
        long res = 0;
        int whitePosition = 0;
        for(int i = 0;i<n;i++)
            if(s.charAt(i)=='0'){
                res+=i-whitePosition;
                whitePosition++;
            }
                
        return res;
    }
}

class Solution {
    public long minimumSteps(String s) {
        long res = 0l;
        int gap = 0;

        for (char ch : s.toCharArray()) {
            if (ch == '0') {
                res += gap;
            } else {
                gap++;
            }
        }

        return res;
    }
}

class Solution:
    def longestDiverseString(self, a: int, b: int, c: int) -> str:
        heap = []
        if a != 0:
            heapq.heappush(heap, (-a, 'a'))
        
        if b != 0:
            heapq.heappush(heap, (-b, 'b'))
        if c != 0:
            heapq.heappush(heap, (-c, 'c'))
        ans = []
        while heap:
            holder, charHolder = None, None
            if len(ans) > 1 and heap[0][1] == ans[-1] == ans[-2]:
                holder, charHolder = heapq.heappop(heap)
            if not heap:
                break
            
            freq, char = heapq.heappop(heap)
            ans.append(char)
            freq += 1
            if freq < 0:
                heapq.heappush(heap, (freq, char))
            if holder != None:
                heapq.heappush(heap, (holder, charHolder))
        return ''.join(ans)

class Solution {
public:
    string longestDiverseString(int a, int b, int c) {
        priority_queue<pair<int, char>> pq;
        pq.push(make_pair(a, 'a'));
        pq.push(make_pair(b, 'b'));
        pq.push(make_pair(c, 'c'));
        stack<pair<int, char>> bk;

        string res = "";

        for (;!pq.empty();){
            auto top = pq.top();
            pq.pop();
            if (top.first == 0) continue;
            int r_size = res.size();
            if (r_size >= 2 && (res[r_size-1] == top.second && res[r_size-2] == top.second)) {
                bk.push(top);
                continue;
            }

            res = res + top.second;
            top.first--;
            pq.push(top);
            for (;!bk.empty();) {
                auto tmp = bk.top();
                pq.push(tmp);
                bk.pop();
            }
        }
        return res;
    }
};