1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

class Solution {
public:
    long long maxScore(vector<int>& a, vector<int>& b) {
        int n=b.size();
        vector<array<long long,4>>memo(n);
        for(auto&row:memo){
            ranges::fill(row,LLONG_MIN);
        }
        auto dfs=[&](auto&&dfs,int i,int j)->long long{
            if(j<0)return 0;
            if(i<0){
                return LLONG_MIN/2;

            }
            auto &res=memo[i][j];
            if(res==LLONG_MIN){
                res=max(dfs(dfs,i-1,j),dfs(dfs,i-1,j-1)+(long long)a[j]*b[i]);
            }
            return res;
        };
        return dfs(dfs,n-1,3);
    }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

class Solution {
public:
    int findMaxForm(vector<string>& strs, int m, int n) {
        int len = strs.size();
         vector<vector<vector<int>>> dp(len + 1, vector<vector<int>>(m + 1, vector<int>(n + 1, 0)));
        for (int i = 1; i <= len; i++) {
            int x1 = cnum(strs[i - 1]);
            int x0 = strs[i - 1].size() - x1;
            for (int j = 0; j <= m; j++) {
                for (int k = 0; k <= n; k++) {
                    dp[i][j][k] = dp[i - 1][j][k];
                    if (j >= x0 && k >= x1) {
                        dp[i][j][k] =
                            max(dp[i - 1][j][k], dp[i - 1][j - x0][k - x1] + 1);
                    }
                }
            }
        }
        return dp[len][m][n];
    }
    int cnum(string s) {
        int cnt = 0;
        for (auto c : s) {
            if (c == '1')
                cnt++;
        }
        return cnt;
    }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

class Solution {
public:
    string getHappyString(int n, int k) {
        
        int total = 3 * (1 << (n - 1)); 
        if (k > total) return "";
        
        string result;
        char prev = '\0';
        
        for (int i = 0; i < n; ++i) {
      
            int count_per_choice = 1 << (n - i - 1); // 2^(n-i-1)
            
            for (char c = 'a'; c <= 'c'; ++c) {
                if (c == prev) continue; 
                
                if (k <= count_per_choice) {
                    result += c;
                    prev = c;
                    break;
                }
                k -= count_per_choice;
            }
        }
        
        return result;
    }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

class Solution {
public:
    int f[205][205][2] = {0};
    int numberOfStableArrays(int z, int o, int limit) {
        const int mod = 1e9 + 7;
        for (int i = 0; i <= z; i++) {
            f[i][0][0] = (i <= limit), f[i][0][1] = 0;
        }
        for (int i = 0; i <= o; i++) {
            f[0][i][0] = 0, f[0][i][1] = (i <= limit);
        }
        int sum1[o + 1];
        for (int j = 0; j <= o; j++) {
            sum1[j] = f[0][j][1];
        }
        for (int i = 1; i <= z; i++) {
            for (int j = 1, sum0 = f[i][0][0]; j <= o; j++) {
                f[i][j][0] = sum1[j];
                f[i][j][1] = sum0;

                sum0 = (sum0 + f[i][j][0]) % mod;
                if (j >= limit) {
                    sum0 = (sum0 + mod - f[i][j - limit][0]) % mod;
                }
                sum1[j] = (sum1[j] + f[i][j][1]) % mod;
                if (i >= limit) {
                    sum1[j] = (sum1[j] + mod - f[i - limit][j][1]) % mod;
                }
            }
        }
        return (f[z][o][0] + f[z][o][1]) % mod;
    }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

class Solution {
public:
    int maxProductPath(vector<vector<int>>& grid) {
        const int MOD = 1e9 + 7;
        int m = grid.size(), n = grid[0].size();
        
        vector<vector<long long>> big(m, vector<long long>(n));
        vector<vector<long long>> sml(m, vector<long long>(n));
        
        big[0][0] = grid[0][0];
        sml[0][0] = grid[0][0];
        
        for (int i = 1; i < m; ++i) {
            big[i][0] = sml[i][0] = (long long)big[i-1][0] * grid[i][0];
        }
        
        for (int j = 1; j < n; ++j) {
            big[0][j] = sml[0][j] = (long long)big[0][j-1] * grid[0][j];
        }
        
        for (int i = 1; i < m; ++i) {
            for (int j = 1; j < n; ++j) {
                vector<long long> candidates = {
                    (long long)big[i-1][j] * grid[i][j],
                    (long long)sml[i-1][j] * grid[i][j],
                    (long long)big[i][j-1] * grid[i][j],
                    (long long)sml[i][j-1] * grid[i][j]
                };
                big[i][j] = *max_element(candidates.begin(), candidates.end());
                sml[i][j] = *min_element(candidates.begin(), candidates.end());
            }
        }
        
        return big[m-1][n-1] >= 0 ? (big[m-1][n-1] % MOD) : -1;
    }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

class Solution {
public:
    int minFlips(string s) {
        int n = s.size();
        string tar = "01";
        int cnt = 0;
        for (int i = 0; i < n; i++) {
            cnt += (s[i] != tar[i % 2]);
        }
        int ans = min({cnt, n - cnt});
        for (int i = 0; i < n; i++) {
            cnt -= (s[i] != tar[i % 2]);
            cnt += (s[i] != tar[(i + n) % 2]);
            ans = min({ans, cnt, n - cnt});
        }
        return ans;
    }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

class Solution {
public:
    int mod = 1e9 + 7;
    vector<long long> v3, v4;
    int f3(int a) {
        if (v3[a] == 0) {
            for (int i = 4; i <= a; i++) {
                if (v3[i] != 0)
                    continue;
                v3[i] = (v3[i - 1] + v3[i - 2] + v3[i - 3]) % mod;
            }
        }
        return v3[a];
    }
    int f4(int a) {
        if (v4[a] == 0) {
            for (int i = 5; i <= a; i++) {
                if (v4[i] != 0)
                    continue;
                v4[i] = (v4[i - 1] + v4[i - 2] + v4[i - 3] + v4[i - 4]) % mod;
            }
        }
        return v4[a];
    }
    int countTexts(string pressedKeys) {
        int k[10] = {0, 0, 3, 3, 3, 3, 3, 4, 3, 4};
        long long ans = 1;
        int n = pressedKeys.size();
        int si = max(n + 1, 10);
        v3.resize(si, 0), v4.resize(si, 0);
        v3[0] = 1, v3[1] = 1, v3[2] = 2, v3[3] = 4, v4[0] = 1, v4[1] = 1,
        v4[2] = 2, v4[3] = 4, v4[4] = 8;
        for (int i = 0; i < n; i++) {
            char c = pressedKeys[i];
            int j = i;
            while (j < n && pressedKeys[j] == c) {
                j++;
            }

            int cnt = j - i, kv = c - '0';
            if (k[kv] == 3) {
                ans = ans * (f3(cnt)) % mod;
            } else {
                ans = ans * (f4(cnt)) % mod;
            }
            i = j - 1;
        }
        return ans;
    }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

class Solution {
public:
    long long maxSumTrionic(vector<int>& nums) {
        int n = nums.size();
        
        vector<long long > pre(n,LLONG_MIN),suf(n,LLONG_MIN);

        for(int i=1;i<n;i++){
            if(nums[i]>nums[i-1])
            {
            long long bs=(i>1&&pre[i-1]!=LLONG_MIN)?pre[i-1]:nums[i-1];
            pre[i]=max((long long)nums[i]+nums[i-1],bs+nums[i]);
            }
        }
        for(int i=n-2;i>=0;--i){
            if(nums[i+1]>nums[i])
            {
            long long bs=(i+2<n&&suf[i+1]!=LLONG_MIN)?suf[i+1]:nums[i+1];
            suf[i]=max((long long)nums[i+1]+nums[i],bs+nums[i]);
            }
        }
        long long ans=LLONG_MIN;
        for(int i=0;i<n-1;i++){
            if(nums[i]>nums[i+1]){
                int p=i;

                long long t=nums[i];

                while(i<n-1&&nums[i]>nums[i+1]){
                    ++i;
                    t+=nums[i];
                    if(pre[p]!=LLONG_MIN&&suf[i]!=LLONG_MIN){

                        ans=max(ans,t+pre[p]+suf[i]-nums[i]-nums[p]);
                    }
                }
                i--;


            }
        }
        return ans;
    }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

class Solution {
public:
    vector<int> minimumFlips(int n, vector<vector<int>>& edges, string start, string target) {
        vector<vector<pair<int,int>>> g(n);
        for(int i=0;i<n-1;i++){
            int x=edges[i][0],y=edges[i][1];
            g[x].emplace_back(y,i);
            g[y].emplace_back(x,i);
        }
        vector<int> ans;
       std:: function <bool(int,int)> dfs=[&](int x,int fa)->bool{
            bool rev=start[x]!=target[x];
            for(auto& [y,i]:g[x]){
                if(y!=fa&&dfs(y,x)){
                    ans.push_back(i);
                    rev=!rev;
                }
            }
            return rev;
        };
        if(dfs(0,-1)){
            return {-1};
        }
        sort(ans.begin(),ans.end());
        return ans;
    }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

class Solution {
public:
    vector<int> minimumFlips(int n, vector<vector<int>>& edges, string start, string target) {
        vector<vector<pair<int,int>>> g(n);
        for(int i=0;i<n-1;i++){
            int u = edges[i][0], v = edges[i][1];
            g[u].push_back({v,i});
            g[v].push_back({u,i});
        }

        vector<int> need(n);
        for(int i=0;i<n;i++){
            need[i] = (start[i] != target[i]);
        }

        vector<int> ans;

        auto dfs = [&](this auto&& dfs, int x, int fa)->void {
            for(auto& [y, id] : g[x]){
                if(y == fa) continue;
                dfs(y, x);
                if(need[y]){
                    ans.push_back(id);
                    need[y] = 0;
                    need[x] ^= 1;
                }
            }
        };

        dfs(0, -1);
        if(need[0]) return {-1};

        sort(ans.begin(), ans.end());
        return ans;
    }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

class Solution
{
    int  mod = 1e9 + 7, t[2];
    vector<vector<long long>> memo;
    long long dfs(int i, int state, vector<int> &nums)
    {
        if (i == nums.size())
        {
            return 0;
        }
        if (memo[i][state] != -1)
        {
            return memo[i][state];
        }
        long long res = 0;
        int cur = 0;
        for (int j = i; j < nums.size(); j++)
        {
            cur ^= nums[j];
            if (cur == t[state])
            {
                if (j == nums.size() - 1)
                {
                    res = (res + 1) % mod;
                }
                else
                {
                    res = (res + dfs(j + 1, state ^ 1, nums)) % mod;
                }
            }
        }
        return memo[i][state]=res;
    }

public:
    int alternatingXOR(vector<int> &nums, int target1, int target2)
    {
        int n = nums.size();
        t[0] = target1;
        t[1] = target2;
        memo.resize(n, vector<long long>(2, -1));
        return dfs(0, 0, nums);
    }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

class Solution
{
public:
    int alternatingXOR(vector<int> &nums, int target1, int target2)
    {
        int mod = 1e9 + 7;
        unordered_map<int, int> f1;
        unordered_map<int, int> f2 = { {0, 1} };
        int pre = 0;
        for (int i = 0;; i++)
        {
            pre ^= nums[i];
            int l1 = f2[target1 ^ pre];
            int l2 = f1[target2 ^ pre];
            if (i == nums.size() - 1)
            {
                return (l1 + l2) % mod;
            }
            f1[pre] = (l1 + f1[pre]) % mod;
            f2[pre] = (l2 + f2[pre]) % mod;
        }
    }
};