void write()
{
if (!m)
{
printf("%d\n%d\n",1,1);
return;
}
int L=0*XX,R=m*XX,best;
do
{
int mid=(L+R)>>1;
build_network(mid);
int g=m*XX-sap();
if (g<=0) R=mid;
else L=mid,best=L;
}
while (L+1!=R);
build_network(best);
sap();
dfs(S);
for (int i=0;i<n;i++)
if (!visited[i]) total++;
printf("%d\n",total);
for (int i=0;i<n;i++)
if (!visited[i])
printf("%d\n",i+1);
}
int judge(int ti)
{
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++)
{
int u=(i-1)*m+j;
u=(ti-1)*m*n+2+u;
if(mp[i][j]=='#')
continue;
for(int k=0;k<5;k++)
{
int x=i+di[k][0];
int y=j+di[k][1];
int v=(x-1)*m+y;
v=ti*m*n+2+v;
if(!in(x,y))
continue;
add(u,v,1);
}
}
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++)
{
int v=(i-1)*m+j;
v=2+ti*m*n+v;
if(mp[i][j]=='@')
{
add(v,t,1);
}
}
nn+=n*m;
ans+=sap();
return ans==sum;
}
bool solve(bool flag)
{
memset(g, 0, sizeof(g));
memset(v, 0, sizeof(v));
memset(h, 0, sizeof(h));
S = 1; T = 2 * (n1 + n2 + 1) + 1;
for(int i = 1; i <= n1; i++)
for(int j = 1; j <= n2; j++)
if(abs(a[i].a - b[j].a) < d)
{
g[O(a[i].idx)][I(b[j].idx)] = inf;
g[O(b[j].idx)][I(a[i].idx)] = inf;
}
for(int i = 1; i <= n1; i++) g[I(a[i].idx)][O(a[i].idx)] = 1;
for(int i = 1; i <= n2; i++) g[I(b[i].idx)][O(b[i].idx)] = 1;
if(!flag)
{
std::sort(a+1, a+1+n1, cmp1); std::sort(b+1, b+1+n2, cmp2);
for(int i = 1; i <= m; i++) g[S][I(a[i].idx)] = inf;
for(int i = 1; i <= m; i++) g[O(b[i].idx)][T] = inf;
}
else {
std::sort(a+1, a+1+n1, cmp2); std::sort(b+1, b+1+n2, cmp1);
for(int i = 1; i <= m; i++) g[O(a[i].idx)][T] = inf;
for(int i = 1; i <= m; i++) g[S][I(b[i].idx)] = inf;
}
v[0] = T;
int maxflow = 0;
while(h[S] < T) maxflow += sap(1, inf);
//printf("flag = %d, res = %d\n",flag, maxflow);
return maxflow >= m;
}
void solve()
{
int ans, num, i, j;
ans = sap();
printf("%d\n", ans);
memset(cnt, 0, sizeof(cnt));
dfs(st);
num = 0;
for(i = 0;i <= tot; i++)
{
if((i & 1)) continue;
if(cnt[e[i].u] != cnt[e[i].v])
{
if(e[i].u == st)
{
num++;
vec[num][0] = e[i].v;
vec[num][1] = 0;
}
if(e[i].v == ed)
{
num++;
vec[num][0] = e[i].u - n2;
vec[num][1] = 1;
}
}
}
printf("%d\n", num);
for(i = 1;i <= num; i++) printf("%d %c\n", vec[i][0], (vec[i][1] == 0 ? '-' : '+'));
}
int main(){
int f,d,n;
while(~scanf("%d%d%d",&n,&f,&d)){
gInit();
V=2+f+d+n+n;
int t;
for(int i=0;i<f;i++){
scanf("%d",&t);
add_edge(0,2+i,t);
}
for(int i=0;i<d;i++){
scanf("%d",&t);
add_edge(2+f+i,1,t);
}
char ch[210];
for(int j=0;j<n;j++){
scanf("%s",ch);
for(int i=0;i<f;i++){
if(ch[i]=='Y')
add_edge(2+i,2+f+d+j,1);
}
}
for(int j=0;j<n;j++){
scanf("%s",ch);
for(int i=0;i<d;i++){
if(ch[i]=='Y')
add_edge(2+f+d+n+j,2+f+i,1);
}
}
for(int j=0;j<n;j++)
add_edge(2+f+d+j,2+f+d+n+j,1);
printf("%d\n",sap(0,1));
}
return 0;
}
int sap(const int idx, const int maxCap)
{
if (idx == sink)
return maxCap;
int l = maxCap, d, minH = n;
for (int i = 0; i < n; i++)
{
if (cap[idx][i] - flow[idx][i] > 0)
{
if (h[idx] == h[i] + 1)
{
d = sap(i, min(l, cap[idx][i] - flow[idx][i]));
flow[idx][i] += d;
flow[i][idx] -= d;
l -= d;
if (h[source] == n || l == 0) return maxCap - l;
}
minH = min(minH, h[i] + 1);
}
}
if (l == maxCap)
{
vh[h[idx]]--;
vh[minH]++;
if (vh[h[idx]] == 0)
h[source] = n;
h[idx] = minH;
}
return maxCap - l;
}
int main ()
{
int n,m,u,v,p;
int src,des;
int sum;
while (scanf("%d %d",&n,&m)!=EOF)
{
ep = 0;
sum=0;
src = 0;
des = n + 1;
memset (head,-1,sizeof(head));
for(int i=1;i<=n;i++)
{
scanf("%d",&p);
if(p>0)
{
addedge(src,i,p);
sum+=p;
}
else
addedge(i,des,-p);
}
for (int i=1; i<=m; i++)
{
scanf("%d%d",&u,&v);
addedge(u,v,inf);
}
int max_flow=sap(src,des,n + 2);;
printf("%d\n",sum-max_flow);
}
return 0;
}
int main()
{
init();
sap();
solve();
return 0;
}
void work()
{
build_map();
int res=0;
v[S]=T;
while(h[S]<T) res+=sap(S,inf);
printf("%d\n",lizard_tot-res);
}
int main() {
while (scanf("%d%d", &m, &n) != EOF) {
init();
for (int i = 0; i < m; ++i) {
scanf("%d%d%d", &a, &b, &x);
insert1(a, b, x);
}
printf("%d\n", sap(1,n));
}
}
int max_flow_graph::max_flow(int source, int sink) {
std::fill(gap, gap + isize, 0);
std::fill(lvl, lvl + isize, 0);
gap[0] = isize;
int ret = 0;
while (lvl[source] < isize) {
ret += sap(source, INT_MAX, source, sink); //idk why this even exists
}
return ret;
}
int maxFlow()
{
vh[0]=n;
flowSum=0;
while(gap[1]<n)
{
flag=false;
minCap=INF;
sap(org);
}
return flowSum;
}
// ----------------------------------------------
int sap(int v,int flow){
if(v==T)return flow;
int rec=0;
for(edge *p=d[v];p;p=p->next)if(h[v]==h[p->t]+1&&p->f){
int ret=sap(p->t,min(flow-rec,p->f));
p->f-=ret;p->pair->f+=ret;d[v]=p;
if((rec+=ret)==flow)return flow;
}
d[v]=head[v];
if(!(--gap[h[v]]))h[S]=T;
gap[++h[v]]++;
return rec;
}
void work()
{
int maxl=oo;
s=0,t=n+1;
for(int i=1; i<=k; ++i)
spfa(i);
// for(int i=1;i<=n;++i) for(int j=1;j<=n;++j) printf("%d %d %d\n",i,j,f[i][j]);
// for(int i=1;i<=n;++i) for(int j=1;j<=n;++j) if(f[i][j]<1000000) maxl=max(maxl,f[i][j]);
int left=0,right=maxl,ans,mid;
while(left<right-1)
{
mid=left+right>>1;
if(sap(mid)) right=mid;
else left=mid;
}
while(sap(right))
{
ans=right;
--right;
}
printf("%d\n",ans);
}
int solve(int source, int sink)
{
if (source == sink) return inf;
this->sink = sink;
this->source = source;
memset(flow, 0, sizeof(flow));
memset(h, 0, sizeof(h));
memset(vh, 0, sizeof(vh));
int ans = 0;
while (h[source] != n)
ans += sap(source, inf);
return ans;
}
int sap(int x,int flow)
{
if(x==T) return flow;
int res=0;
for(int i=0;i<=T;i++)
if(g[x][i] && h[x]==h[i]+1)
{
int t=sap(i,min(g[x][i],flow-res));
g[x][i]-=t; g[i][x]+=t;
if((res+=t)==flow) return res;
if(h[S]>=T) return res;
}
if(!(--v[h[x]])) h[S]=T;
++v[++h[x]];
return res;
}
int main()
{
int u,v,len;
int i,m;
while(scanf("%d%d",&m,&n)!=EOF)
{
init();
for(i=0;i<m;i++)
{
scanf("%d%d%d",&u,&v,&len);
add(u,v,len);
}
printf("%d\n",sap(1,n));
}
return 0;
}
void solve() {
n = id_col + id_row + 2;
int s = n - 1, t = n;
init();
for(int i = 0 ; i < nn ;i++)
for(int f = 0 ; f < m;f++)
if(true == white[i][f]) {
pos[i][f] = size;
add(getcol(i,f),getrow(i,f) + id_col,8);
}
for(int i = 1;i <= id_col ;i++)
add(s,i,flow_col[i]);
for(int i = 1;i <= id_row; i++)
add(id_col+i, t, flow_row[i]);
sap(s,t);
ans();
}
void solve()
{
int64 max = 200000000000ll;
int64 high = max;
int64 low = 0;
int64 mid;
int res;
while(low < high)
{
mid = (low + high) / 2;
build(mid);
res = sap();
if(res >= sum) high = mid;
else low = mid + 1;
}
printf("%lld\n", low == max ? -1 : low);
}
void solve()
{
int flag, i;
flag = 1;
for(i = 1;i <= num; i++)
{
memset(flow, 0, sizeof(flow));
if(sap(0, i * 2 - 1) == sum)
{
if(flag) printf("%d", i - 1);
else printf(" %d", i - 1);
flag = 0;
}
}
if(flag == 0) printf("\n");
else printf("-1\n");
}
int solve() {
n = nn+mm+2;
int s = n-1;
int t = n;
init();
for(int i = 0 ;i < nn;i++) {
for(int f = 0;f < mm;f++) {
int dis = (guest[i][0] - umb[f][0])*(guest[i][0] - umb[f][0]) + (guest[i][1] - umb[f][1])*(guest[i][1] - umb[f][1]);
if(tt * tt * guest[i][2] * guest[i][2] >= dis)
add(1+i,nn+1+f,1);
}
}
for(int i = 1;i <= nn;i++)
add(s,i,1);
for(int i = nn+1;i <= nn+mm;i++)
add(i,t,1);
return sap(s,t);
}
int main()
{
int u,v;
int tem,sum,s,t;
string ch,ch2;
int f,i,cas;
scanf("%d",&cas);
for(i=0;i<cas;i++)
{
init();
mp.clear();
ji=0;
n=802;
s=801;
t=802;
scanf("%d",&tem);
for(f=0;f<tem;f++)
{
cin>>ch;
u=id(ch);
add(s,u,1);
}
scanf("%d",&sum);
for(f=0;f<sum;f++)
{
cin>>ch>>ch2;
u=id(ch2);
add(u,t,1);
}
scanf("%d",&tem);
for(f=0;f<tem;f++)
{
cin>>ch>>ch2;
u=id(ch);
v=id(ch2);
add(v,u,INF);
}
if(0 != i)
printf("\n");
printf("%d\n",sum-sap(s,t));
}
return 0;
}
void sap(int pos)
{
if(pos==snk)
{
flowSum+=minCap;
flag=true;
return;
}
int i;
int minGap=n-1;
int tmpCap=minCap;
for(i=1;i<=n;i++)
if(cap[pos][i])
{
if(gap[i]+1==gap[pos])
{
if(cap[pos][i]<minCap)
minCap=cap[pos][i];
sap(i);
if(gap[1]>=n)return;
if(flag)break;
minCap=tmpCap;
}
if(gap[i]<minGap)
minGap=gap[i];
}
if(flag)
{
cap[pos][i]-=minCap;
cap[i][pos]+=minCap;
}
else
{
vh[gap[pos]]--;
if(vh[gap[pos]]==0)gap[1]=n;
gap[pos]=minGap+1;
vh[gap[pos]]++;
}
}
void ScreenLayoutManager::AdjustToSafeAreaProportional( Vec2& p, Vec2& s, const float assetAspect,
const EUIDRAWHORIZONTAL eUIDrawHorizontal,
const EUIDRAWVERTICAL eUIDrawVertical,
const EUIDRAWHORIZONTAL eUIDrawHorizontalDocking,
const EUIDRAWVERTICAL eUIDrawVerticalDocking ) const
{
// Get the canvas aspect ratio
const float canvasAspect = GetTagetSpaceAspect();
//-----------------------------------------------
// Get final asset size(w,h) in proportional space.
s = GetAssetSizeAsProportionOfScreen( assetAspect, canvasAspect, s );
//-----------------------------------------------
// Get
// at this point the p is at still the (center,left),
// (top,left) or (bottom,right) of the asset.
// Adjust canvas for borders
if( !(m_flags & eSLO_DoNotAdaptToSafeArea) )
{
p = ScaleProportionalPositionInToSafeArea( p );
}
// Get the position of the pivot p in screen space
// when aligned/docked to the screen.
Vec2 sap(1.0f,1.0f);
if( !(m_flags & eSLO_DoNotAdaptToSafeArea) )
{
sap = GetSafeAreaScreenProportion(m_curSafeAreaID);
}
AlignToScreen( &p.x, &p.y, p.x, p.y, sap.x, sap.y, eUIDrawHorizontalDocking, eUIDrawVerticalDocking );
// If we have a size get the TL point of the asset
// after applying the align flags to the asset.
// i.e. in the asset is centered about it's pivot
// then the TL === p-s/2
AlignAroundPivot( &p.x, &p.y, p.x, p.y, s.x, s.y, eUIDrawHorizontal, eUIDrawVertical );
}
int check(int round)
{
int s,t,i,f;
n = nn + 2*mm +2;
s = n-1;
t = s+1;
init();
for(i = 1;i<=nn;i++)
add(s,i,round);
for(i = nn+1;i <= nn+mm;i++)
add(i,i+mm,k);
for(i = nn+mm+1;i<=nn+mm+mm;i++)
add(i,t,round);
for(i=1;i<=nn;i++)
for(f=1;f<=mm;f++)
if(1 == good[i][f])
add(i,f+nn+mm,1);
else
add(i,f+nn,1);
if(nn*round == sap(s,t))
return 1;
return 0;
}
int max_flow_graph::sap(int pos, int flow, int source, int sink) {
if (pos == sink) {
return flow;
}
int flow_left = flow;
for (int a = head[pos]; a != -1; a = edges[a].n) {
if (edges[a].c && lvl[edges[a].v] + 1 == lvl[pos]) {
int cf = sap(edges[a].v, std::min(edges[a].c, flow_left), source, sink);
flow_left -= cf;
edges[a].c -= cf;
edges[a ^ 1].c += cf;
if (lvl[source] == isize || flow_left == 0) {
return flow - flow_left;
}
}
}
int min_child = isize;
for (int a = head[pos]; a != -1; a = edges[a].n) {
if (edges[a].c) {
min_child = std::min(min_child, lvl[edges[a].v]);
}
}
if (flow == flow_left) {
gap[lvl[pos]]--;
if (gap[lvl[pos]] == 0) {
lvl[source] = isize;
} else {
lvl[pos] = min_child + 1;
gap[lvl[pos]]++;
}
}
return flow - flow_left;
}
int main()
{
int ttt,maxw=0;
scanf("%d",&ttt);
for(int times=1;times<=ttt;++times)
{
int tans=0;
memset(day,0,sizeof(day));
memset(d,0,sizeof(d));
memset(w,0,sizeof(w));
memset(v,0,sizeof(v));
scanf("%d",&n);
for(int i=1;i<=n;++i)
{
for(int j=1;j<=7;++j) scanf("%d",&day[i][j]);
scanf("%d%d",&d[i],&w[i]);
tans+=d[i];
maxw=maxw<w[i]?w[i]:maxw;
}
s=0,t=n+maxw*7+1;
for(int i=1;i<=n;++i)
{
v[s][i]=d[i];
for(int j=1;j<=w[i];++j)
for(int k=1;k<=7;++k)
if(day[i][k])
{
v[i][(j-1)*7+n+k]=1;
v[(j-1)*7+n+k][t]=1;
}
}
sap();
printf("%s\n",ans==tans?"Yes":"No");
}
return 0;
}
void IterativeEdgeMatcher::_updateVertexScores(VertexScoreMap& vm, EdgeScoreMap &/*em*/)
{
CostFunction cost;
if (&vm == &_vertex12Scores)
{
cost.em1 = &_edge12Scores;
cost.em2 = &_edge21Scores;
}
else
{
cost.em2 = &_edge12Scores;
cost.em1 = &_edge21Scores;
}
cost.p = _p;
// go through all vertex matches
for (VertexScoreMap::iterator it = vm.begin(); it != vm.end(); ++it)
{
ConstNetworkVertexPtr v1 = it.key();
cost.v1 = v1;
QList<ConstNetworkEdgePtr> edges1 = _getEdgesOnVertex(v1);
// Go through all the potential matching vertices
QHash<ConstNetworkVertexPtr, double>& t2 = it.value();
for (QHash<ConstNetworkVertexPtr, double>::iterator jt = t2.begin(); jt != t2.end(); ++jt)
{
Saps sap(cost);
ConstNetworkVertexPtr v2 = jt.key();
cost.v2 = v2;
QList<ConstNetworkEdgePtr> edges2 = _getEdgesOnVertex(v2);
// get all the neighboring edges for the first vertex.
for (int i1 = 0; i1 < edges1.size(); ++i1)
{
sap.addActor(&(edges1[i1]));
}
// get all the neighboring edges for the second vertex.
for (int i2 = 0; i2 < edges2.size(); ++i2)
{
sap.addTask(&(edges2[i2]));
}
// find the best match of scores between the two sets of edges
vector<Saps::ResultPair> pairing = sap.calculatePairing();
QList<double> scores;
for (size_t i = 0; i < pairing.size(); ++i)
{
if (pairing[i].actor && pairing[i].task)
{
scores.append(cost.cost(pairing[i].actor, pairing[i].task));
}
}
// aggregate the scores between the two sets of edges
double edgeScore = pow(_aggregateScores(scores), _dampening) * _scoreVertices(v1, v2);
// set this vertex pair's score to the new aggregated score.
jt.value() = edgeScore;
}
}
}
void work(){
sap();
printf("%.4lf\n",exp(1.0*ans));
}
