Problemas de HackerEarth | Isaac Lozano Osorio

ArticulationPointsAndBridges — HackerEarth

Mon, 01 Jan 0001 00:00:00 +0000

Solución — ArticulationPointsAndBridges

#include <bits/stdc++.h>
using namespace std;

vector<int> adj[11],ap;
vector<pair<int,int> >bridges;
int disc[11],low[11],parent[11],visited[11];

pair<int,int> minmax(int x,int y)
{
 pair<int,int> ret;
 if(x<y) ret=make_pair(x,y);
 else ret=make_pair(y,x);
 return ret;
}

void dfs(int vertex,int vistime)
{
 visited[vertex]=1;
 disc[vertex]=low[vertex]=vistime;
 int child=0;
 for(int i=0;i<(int)adj[vertex].size();i++)
 if(!visited[adj[vertex][i]])
 {
 child++;
 parent[adj[vertex][i]]=vertex;
 dfs(adj[vertex][i],vistime+1);
 low[vertex]=min(low[vertex],low[adj[vertex][i]]);
 if(parent[vertex]==-1){
 bridges.push_back(minmax(vertex,adj[vertex][i]));
 if(child>1)
 ap.push_back(vertex);
 }
 else if(low[adj[vertex][i]]>disc[vertex]){
 bridges.push_back(minmax(vertex,adj[vertex][i]));
 ap.push_back(vertex);
 }
 else if(low[adj[vertex][i]]==disc[vertex])
 ap.push_back(vertex);

 }
 else if(parent[vertex]!=adj[vertex][i])
 low[vertex]=min(low[vertex],disc[adj[vertex][i]]);

}
int main()
{
 int n,m,x,y;
 scanf("%d%d",&n,&m);
 for(int i=0;i<m;i++){
 scanf("%d%d",&x,&y);
 adj[x].push_back(y);
 adj[y].push_back(x);
 }
 memset(parent,-1,sizeof(parent));
 dfs(0,0);
 sort(ap.begin(),ap.end());
 sort(bridges.begin(),bridges.end());
 printf("%d\n",ap.size());
 for(unsigned i=0;i<ap.size();i++) printf("%d ",ap[i]);
 printf("\n%d\n",bridges.size());
 for(unsigned i=0;i<bridges.size();i++) printf("%d %d\n", bridges[i].first,bridges[i].second);
 return 0;
}

CountSubstringOccurrences — HackerEarth

Mon, 01 Jan 0001 00:00:00 +0000

Solución — CountSubstringOccurrences

#include <bits/stdc++.h>
using namespace std;

vector<int> Z(string &s) {
int n = s.size();
int L, R;
L = R = 0;
vector<int> Z(n, 0);
for (int i = 1; i < n; ++i){
if (i < R) Z[i] = min(Z[i-L], R-i);
else Z[i] = 0;
while (Z[i] + i < n and s[Z[i]] == s[i+Z[i]]) ++Z[i];
if (i+Z[i] > R){
L = i;
R = i + Z[i];
}
}
return Z;
}

int main()
{
 string a,b; cin>>a>>b;
 string resu = a+"$"+b;
 vector<int> res = Z(resu);
 int sol = 0;
 for(unsigned int i=0; i<res.size();i++) if(res[i]==a.length()) sol++;
 printf("%d",sol);
 return 0;
}

FindTheFlow — HackerEarth

Mon, 01 Jan 0001 00:00:00 +0000

Solución — FindTheFlow

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;

