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;
}
}
