#include <iostream>
#include <vector>
#include <algorithm>
#include <climits>
using namespace std;

int solve(int i, vector<int>& lst, int ad, const vector<int>& machineCount, const vector<int>& finalMachineCount, int shiftingCost) {
    int n = machineCount.size();
    if (i == n) {
        int res = ad;
        for (int k = 0; k < 3; ++k) {
            res += abs(lst[k] - finalMachineCount[k]);
        }
        return res;
    }
   
    int res = INT_MAX;
    res = min(res, solve(i + 1, lst, ad, machineCount, finalMachineCount, shiftingCost));
   
    for (int j = 0; j < 3; ++j) {
        lst[j] += machineCount[i];
        if (lst[j] - machineCount[i] != 0) {
            res = min(res, solve(i + 1, lst, ad + shiftingCost, machineCount, finalMachineCount, shiftingCost));
        } else {
            res = min(res, solve(i + 1, lst, ad, machineCount, finalMachineCount, shiftingCost));
        }
        lst[j] -= machineCount[i];
    }
   
    return res;
}

int getMinimumCost(const vector<int>& machineCount, const vector<int>& finalMachineCount, int shiftingCost) {
    vector<int> lst(3, 0);
    return solve(0, lst, 0, machineCount, finalMachineCount, shiftingCost);
}

int main() {
    vector<int> machineCount = { /* your values here */ };
    vector<int> finalMachineCount = { /* your values here */ };
    int shiftingCost = /* your value here */;
   
    cout << getMinimumCost(machineCount, finalMachineCount, shiftingCost) << endl;
    return 0;
}

GetminimumCost ✅

Snake water ✅

Bounty - Amazon Ml ✅

Accenture - Symmetrical number ✅

Accenture - Cup cakes ✅

Accenture - Subarray sum triplets ✅

Accenture - Printing Lab ✅

Accenture - Three Rats ✅

Accenture - Tall plants ✅

Accenture - operational substring ✅

int par[100005];
int find_par(int u) {
if(par[u] < 0) return u;
par[u] = find_par(par[u]);
return par[u];
}
bool merge(int u, int v) {
u = find_par(u), v = find_par(v);
if(u == v) return false;
if(par[u] > par[v]) swap(u, v);
par[u] += par[v];
par[v] = u;
return true;
}
set<int> g[100005];
vector<int> recoverDeadPods(int n, vector<vector<int>> connections, vector<vector<int>> queries) {
int p = 0;
for(auto x : connections) {
  p = max(p, x[0]);
  p = max(p, x[1]);
}
for(auto x : queries) {
  p = max(p, x[0]);
  p = max(p, x[1]);
}

for(int i = 1; i <= p; i++) par[i] = -1;
for(auto x : connections) {
  merge(x[0], x[1]);
}

for(int i = 1; i <= p; i++) {
  int u = find_par(i);
  g[u].insert(i);
}

vector<int> ans;
for(auto x : queries) {
  if(x[0] == 1) {
   int u = find_par(x[1]);

   if(g[u].empty()) ans.push_back(-1);
   else {
    auto iter = g[u].find(x[1]);
    if(iter != g[u].end()) ans.push_back(x[1]);
    else ans.push_back(*g[u].begin());
   }
  } else {
   int u = find_par(x[1]);
   auto iter = g[u].find(x[1]);
   if(iter != g[u].end()) g[u].erase(iter);
  }
}
return ans;
}

Pods Cisco ✅

def getMinTime(n, cache):
    # Write your code here
    def solve(mid):
        h = {}
        for i in cache:
            h[i] = 1+h.get(i,0)
        extrawork = 0
        cnt = 0
        for i in range(1,n+1):
            if h.get(i,0) > mid:
                extrawork += h[i]-mid
            else:
                cnt += (mid-h.get(i,0))//2
        return cnt>=extrawork
    l,r = 1, 2*len(cache)
    while l<=r:
        mid = (l+r)//2
        if solve(mid):
            ans = mid
            r = mid-1
        else:
            l = mid+1
    return ans

           
    l,r = 1, len(cache)
    while l<=r:
        mid = (l+r)//2
        if solve(mid):
            ans = mid
            r = mid-1
        else:
            l = mid+1
    return ans

Min time
Cisco ✅