struct Node {
 int x, y, v;// x->y, v
 int next;
} edge[500005];
int e, head[500005], dis[500005], previ[500005], record[500005];
void addEdge(int x, int y, int v) {
 edge[e].x = x, edge[e].y = y, edge[e].v = v;
 edge[e].next = head[x], head[x] = e++;
 edge[e].x = y, edge[e].y = x, edge[e].v = 0;
 edge[e].next = head[y], head[y] = e++;
}
int maxflow(int s, int t) {
 int flow = 0;
 int i, x, y;
 while(1) {
 memset(dis, 0, sizeof(dis));
 dis[s] = 0xffff; // oo
 queue<int> Q;
 Q.push(s);
 while(!Q.empty()) {
 x = Q.front();
 Q.pop();
 for(i = head[x]; i != -1; i = edge[i].next) {
 y = edge[i].y;
 if(dis[y] == 0 && edge[i].v > 0) {
 previ[y] = x;
 record[y] = i;
 dis[y] = min(dis[x], edge[i].v);
 Q.push(y);
 }
 }
 if(dis[t]) break;
 }
 if(dis[t] == 0) break;
 flow += dis[t];
 for(x = t; x != s; x = previ[x]) {
 int ri = record[x];
 edge[ri].v -= dis[t];
 edge[ri^1].v += dis[t];
 }
 }
 return flow;
}

int main()
{
 //freopen("C:/Users/Isaac/Documents/QT/Entregar/in.txt","r",stdin);
 e=0;
 memset(head,-1,sizeof(head));
 int n; scanf("%d",&n);
 int S=1,T=n+1,c;
 char a,b;
 map<char,int> M; M['S']=1; M['T']=n+1;
 int cnt=2;
 for(int j=0; j<n;j++)
 {
 cin>>a>>b>>c;
 if(M[a]==0) { M[a]=cnt; cnt++; }
 if(M[b]==0) { M[b]=cnt; cnt++; }
 addEdge(M[a],M[b],c);
 }
 int flow = maxflow(S,T);
 printf("%d\n",flow);
 return 0;
}

HoliAndCulturalFestival — HackerEarth

Mon, 01 Jan 0001 00:00:00 +0000

Solución — HoliAndCulturalFestival

#include <cmath>
#include <vector>
#include <iostream>

using namespace std;

typedef vector<int> VI;
typedef vector<VI> VVI;
typedef int L;
typedef vector<L> VL;
typedef vector<VL> VVL;
typedef pair<int, int> PII;
typedef vector<PII> VPII;

const L INF = 0x3f3f3f3f;

struct MinCostMaxFlow {
 int N;
 VVL cap, flow, cost;
 VI found;
 VL dist, pi, width;
 VPII dad;

 MinCostMaxFlow(int N) :
 N(N), cap(N, VL(N)), flow(N, VL(N)), cost(N, VL(N)),
 found(N), dist(N), pi(N), width(N), dad(N) {}

 void AddEdge(int from, int to, L cap, L cost) {
 this->cap[from][to] = cap;
 this->cost[from][to] = cost;
 }

 void Relax(int s, int k, L cap, L cost, int dir) {
 L val = dist[s] + pi[s] - pi[k] + cost;
 if (cap && val < dist[k]) {
 dist[k] = val;
 dad[k] = make_pair(s, dir);
 width[k] = min(cap, width[s]);
 }
 }

 L Dijkstra(int s, int t) {
 fill(found.begin(), found.end(), false);
 fill(dist.begin(), dist.end(), INF);
 fill(width.begin(), width.end(), 0);
 dist[s] = 0;
 width[s] = INF;

 while (s != -1) {
 int best = -1;
 found[s] = true;
 for (int k = 0; k < N; k++) {
 if (found[k]) continue;
 Relax(s, k, cap[s][k] - flow[s][k], cost[s][k], 1);
 Relax(s, k, flow[k][s], -cost[k][s], -1);
 if (best == -1 || dist[k] < dist[best]) best = k;
 }
 s = best;
 }

 for (int k = 0; k < N; k++)
 pi[k] = min(pi[k] + dist[k], INF);
 return width[t];
 }

 pair<L, L> GetMaxFlow(int s, int t) {
 L totflow = 0, totcost = 0;
 while (L amt = Dijkstra(s, t)) {
 totflow += amt;
 for (int x = t; x != s; x = dad[x].first) {
 if (dad[x].second == 1) {
 flow[dad[x].first][x] += amt;
 totcost += amt * cost[dad[x].first][x];
 } else {
 flow[x][dad[x].first] -= amt;
 totcost -= amt * cost[x][dad[x].first];
 }
 }
 }
 return make_pair(totflow, totcost);
 }
};

