#include <iostream>
#include <vector>

const int MOD = 1000000007;

using namespace std;

int countBeautifulSequences(int n) {
    if (n == 1) {
        return 1;
    }

    vector<int> dp(n + 1, 0);
    dp[1] = 1;

    for (int i = 1; i <= n; ++i) {
        for (int j = i; j <= n; ++j) {
            dp[j] = (dp[j] + dp[j - i]) % MOD;
        }
    }

    return (dp[n] - 1 + MOD) % MOD;
}

int main() {
    int n;
    cin >> n;

    int result = countBeautifulSequences(n);
    cout << result << endl;

    return 0;
}

Count Beautiful sequence✅
Share @coding_000❤️

Share our channel screenshot in large groups ✅✅✅✅✅

For remaining coding answers 🏃🏃🏃🏃

Share Fast make 4.6k🎯🎯

#include <bits/stdc++.h>
using namespace std;
#define ll long long
ll dp[10005][2];
const int mod = (1e9 + 7);

ll solve(ll i, ll o, ll n, ll k, vector<ll> &v) {
    if (i > n) {
        return 0;
    }
    if (dp[i][o] != -1)
        return dp[i][o];
    ll ans = 0;
    if (o == 0) {
        for (int j = i; j < min(n + 1, i + k); j++) {
            ans = max(ans, solve(j + 1, 1 - o, n, k, v)) % mod;
        }
    } else {
        ll ta = 0;
        ll mx = 0;
        for (int j = i; j < min(n + 1, i + k); j++) {
            if (ta + v[j] >= 0) {
                ta += v[j];
                mx = max(mx, ta);
            } else {
                ta = 0;
            }
            ll c = solve(j + 1, 1 - o, n, k, v) % mod;
            ans = max(ans, ((j - i + 1) * mx) % mod + c % mod);
        }
    }
    return dp[i][o] = ans;
}

int main() {
    ll n, k;
    cin >> n >> k;
    vector<ll> v;
    ll neg = 0;
    for (int i = 0; i < n; i++) {
        ll x;
        cin >> x;
        v.push_back(x);
        if (x <= 0)
            neg++;
    }

    if (neg == v.size()) {
        cout << 0 << endl;
        return 1;
    }
    memset(dp, -1, sizeof(dp));
 
    cout << max(solve(0, 0, v.size() - 1, k, v), solve(0, 1, v.size() - 1, k, v)) << endl;
}
// Array Segments✅✅

Share @coding_000

int min_operations(string s) {
    int n = s.length();
    vector<vector<int>> dp(n, vector<int>(n, INT_MAX));
    for (int i = 0; i < n; i++) {
        dp[i][i] = 0;
    }
    for (int len = 2; len <= n; len++) {
        for (int i = 0; i <= n - len; i++) {
            int j = i + len - 1;
            if (s[i] == s[j]) {
                dp[i][j] = min(dp[i][j], dp[i + 1][j - 1]);
            } else {
                for (int k = i; k < j; k++) {
                    dp[i][j] = min(dp[i][j], dp[i][k] + dp[k + 1][j] + 1);
                }
            }
        }
    }

    return dp[0][n - 1];
}
// String dot✅

Share @coding_000❤️

#include <iostream>
#include <vector>
#include <queue>
#include <algorithm>

using namespace std;

const int INF = 1e9;

struct Node {
    int value, dist;
    Node(int v, int d) : value(v), dist(d) {}
};

int main() {
    int n, m;
    cin >> n >> m;

    vector<int> A(n);
    vector<vector<int>> graph(n, vector<int>());
    vector<vector<int>> dist(n, vector<int>(n, INF));

    for (int i = 0; i < n; ++i) {
        cin >> A[i];
    }

    for (int i = 0; i < m; ++i) {
        int x, y;
        cin >> x >> y;
        --x; --y; // Convert to 0-based indexing
        graph[x].push_back(y);
        graph[y].push_back(x);
        dist[x][y] = dist[y][x] = 1;
    }

    // Floyd-Warshall algorithm to calculate shortest distances
    for (int k = 0; k < n; ++k) {
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < n; ++j) {
                dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
            }
        }
    }

    priority_queue<Node, vector<Node>, greater<Node>> pq;

    for (int i = 0; i < n; ++i) {
        if (A[i] > 0) {
            pq.push(Node(i, 0));
        }
    }

    long long cost = 0;

    while (!pq.empty()) {
        Node node = pq.top();
        pq.pop();

        int u = node.value;
        int d = node.dist;

        if (A[u] > 0) {
            cost += d * A[u];
            A[u] = 0;

            for (int v : graph[u]) {
                if (A[v] > 0) {
                    pq.push(Node(v, d + 1));
                }
            }
        }
    }

    for (int i = 0; i < n; ++i) {
        if (A[i] > 0) {
            cout << -n << endl;
            return 0;
        }
    }

    cout << cost << endl;

    return 0;
}

