VI dijkstra(VVI& graph, int v) { std::set<int> visited; VI rho(graph.size()); VI pred(graph.size()); pred[v] = nil; for (VI::iterator itr = rho.begin(); itr != rho.end(); ++itr) { *itr = inf; } rho[v] = 0; int current_min_rho; while (visited.size() != graph.size()) { // travers current_min_rho = inf; for (int i = 0; i < graph.size(); ++i) { if (visited.find(i) == visited.end() && current_min_rho > rho[i]) current_min_rho = i; } visited.insert(current_min_rho); // mark for (int i = 0; i < graph.size(); ++i) { if (graph[current_min_rho][i] && visited.find(i) == visited.end()) { if (rho[i] > rho[current_min_rho] + graph[current_min_rho][i]) { rho[i] = rho[current_min_rho] + graph[current_min_rho][i]; pred[i] = current_min_rho; } } } } return rho; }
bool multi(VVI & x, VVI & y, VVI & z) { int mx = x.size(); int my = y.size(); if (mx == 0 || my == 0) return false; int nx = x[0].size(); int ny = y[0].size(); if (nx == 0 || ny == 0) return false; //cout << "mx: " << mx << endl; //cout << "my: " << my << endl; //cout << "nx: " << nx << endl; //cout << "ny: " << ny << endl; if (nx != my) return false; z.clear(); for (int i = 0; i < mx; i++) { z.push_back(VI(ny, 0)); for (int j = 0; j < ny; j++) { double sum = 0; for (int k = 0; k < my; k++) { sum += (double)x[i][k] * (double)y[k][j]; } if (sum > INT_MAX || sum < INT_MIN) return false; z[i][j] = (int)sum; } } return true; }
void CalcOmegaMatrix(const VVI & RM, const VVI & DM, VVI & OmegaM) { if (RM.size() == 0 || DM.size() == 0) { cerr << "Size of relation matrix and decison matrix is 0 !" << endl; exit(-1); } //OmegaM: n * d OmegaM.clear(); VI viTmp(DM[0].size(), 0); OmegaM.insert(OmegaM.begin(), RM.size(), viTmp); // cout << OmegaM.size() << "\t" << OmegaM[0].size() <<endl; unsigned int i, j, k; STR2VI_MAP::iterator it; int sum = 0; for (i = 0; i < RM.size(); ++i) { for (j = 0; j < DM[0].size(); ++j) { sum = 0; for (k = 0; k < DM.size(); ++k) { sum += RM[i][k] * DM[k][j]; } OmegaM[i][j] = sum; } } }
void CalcH(const VVI OmegaM, const VI LM, VVD & H) { if (OmegaM.size() == 0 || LM.size() == 0) { cerr << "Size of Omega matrix or Lambda matrix is 0 !" << endl; exit(-1); } H.clear(); VD vdTmp(OmegaM[0].size(), 0); H.insert(H.begin(), OmegaM.size(), vdTmp); unsigned int i, j; for (i = 0; i < H.size(); ++i) for (j = 0; j < H[0].size(); ++j) { H[i][j] = 1.0 * OmegaM[i][j] / LM[i]; } /* for(it=DMap.begin(), i=0; it!= DMap.end(); ++it, ++i) { for(j=0;j<RM.size();++j) { sum = 0; for(k=0;k<(*it).second.size();++k) { sum += RM[j][(*it).second[k]]; } H[i][j] = 1.0 * sum / LM [j]; } }*/ }
string moreClasses(string a, vector <string> b) { int i, j, k, x, y, z, n; string ret = ""; VVI m; for( i = 0; i < b.size(); i++ ) { n = atoi(b[i].c_str()); for( j = 0; j < n; j++ ) { m.push_back(VI()); for( k = 0; k < b[i].size(); k++ ) if( !isdigit(b[i][k]) ) m.back().push_back(b[i][k]); } } if( m.size() > 128 ) return "0"; for( i = 0; i < a.size(); i++ ) taken[a[i]] = 1; n = m.size()-bipartitematch(m); x = 33; while( n ) { if( x >= 128 ) return "0"; if( taken[x] ) {x++; continue;} taken[x] = 1; if (x >= 67) cout<<x; z = m.size()-bipartitematch(m); if( z == n ) taken[x] = 0; else ret += x; n = z; x++; } return ret; }
int BipartiteMatching(const VVI & w, VI & mr, VI & mc) { mr = VI(w.size(), -1); mc = VI(w[0].size(), -1); int ct = 0; for (int i = 0; i < w.size(); i++) { VI seen(w[0].size()); if (FindMatch(i, w, mr, mc, seen)) ct++; } return ct; }
latin_square(const VVI& mat, const VI& rp, const VI& cp) : r(mat.size(), 0), c(mat.size(), 0), m(mat.size(), VI(mat.size())) { int n = mat.size(); for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { r[i] <<= 3; r[i] += mat[rp[i]][cp[j]]; c[i] <<= 3; c[i] += mat[rp[j]][cp[i]]; m[i][j] = mat[rp[i]][cp[j]]; } } }
VVI mul(VVI a, VVI b) { int m = a.size(); int n = a[0].size(); int p = b.size(); VVI c(m, VI(p, 0)); for (int i = 0; i < m; i++) { for (int j = 0; j < p; j++) { for (int k = 0; k < n; k++) { c[i][j] += a[i][k] * b[k][j]; } if (c[i][j] > 0) c[i][j] = 1; } } return c; }
void display(VVI v){ for(int i=0;i<v.size();i++){ for(int j=0;j<v[i].size();j++) printf("%d ", v[i][j]); printf("\n"); } }
void initDfs(int u,int level = 0) { LVL[u] = level; SZ[u] = 1; for(int i = 0; i < adj[u].size(); ++i) { int v = adj[u][i]; if(SZ[v])continue; P[v] = u; initDfs(v,level + 1); SZ[u] += SZ[v]; } for(int i = 0; i < adj[u].size(); ++i) { int v = adj[u][i]; if(v == P[u])continue; if(2*SZ[v] > SZ[u]-1){ PC[u] = v; } else { groups.push_back(VI()); for(int j = v; j != -1; j = PC[j]) groups.back().push_back(j) , groupId[j] = groups.size() - 1 , groupPos[j] = groups.back().size()-1; } } }
void d1s1(VVI &inp){ int vald1s1 = 0; int vald1s2 = 0; int vald2s1 = 0; int vald2s2 = 0; int n=inp.size(); int n1 = n-1; int ij ; STACK stid1s1,stjd1s1; STACK stid1s2,stjd1s2; STACK stid2s1,stjd2s1; STACK stid2s2,stjd2s2; for(int i=0;i<n;i++){ for(int j=0;j<=i;j++){ ij = i-j; update(inp,stid1s1,stjd1s1,ij,j,vald1s1); if(i<(n1)){ update(inp,stid1s2,stjd1s2,n1-j,n1-ij,vald1s2); } update(inp,stid2s1,stjd2s1,j,n1-ij,vald2s1); if(i<(n1)){ update(inp,stid2s2,stjd2s2,n1-ij,j,vald2s2); } } emptyStacks(inp,stid1s1,stjd1s1,vald1s1); emptyStacks(inp,stid1s2,stjd1s2,vald1s2); emptyStacks(inp,stid2s1,stjd2s1,vald2s1); emptyStacks(inp,stid2s2,stjd2s2,vald2s2); } }
/// Calc diagonal matrix Lambda void CalcLambda(const VVI RM, VI & LM) { if (RM.size() == 0) { cerr << "Size of relation matrix!" << endl; exit(-1); } LM.clear(); unsigned int i, j; int sum = 0; for (i = 0; i < RM.size(); ++i) { sum = 0; for (j = 0; j < RM[i].size(); ++j) { sum += RM[i][j]; } LM.push_back(sum); } }
pair<int, VI> GetMinCut(VVI &weights) { int N = weights.size(); VI used(N), cut, best_cut; int best_weight = -1; for (int phase = N-1; phase >= 0; phase--) { VI w = weights[0]; VI added = used; int prev, last = 0; for (int i = 0; i < phase; i++) { prev = last; last = -1; for (int j = 1; j < N; j++) if (!added[j] && (last == -1 || w[j] > w[last])) last = j; if (i == phase-1) { for (int j = 0; j < N; j++) weights[prev][j] += weights[last][j]; for (int j = 0; j < N; j++) weights[j][prev] = weights[prev][j]; used[last] = true; cut.push_back(last); if (best_weight == -1 || w[last] < best_weight) { best_cut = cut; best_weight = w[last]; } } else { for (int j = 0; j < N; j++) w[j] += weights[last][j]; added[last] = true; } } } return make_pair(best_weight, best_cut); }
int solve_impl(VVI &adj_list, int node, int k) { int N = adj_list.size(); static VB visited(N); static VI fn(N), gn(N); // fn[i] contains no of subtrees rooted at i // gn[i] contains no of subtrees not rooted at i visited[node] = true; VI f_values, g_values; for (int i = 0; i < adj_list[node].size(); i++) { int child = adj_list[node][i]; if (!visited[child]) { solve_impl(adj_list, child, k); f_values.push_back(fn[child]); g_values.push_back(gn[child]); } } fn[node] = max(subset_sum_count(f_values, k - 1) + 1, 1); gn[node] = 0; for (int i = 0; i < f_values.size(); i++) { gn[node] += f_values[i] + g_values[i]; } cout << "fn and gn for " << node << " are " << fn[node] << " " << gn[node] << endl; return fn[node] + gn[node]; }
void levelOrder(TreeNode* root, int iDeepth, VVI& result) { if (!root) return; if (iDeepth >= result.size()) result.resize(iDeepth + 1); result[iDeepth].push_back(root->val); levelOrder(root->left, iDeepth + 1, result); levelOrder(root->right, iDeepth + 1, result); }
void print(VVI& v) { for(int i = 0; i < v.size(); ++i) { for(int j = 0; j < v[i].size() - 1; ++j) { cout<<v[i][j]<<" "; } cout<<endl; } }
void OutputMatrix(const VVI matrix) { unsigned int i, j; for (i = 0; i < matrix.size(); ++i) { for (j = 0; j < matrix[i].size(); ++j) { cout << matrix[i][j] << " "; } cout << endl; } }
HLD(VVI adj) { N = adj.size(); P = PC = VI(N , -1); LVL = SZ = groupId = groupPos = VI(N , 0); this->adj = adj; for(int i = 0; i < N; ++i) { if(SZ[i] == 0) { initDfs(i); groups.push_back(VI()); for(int j = i; j != -1; j = PC[j]) groups.back().push_back(j) , groupId[j] = groups.size() - 1 , groupPos[j] = groups.back().size()-1; } } }
void imprime(VVI& dist){ const int V = dist.size(); for(int i=0;i<V;++i){ for(int j=0;j<V;++j){ if(dist[i][j]==INF) cout<<"- "; else cout<<dist[i][j]<< " "; } cout<<endl; } }
bool check(const VVI &g) { int n = g.size(); allisok = 1; for (int i = 0; i < n; ++i) colors[i] = 0; for (int i = 0; i < n; ++i) if (colors[i] == 0) dfs(g, i, 1); return allisok; }
//SUMA DE MATRICES BAJO EL ENFOQUE FILA-COLUMNA VVI sum_filcol(VVI A, VVI B) { int size=A.size(); VVI rslt(size,VI(size)); for(int i=0;i<size;i++) for(int j=0;j<size;j++) rslt[i][j]=A[i][j]+B[i][j]; return rslt; }
int GetMaxFlow(int s, int t) { N = cap.size(); flow = VVI(N, VI(N)); reached = VI(N); int totflow = 0; while (int amt = Augment(s, t, INF)) { totflow += amt; fill(reached.begin(), reached.end(), 0); } return totflow; }
//SUMA DE MATRICES BAJO EL ENFOQUE COLUMNA-FILA VVI sum_colfil(VVI A, VVI B) { int size=A.size(); VVI rslt(size,VI(size)); for(int i=0;i<size;i++) for(int j=0;j<size;j++) rslt[j][i]=A[j][i]+B[j][i]; return rslt; }
//lastrow = row for the last column void getPath(const VVI &parent, int lastrow, VI &path) { int nc = parent.size(); path.clear(); path.push_back(lastrow); if(nc > 1){ for(int c = nc - 2; c >= 0; c--){ //decide row for column c int r = parent[c+1][path.back()]; path.push_back(r); } } }
bool checkConnected(VVI &g) { int n = g.size(); if (n == 0) return 1; for (int i = 0; i < n; ++i) used[i] = 0; dfs(0, g); for (int i = 0; i < n; ++i) if (!used[i]) return 0; return 1; }
VVI exactify(const VVI& S, const int N) { VVI vec; for(int r = 0; r < N; ++r) { for(int c = 0; c < N; ++c) { for(int cand = 0; cand < N; ++cand) { if(S[r][c] != 0 && S[r][c] != cand + 1) { continue; } row_cand[vec.size()] = r*N*N + c*N + cand; vector<int> L(4*N*N); vec.push_back(L); int reg = region(r,c,N); vec.back()[r*N + c] = 1; vec.back()[N*N + r*N + cand] = 1; vec.back()[2*N*N + N*c + cand] = 1; vec.back()[3*N*N + N*reg + cand] = 1; } } } if(!given_solution.empty()) { map<int,int> rev; map<int,int>::iterator it; for(it = row_cand.begin(); it != row_cand.end(); ++it) { rev[it->second] = it->first; } vector<int> check(vec[0].size()); for(int x = 0; x < given_solution.size(); ++x) { for(int y = 0; y < given_solution[x].size(); ++y) { int val = x * N * N + y * N + given_solution[x][y] - 1; for(int i = 0; i < vec[rev[val]].size(); ++i) { check[i] += vec[rev[val]][i]; } } } for(int i = 0; i < check.size(); ++i) { assert(check[i] == 1); } } return vec; }
bool add(VVI & x, VVI & y, VVI & z) { int mx = x.size(); int my = y.size(); if (mx == 0 || my == 0) return false; int nx = x[0].size(); int ny = y[0].size(); if (nx == 0 || ny == 0) return false; //cout << "mx: " << mx << endl; //cout << "my: " << my << endl; //cout << "nx: " << nx << endl; //cout << "ny: " << ny << endl; if (mx != my || nx != ny) return false; z.clear(); for (int i = 0; i < mx; i++) { z.push_back(VI(nx, 0)); for (int j = 0; j < nx; j++) { double tmp = (double)x[i][j] + (double)y[i][j]; if (tmp > INT_MAX || tmp < INT_MIN) return false; z[i][j] = (int)tmp; } } return true; }
/*void hs(VVI &inp){ int valh = 0; int valv = 0; int n=inp.size(); STACK stih,stjh; STACK stiv,stjv; for(int i=0;i<n;i++){ for(int j=0;j<n;j++){ update(inp,stih,stjh,i,j,valh); update(inp,stiv,stjv,j,i,valv); } emptyStacks(inp,stih,stjh,valh); emptyStacks(inp,stiv,stjv,valv); } }*/ void hs(VVI &inp){ int n = inp.size(); STACK stc_h; STACK stc_v; int val_h =0; int val_v=0; for(int i=0;i<n;i++){ for(int j=0;j<n;j++){ if(inp[i][j]>0){ val_h++; stc_h.push(j); } else { while(!stc_h.empty()){ int j_h = stc_h.top(); stc_h.pop(); if(inp[i][j_h]<val_h){ inp[i][j_h]=val_h; } } val_h=0; } if(inp[j][i]>0){ val_v++; stc_v.push(j); } else { while(!stc_v.empty()){ int j_v = stc_v.top(); stc_v.pop(); if(inp[j_v][i]<val_v){ inp[j_v][i] = val_v; } } val_v=0; } } while(!stc_h.empty()){ int j_h = stc_h.top(); stc_h.pop(); if(inp[i][j_h]<val_h){ inp[i][j_h]=val_h; } } val_h=0; while(!stc_v.empty()){ int j_v = stc_v.top(); stc_v.pop(); if(inp[j_v][i]<val_v){ inp[j_v][i] = val_v; } } val_v=0; } }
bool checkBipartate(VVI &g, int k) { int n = g.size(); if (n == 0) return 1; for (int i = 0; i < n; ++i) used[i] = 0; for (int i = 0; i < n; ++i) if (!used[i]) { k--; dfs(i, g); } return k == 0; }
VS print(VVI & m) { VS M; for (int i = 0; i < (int)m.size(); i++) { M.push_back(""); for (int j = 0; j < (int)m[i].size(); j++) { ostringstream os; os << m[i][j]; if (j == 0) M[i] += os.str(); else M[i] += (" " + os.str()); } } //for (int i = 0; i < (int)M.size(); i++) //cout << M[i] << endl; return M; }