int main(){
 //freopen("C:/Users/Isaac/Documents/QT/Entregar/in.txt","r",stdin);
 int cases; scanf("%d",&cases);
 int P,D,M; scanf("%d%d%d",&P,&D,&M);
 MinCostMaxFlow mcmf(8+cases*cases);
 for(int i=1; i<=cases;i++) mcmf.AddEdge(0,i,1,0);
 for(int i=1; i<=cases;i++){
 for(int j=1; j<=cases;j++)
 {
 int x; scanf("%d",&x);
 mcmf.AddEdge(i,j+i*3,1,-x);
 mcmf.AddEdge(j+i*3,cases*cases+4+j,1,0);
 if(i==1 && j==1) mcmf.AddEdge(cases*cases+4+j,7+cases*cases,P,0);
 else if(i==1 && j==2) mcmf.AddEdge(cases*cases+4+j,7+cases*cases,D,0);
 else mcmf.AddEdge(cases*cases+4+j,7+cases*cases,M,0);
 }
 }
 pair<int, int> res = mcmf.GetMaxFlow(0,7+cases*cases);
 //printf("%d\n",res.first);
 printf("%d\n",-res.second);
 return 0;
}

ManageMiser — HackerEarth

Mon, 01 Jan 0001 00:00:00 +0000

Solución — ManageMiser

#include <cmath>
#include <vector>
#include <iostream>

using namespace std;

typedef vector<int> VI;
typedef vector<VI> VVI;
typedef int L;
typedef vector<L> VL;
typedef vector<VL> VVL;
typedef pair<int, int> PII;
typedef vector<PII> VPII;

const L INF = 0x3f3f3f3f;

struct MinCostMaxFlow {
 int N;
 VVL cap, flow, cost;
 VI found;
 VL dist, pi, width;
 VPII dad;

 MinCostMaxFlow(int N) :
 N(N), cap(N, VL(N)), flow(N, VL(N)), cost(N, VL(N)),
 found(N), dist(N), pi(N), width(N), dad(N) {}

 void AddEdge(int from, int to, L cap, L cost) {
 this->cap[from][to] = cap;
 this->cost[from][to] = cost;
 }

 void Relax(int s, int k, L cap, L cost, int dir) {
 L val = dist[s] + pi[s] - pi[k] + cost;
 if (cap && val < dist[k]) {
 dist[k] = val;
 dad[k] = make_pair(s, dir);
 width[k] = min(cap, width[s]);
 }
 }

 L Dijkstra(int s, int t) {
 fill(found.begin(), found.end(), false);
 fill(dist.begin(), dist.end(), INF);
 fill(width.begin(), width.end(), 0);
 dist[s] = 0;
 width[s] = INF;

 while (s != -1) {
 int best = -1;
 found[s] = true;
 for (int k = 0; k < N; k++) {
 if (found[k]) continue;
 Relax(s, k, cap[s][k] - flow[s][k], cost[s][k], 1);
 Relax(s, k, flow[k][s], -cost[k][s], -1);
 if (best == -1 || dist[k] < dist[best]) best = k;
 }
 s = best;
 }

 for (int k = 0; k < N; k++)
 pi[k] = min(pi[k] + dist[k], INF);
 return width[t];
 }

 pair<L, L> GetMaxFlow(int s, int t) {
 L totflow = 0, totcost = 0;
 while (L amt = Dijkstra(s, t)) {
 totflow += amt;
 for (int x = t; x != s; x = dad[x].first) {
 if (dad[x].second == 1) {
 flow[dad[x].first][x] += amt;
 totcost += amt * cost[dad[x].first][x];
 } else {
 flow[x][dad[x].first] -= amt;
 totcost -= amt * cost[x][dad[x].first];
 }
 }
 }
 return make_pair(totflow, totcost);
 }
};