Tree=0✅

All pass✅ Share @coding_000❤️

More Share More Solutions❤️👨‍💻

NoBody sharing 😢😕
Our channel @Coding_000❤️

int solve(vector<int>& arr)
{  
    if(arr.size()==1)
    {
        if(arr[0]==0) return 0;
        else return 1;
    } coding_000
    int used = 0;
    int start = 0;
    int n = arr.size();
    int result = 0;
    for (int i = 0; i < n; i++)
    {
        while ((used&arr[i])!=0)
        {
            used ^= arr[start];
            start++;
        }
        used |= arr[i];
        if (start < i)
            result+=i - start + 1;
    }

    return 2*result;
}
// Count subsets✅

Share @coding_000❤️

int dp[603];
int mex(vector<int>&v, int i, int j){
     set<int>st;
     for(int ind = i;ind <= j;ind++) st.insert(v[ind]);
     int ans = 1;
     for(auto pr : st){
          if(pr == ans) ans++;
     }
     return ans;
}

int love(vector<int>& arr, int ind, int k){
    
    int n = arr.size();
    if(k == 1) return mex(arr, ind, n - 1);
                                           
    if(dp[ind] != -1)  return dp[ind];

    int maxi = INT_MIN;

    for(int i = ind;i <= (n - k);i++){
       int ans = mex(arr, ind, i) + helper(arr, i + 1, k - 1);
       maxi = max(maxi, ans);
    }

    return dp[ind] = maxi;
}


int solve(int N, int K, vector<int>A){

     memset(dp, -1, sizeof(dp));
    return love(A, 0 , K);

}
// Max Strikes again✅

https://t.me/coding_000 ❤️

Guys share the screenshot in large groups and Share with your friends ✅🔥 @Coding_000 ❤️

I don't see anyone sharing 🥲

#include<bits/stdc++.h>
using namespace std;
const int N=500005;
typedef long long ll;
int T,n,k,t,h[N];
ll dp[N][2];
struct edge{
  int ver,net;
  ll val;
}f[N*2];
void add(int x,int y,int z){
  f[++t].net=h[x];
  h[x]=t,f[t].ver=y;
  f[t].val=z;
}
void dfs(int x,int fa){
  dp[x][0]=dp[x][1]=0;
  priority_queue<ll> q;
  for(int i=h[x];i;i=f[i].net){
    int y=f[i].ver;
    if(y==fa) continue;
    dfs(y,x);
    dp[x][0]+=dp[y][0];
    q.push(dp[y][1]+f[i].val-dp[y][0]);
  }
  dp[x][1]=dp[x][0];
  int p=k;
  while(p--&&q.size()&&q.top()>0){
    if(p) dp[x][1]+=q.top();
    dp[x][0]+=q.top();
    q.pop();
  }
 
}
int main(){
  scanf("%d",&T);
  while(T--){
    int x,y,z;t=0;
    scanf("%d%d",&n,&k);
    for(int i=1;i<n;++i){
      scanf("%d%d%d",&x,&y,&z);
      add(x,y,z),add(y,x,z);
    }
    dfs(1,0);
    printf("%lld\n",dp[1][0]);
    for(int i=1;i<=n;++i) h[i]=0,dp[i][0]=dp[i][1]=0;
  }
  return 0;
}
// Good edges✅

Share @coding_000❤️

This code anyone want..?

DM @ILOVEU_143 ❤️✅

Send me our channel screenshot

Send ur questions i will send solutions

Dm Me Fast @ILOVEU_143❤️✅

Share @Coding_000❤️👨‍💻