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 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 DFS (int v) { idx[v] = index; low[v] = index; index += 1; st.push_back(v); inStack[v] = true; for (auto w : adj[v]) { if (idx[w] == -1) { DFS(w); low[v] = min(low[v], low[w]); } else if (inStack[w]) { low[v] = min(low[v], low[w]); } } if (low[v] == idx[v]) { int w; components.push_back(VI()); do { w = st.back(); st.pop_back(); inStack[w] = false; componentOf[w] = totalComponents; components[totalComponents].push_back(w); } while (w != v); totalComponents++; } }
set<VT> LCSall(VT& A, VT& B) { VVI dp; int n = A.size(), m = B.size(); dp.resize(n+1); for(int i=0; i<=n; i++) dp[i].resize(m+1, 0); for(int i=1; i<=n; i++) for(int j=1; j<=m; j++) { if(A[i-1] == B[j-1]) dp[i][j] = dp[i-1][j-1]+1; else dp[i][j] = max(dp[i-1][j], dp[i][j-1]); } set<VT> res; backtrackall(dp, res, A, B, n, m); return res; }
bool can(int prefLength,VI& result,bool return_result = false){ result.clear(); vector<Hash> hashes; int n = 1; for(int sn = 0; sn<n;++sn){ HashComputer<mod1> curHash1; HashComputer<mod2> curHash2; for(int i = 0; i < prefLength; ++i){ curHash1.add(a[sn][i]); curHash2.add(a[sn][i]); } hashes.push_back(Hash(make_pair(curHash1.value,curHash2.value),sn,0)); for(int i = prefLength; i < a[sn].size(); ++i){ curHash1.shift(a[sn][i-prefLength],a[sn][i],prefLength); curHash2.shift(a[sn][i-prefLength],a[sn][i],prefLength); hashes.push_back(Hash(make_pair(curHash1.value,curHash2.value),sn,i-prefLength+1)); } } sort(hashes.begin(),hashes.end()); //hashes.resize(unique(hashes.begin(),hashes.end(),EqualString())-hashes.begin()); VVI results; for(int i = k-1; i < hashes.size();++i) if(hashes[i].equals(hashes[i-k+1])){ if(return_result == true){ results.push_back(VI()); int k = results.size()-1; for(int j = i-n+1; j <=i;++j) results[k].push_back(hashes[j].pos); } else return true; } if(return_result == true){ result = *min_element(results.begin(),results.end()); return true; } return false; }
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; } }
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 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; } }
int main() { int N, M; while (cin >> N >> M) { int a, b; VVI w; VI mr; VI mc; w.resize(N); for (int i = 0; i < N; ++i) { w[i].resize(N); for (int j = 0; j < N; ++j) { w[i][j] = 0; } } for (int i = 0; i < M; ++i) { cin >> a >> b; w[a][b] = 1; } int numMatches = BipartiteMatching(w, mr, mc); if (numMatches == N) { cout << "YES\n"; } else { cout << "NO\n"; } } return 0; }
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; } }
VT LCS(VT& A, VT& B) { VVI dp; int n = A.size(), m = B.size(); dp.resize(n+1); for(int i=0; i<=n; i++) dp[i].resize(m+1, 0); for(int i=1; i<=n; i++) for(int j=1; j<=m; j++) { if(A[i-1] == B[j-1]) dp[i][j] = dp[i-1][j-1]+1; else dp[i][j] = max(dp[i-1][j], dp[i][j-1]); } VT res; backtrack(dp, res, A, B, n, m); reverse(res.begin(), res.end()); return res; }
VVI transpose(VVI v){ VVI result; result.resize(v.size()); for(int i=0;i<result.size();i++) result[i].resize(v.size()); for(int i=0;i<v.size();i++){ for(int j=0;j<v.size();j++){ result[j][v.size() - 1 - i] = v[i][j]; } } return result; }
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; }
void buildBCC () { idx = VI(n, -1), low = VI(n); cutVertices.clear(); bridges.clear(); st.clear(); components.clear(); totalComponents++; for (int i = 0; i < n; i++) if (idx[i] == -1) { DFS(make_pair(i, -1), 0); } }
//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; }
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 DFS (PI v, int index) { idx[v.x] = index; low[v.x] = index; index += 1; int children = 0; bool ap = false; for (auto w : adj[v.x]) if (w.y != v.y) { if (idx[w.x] == -1) { st.push_back(w.y); index = DFS(w, index); low[v.x] = min(low[v.x], low[w.x]); if (low[w.x] > idx[v.x]) { bridges.push_back(w.y); } children++; if (low[w.x] >= idx[v.x]) { if (v.y != -1 || children >= 2) { ap = true; } components.push_back(VI()); totalComponents++; int u; do { u = st.back(); st.pop_back(); components.back().push_back(u); } while (u != w.y); } } else if (idx[w.x] < idx[v.x]) { st.push_back(w.y); low[v.x] = min(low[v.x], idx[w.x]); } } if (ap) { cutVertices.push_back(v.x); } return index; }
//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; }
int maxDifference(VS is, int dec) { VVI g; for (int i = 0; i < SZ(is); i++) { g.PB(VI()); for (int j = 0; j < SZ(is[i]); j++) { if (is[i][j] == 'Y') { g[i].PB(j); } } } if (findComps(g) > 1) { return -1; } int maxD = 0; for (int s = 0; s < SZ(g); s++) { queue<int> q; q.push(s); VB u(SZ(g)); VI d(SZ(g)); u[s] = true; while (!q.empty()) { int v = q.front(); q.pop(); for (int i = 0; i < SZ(g[v]); i++) { int to = g[v][i]; if (!u[to]) { u[to] = true; q.push(to); d[to] = d[v] + 1; } } } for (int i = 0; i < SZ(d); i++) { maxD = max(maxD, d[i]); } } return maxD * dec; }
int calc(const VI& in) { VVI vals; // memo for(int i=0;;i++) { vals.pb(VI(words.size(),1)); bool found = false; for(int j=0;j<in.size();j++) if(in[j] == i) { found = true; for(int k=0;k<words.size();k++) { vals.back()[k] *= words[k][equation[j]]; vals.back()[k] %= MOD; } } if(found == false) { vals.pop_back(); break; } } int mul = 1; for(int i=0;i<vals.size();i++) { int sum = 0; for(int j=0;j<vals[i].size();j++) sum += vals[i][j]; sum %= MOD; mul = (mul * sum) % MOD; } return mul; }
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; } }