int main(){
 //freopen("C:/Users/Isaac/Documents/QT/Entregar/in.txt","r",stdin);
 int cases; scanf("%d",&cases);
 MinCostMaxFlow mcmf(201);
 int flag=1;
 for(int i=1; i<=cases;i++){
 mcmf.AddEdge(0,i,1,0);
 for(int j=1; j<=cases;j++)
 {
 int x; scanf("%d",&x);
 mcmf.AddEdge(i,j+cases,1,x);
 if(flag==1) mcmf.AddEdge(j+cases,200,1,0);
 }
 flag=2;
 }
 pair<int, int> res = mcmf.GetMaxFlow(0, 200);
 //printf("%d\n",res.first);
 printf("%d\n",res.second);
 return 0;
}

Matrix_Sum — HackerEarth

Mon, 01 Jan 0001 00:00:00 +0000

Solución — Matrix_Sum

#include <bits/stdc++.h>
using namespace std;

int main()
{
 int n,m; scanf("%d%d",&n,&m);
 int memo[n+1][m+1];
 int matrix[n+1][m+1];
 for(int i=1; i<=n;i++)
 for(int j=1; j<=m;j++) scanf("%d",&matrix[i][j]);
 memset(memo,0,sizeof(memo));
 /*
 1 2 3 1 3 6
 4 5 6 5 12 21
 7 8 9 12 27 45
 */
 for(int i=1; i<=n;i++)
 for(int j=1; j<=m;j++)
 memo[i][j]=memo[i-1][j]+memo[i][j-1]+matrix[i][j]-memo[i-1][j-1];
 int query; scanf("%d",&query);
 int n1,m1;
 for(int i=0; i<query;i++)
 {
 scanf("%d%d",&n1,&m1);
 printf("%d\n",memo[n1][m1]);
 }
 return 0;
}

MinCutBaahubali vs Bhallaladeva — HackerEarth

Mon, 01 Jan 0001 00:00:00 +0000

Solución — MinCutBaahubali vs Bhallaladeva

// Adjacency matrix implementation of Stoer-Wagner min cut algorithm.
//
// Running time:
// O(|V|^3)
//
// INPUT:
// - graph, constructed using AddEdge()
//
// OUTPUT:
// - (min cut value, nodes in half of min cut)

#include <cmath>
#include <vector>
#include <iostream>
#include <queue>
#include <map>
#include <cstring>

using namespace std;

typedef vector<int> VI;
typedef vector<VI> VVI;

const int INF = 1000000000;

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);
}
struct Node {
 int x, y, v;// x->y, v
 int next;
} edge[105];
int e, head[105], dis[105], previ[105], record[105];
void addEdge(int x, int y, int v) {
 edge[e].x = x, edge[e].y = y, edge[e].v = v;
 edge[e].next = head[x], head[x] = e++;
 edge[e].x = y, edge[e].y = x, edge[e].v = 0;
 edge[e].next = head[y], head[y] = e++;
}
int maxflow(int s, int t) {
 int flow = 0;
 int i, x, y;
 while(1) {
 memset(dis, 0, sizeof(dis));
 dis[s] = 0xffff; // oo
 queue<int> Q;
 Q.push(s);
 while(!Q.empty()) {
 x = Q.front();
 Q.pop();
 for(i = head[x]; i != -1; i = edge[i].next) {
 y = edge[i].y;
 if(dis[y] == 0 && edge[i].v > 0) {
 previ[y] = x;
 record[y] = i;
 dis[y] = std::min(dis[x], edge[i].v);
 Q.push(y);
 }
 }
 if(dis[t]) break;
 }
 if(dis[t] == 0) break;
 flow += dis[t];
 for(x = t; x != s; x = previ[x]) {
 int ri = record[x];
 edge[ri].v -= dis[t];
 edge[ri^1].v += dis[t];
 }
 }
 return flow;
}

int main() {
 e=0;
 memset(head, -1, sizeof(head));
 int N,aux=2;
 cin >> N;
 char S,T; cin>>S>>T;
 map<char,int> M; M[S]=1; M[T]=N;
 VVI weights(N, VI(N));
 for (int i = 0; i < N; i++) {
 char a, b; int c;
 cin >> a >> b >> c;
 if(M[a]==0) { M[a]=aux; aux++; }
 if(M[b]==0) { M[b]=aux; aux++; }
 weights[M[a]][M[b]] = c;
 addEdge(M[a],M[b],c);
 }
 pair<int, VI> res = GetMinCut(weights);
 int flow = maxflow(1, N);
 cout<<flow-res.first<<'\n';
 return 0;
}

NEWFRIENDS — HackerEarth

Mon, 01 Jan 0001 00:00:00 +0000

Solución — NEWFRIENDS

#include <bits/stdc++.h>
using namespace std;

struct Node {
 int x, y, v;// x->y, v
 int next;
} edge[50005];
int e, head[1005], dis[1005], previ[1005], record[1005];
void addEdge(int x, int y, int v) {
 edge[e].x = x, edge[e].y = y, edge[e].v = v;
 edge[e].next = head[x], head[x] = e++;
 edge[e].x = y, edge[e].y = x, edge[e].v = 0;
 edge[e].next = head[y], head[y] = e++;
}
int maxflow(int s, int t) {
 int flow = 0;
 int i, x, y;
 while(1) {
 memset(dis, 0, sizeof(dis));
 dis[s] = 0xffff; // oo
 queue<int> Q;
 Q.push(s);
 while(!Q.empty()) {
 x = Q.front();
 Q.pop();
 for(i = head[x]; i != -1; i = edge[i].next) {
 y = edge[i].y;
 if(dis[y] == 0 && edge[i].v > 0) {
 previ[y] = x;
 record[y] = i;
 dis[y] = min(dis[x], edge[i].v);
 Q.push(y);
 }
 }
 if(dis[t]) break;
 }
 if(dis[t] == 0) break;
 flow += dis[t];
 for(x = t; x != s; x = previ[x]) {
 int ri = record[x];
 edge[ri].v -= dis[t];
 edge[ri^1].v += dis[t];
 }
 }
 return flow;
}

int main()
{
 int cases; scanf("%d",&cases);
 while(cases--)
 {
 e=0;
 memset(head,-1,sizeof(head));
 int n,m; scanf("%d%d",&n,&m);
 for(int i=0; i<m;i++)
 {
 int x,y;
 scanf("%d%d",&x,&y);
 addEdge(x+1,y+1,1);
 }
 int S,T,k; scanf("%d%d%d",&S,&T,&k);
 addEdge(1,S+1,k+1);
 addEdge(T+1,n+2,k+1);
 int flow = maxflow(1,n+2);
 //cout<<flow<<'\n';
 if(flow>=(k+1)) printf("YES\n");
 else printf("NO\n");
 }
 return 0;
}

ProductiveProductivity — HackerEarth

Mon, 01 Jan 0001 00:00:00 +0000

Solución — ProductiveProductivity

#include <cmath>
#include <vector>
#include <iostream>
#include <map>

using namespace std;

typedef vector<int> VI;
typedef vector<VI> VVI;
typedef int L;
typedef vector<L> VL;
typedef vector<VL> VVL;
typedef pair<int, int> PII;
typedef vector<PII> VPII;

const L INF = 0x3f3f3f3f;

map<int,int> M;

struct MinCostMaxFlow {
 int N;
 VVL cap, flow, cost;
 VI found;
 VL dist, pi, width;
 VPII dad;

 MinCostMaxFlow(int N) :
 N(N), cap(N, VL(N)), flow(N, VL(N)), cost(N, VL(N)),
 found(N), dist(N), pi(N), width(N), dad(N) {}

 void AddEdge(int from, int to, L cap, L cost) {
 this->cap[from][to] = cap;
 this->cost[from][to] = cost;
 }

 void Relax(int s, int k, L cap, L cost, int dir) {
 L val = dist[s] + pi[s] - pi[k] + cost;
 if (cap && val < dist[k]) {
 dist[k] = val;
 dad[k] = make_pair(s, dir);
 width[k] = min(cap, width[s]);
 }
 }

 L Dijkstra(int s, int t) {
 fill(found.begin(), found.end(), false);
 fill(dist.begin(), dist.end(), INF);
 fill(width.begin(), width.end(), 0);
 dist[s] = 0;
 width[s] = INF;

 while (s != -1) {
 int best = -1;
 found[s] = true;
 for (int k = 0; k < N; k++) {
 if (found[k]) continue;
 Relax(s, k, cap[s][k] - flow[s][k], cost[s][k], 1);
 Relax(s, k, flow[k][s], -cost[k][s], -1);
 if (best == -1 || dist[k] < dist[best]) best = k;
 }
 s = best;
 }

 for (int k = 0; k < N; k++)
 pi[k] = min(pi[k] + dist[k], INF);
 return width[t];
 }

 pair<L, L> GetMaxFlow(int s, int t) {
 L totflow = 0, totcost = 0;
 while (L amt = Dijkstra(s, t)) {
 totflow += amt;
 for (int x = t; x != s; x = dad[x].first) {
 if (dad[x].second == 1) {
 flow[dad[x].first][x] += amt;
 totcost += M[amt * cost[dad[x].first][x]];
 } else {
 flow[x][dad[x].first] -= amt;
 totcost -= M[amt * cost[x][dad[x].first]];
 }
 }
 }
 return make_pair(totflow, totcost);
 }
};

int main(){
 //freopen("C:/Users/Isaac/Documents/QT/Entregar/in.txt","r",stdin);
 int cases; scanf("%d",&cases);
 while(cases--)
 {
 int n; scanf("%d",&n);
 int T = 2+2*n+n*n;
 MinCostMaxFlow mcmf(T);
 for(int i=1; i<=n;i++) mcmf.AddEdge(0,i,1,0);
 int flag=1;
 for(int i=1; i<=n;i++){
 for(int j=1; j<=n;j++)
 {
 int x; scanf("%d",&x); M[1000-x]=x;
 mcmf.AddEdge(i,i*n+j,1,1000-x);
 mcmf.AddEdge(i*n+j,n*n+n+j,1,0);
 if(flag==1) mcmf.AddEdge(n*n+n+j,T-1,1,0);
 }
 flag=2;
 }
 pair<int, int> res = mcmf.GetMaxFlow(0, T-1);
 //printf("%d\n",res.first);
 printf("%d\n",res.second);
 }
 return 0;
}

ShilAndLabAssignment — HackerEarth

Mon, 01 Jan 0001 00:00:00 +0000

Solución — ShilAndLabAssignment

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;

struct Node {
 int x, y, v;// x->y, v
 int next;
} edge[500005];
int e, head[500005], dis[500005], previ[500005], record[500005];
void addEdge(int x, int y, int v) {
 edge[e].x = x, edge[e].y = y, edge[e].v = v;
 edge[e].next = head[x], head[x] = e++;
 edge[e].x = y, edge[e].y = x, edge[e].v = 0;
 edge[e].next = head[y], head[y] = e++;
}
int maxflow(int s, int t) {
 int flow = 0;
 int i, x, y;
 while(1) {
 memset(dis, 0, sizeof(dis));
 dis[s] = 0xffff; // oo
 queue<int> Q;
 Q.push(s);
 while(!Q.empty()) {
 x = Q.front();
 Q.pop();
 for(i = head[x]; i != -1; i = edge[i].next) {
 y = edge[i].y;
 if(dis[y] == 0 && edge[i].v > 0) {
 previ[y] = x;
 record[y] = i;
 dis[y] = min(dis[x], edge[i].v);
 Q.push(y);
 }
 }
 if(dis[t]) break;
 }
 if(dis[t] == 0) break;
 flow += dis[t];
 for(x = t; x != s; x = previ[x]) {
 int ri = record[x];
 edge[ri].v -= dis[t];
 edge[ri^1].v += dis[t];
 }
 }
 return flow;
}

int main()
{
 e=0;
 memset(head,-1,sizeof(head));
 int n,m; scanf("%d%d",&n,&m);
 int flag=1,S=1,T=500000;
 for(int j=0; j<n;j++)
 {
 int x;
 scanf("%d",&x);
 addEdge(S,x+m+1,x);
 for(int i=1; i<=m;i++)
 {
 if(x%i==0) addEdge(x+m+1,i+1,1);
 if(flag==1) addEdge(i+1,T,1);
 }
 flag=2;
 }
 int flow = maxflow(S,T);
 printf("%d\n",flow);
 return 0;
}