2. 程式人生 > >從最小割角度解決最大權閉合圖問題及其在二分圖形式下的優化

從最小割角度解決最大權閉合圖問題及其在二分圖形式下的優化

阿新 • • 發佈：2018-11-15

引入問題：

Kejin Game

 UVALive - 7264 

給出一張技能圖，有的技能需要先置條件才能學習，而通過氪金可以取消某一些先置條件或者直接學習某一項技能，假設學習某項技能或者氪金都需要你付出一些代價，問代價最少為多少？

這個問題我寫過了https://blog.csdn.net/baiyifeifei/article/details/83276927

解題思路

首先我們來審視某一個技能C，假設他存在先置技能A,B，那麼我們使用一些原則來構建一張圖：

假設一個技能直接習得的代價是D則在從該技能的入點向出點連線一條邊；

假如一個技能是另一個的前置技能，那麼就從前置技能的出點向待學習技能的入點連線一條邊；

源點向所有技能的入點連線一條學習該技能所需的代價。

按照上面的法則，我們就可以構建出下面這樣一張圖

假使在ss，想要學習的技能的出點之間形成一個割，那麼意味著這個技能就算被習得了。

以C為例，假設C想要脫離A這個前置的控制，那麼就需要在Va，Dva，EDac之間任意選取一條邊劃去，同理取消B的限制也是一樣的，再割裂Vc就算完全從正常學習的流程中學得了C技能了，當然也可以通過直接割裂Dvc這條邊來達到形成割的目的
 

這題的思路並不難，但是把一個點和源點之間的關係割裂作為選擇上了這個點的根據的做法提供了一種新的思路。

接著，我們來換一個問題，假設技能之間存在著如上面這個題目一樣的依賴關係。現在每個技能存在一個權重，要求你學會一些技能使他們的權重儘可能大。

而這就是我們的“最大權閉合子圖”

關於最大權閉合圖：《最小割模型在資訊學競賽中的應用》

什麼是最大權閉合子圖？

給出一張圖，圖中的點與點之間通過有向邊連線，選出一些點，保證這些選出的點的後繼點也屬於這些被選出來的點，且權值最大則是最大權閉合圖。

如何尋找最大權閉合子圖？

設立一個虛源點和一個虛匯點，所有的正權點都向虛源點連線容量為其權值的邊，所有的負權點都向匯點連線容量為權值的邊，原本有邊的點之間連線容量無限大的邊即可，最後權值之和減去這幅圖的源點與匯點之間的最大流即可。

正確性：

我們知道最大流即是最小割，而這個模型中，我們只可能從與源點還有匯點連線的點去割，而其餘的邊由於容量無限，所以並不可能割，而這種割邊的一端是源點或者匯點的割稱作為簡單割。

而可以證明的是對於一個網路N的簡單割[S,T]與圖G的閉合圖V1方案存在一個對應關係V1\cup \left \{ s \right \}=S,\overline{V1}\cup\left\{t\right\}=T

證明：

閉合圖對應簡單割：由於V1閉合，所以V1與V2之間不存在邊，s與t之間不存在邊，所以V1\cup \left \{ s \right \}，\overline{V1}\cup\left\{t\right\}之間也不存在邊，所以，其就對應著割，而本圖的所有割定為簡單割，所以閉合圖對應簡單割

簡單割對應閉合圖：由於S，T為簡單割，故S,T之間不存在邊，而s，t之間也不存在邊，故S-\left\{ s\right \},T-\left\{t \right \}之間也不存在邊，因而S-\left\{ s\right \}圖的所有後繼點（除了s,t外）必然仍然在S-\left\{ s\right \}內，T-\left\{t \right \}同理，所以簡單割對應閉合圖

這裡我們再引入設一個點集V中的權值為正的點的集合為V_{ }^{+}

最小割的流量

那麼最小割[S,T]之間的割去的最小流量就是:

c[S,T]=\sum_{v\in V_{2}^{+}}^{ }w_{v}+\sum_{v\in V_{1}^{-}}^{ }-w_{v}

ps:[S,T]表示S,T之間的連邊

證明：

[S,T]=[\left \{ s \right \},V2]\cup [V2,V1]\cup[V1,\left \{ t \right \}]

因為S，T為簡單割，所以[V2,V1]為空集

因為只有正權與V1之間有連邊，負權與V2之間有連邊

所以：

[\left \{ s \right \},V2]=[\left \{ s \right \},V_{2}^{+}]

[V1,\left \{ t \right \}]=[V_{1}^{-},\left \{ t \right \}]

所以[S,T]=[\left \{ s \right \},V_{2}^{+}]\cup[V_{1}^{-},\left \{ t \right \}]

所以c[S,T]=\sum_{v\in V_{2}^{+}}^{ }w_{v}+\sum_{v\in V_{1}^{-}}^{ }-w_{v}

得證

如何保證得到的一定是最大權的閉合圖？

最大權閉合圖的總權重為：

w(V_{1})=\sum_{v\in V_{1}^{+}}w_{v}-\sum_{v\in V_{1}^{-}}(-w_{v})

令w(V1)+c[S,T]則有

w(V_{1})+c[S,T]=\sum_{v\in V_{1}^{+}}w_{v}-\sum_{v\in V_{1}^{-}}(-w_{v})+\sum_{v\in V_{2}^{+}}^{ }w_{v}+\sum_{v\in V_{1}^{-}}^{ }-w_{v}

=\sum_{v\in V_{1}^{+}}w_{v}+\sum_{v\in V_{2}^{+}}w_{v}

=\sum_{v\in V_{ }^{+}}w_{v}

經移項，得：

ans=w(V1)=\sum_{v\in V_{ }^{+}}w_{v}-c[S,T]

所以使正權和減去最小割既是答案的最大值

帶二分圖性質的最大權閉合圖

當選擇一條邊兩端的點時視作該邊被選擇，選擇一條邊，可以獲得一個價值，選擇點則需要付出一定的代價，問如何獲得最大的價值。

例題 最大獲利 HYSBZ - 1497 

設E為邊，V為點，則問題的本質就變為：

Maximize (\sum W_{E}-\sum W_{V})

考慮到選了某條邊，那麼這條邊的點就必選，其本質就變成了一個最大權閉合圖問題，我們可以將邊也抽象為點，向其兩個端點連邊，然後在這幅圖上跑最大權閉合圖即可，複雜度為O(MaxFlow(n+m,n+m))。

考慮上面這個問題，假如原圖是一張稠密圖（就如例題），那麼這個演算法的複雜度就會變得非常糟糕了，為此我們需要作出優化。

再來看這個式子

Maximize (\sum W_{E}-\sum W_{V})

我們可以通過乘上-1來使這個問題轉化為求最小值

Minimize(\sum W_{V}-W_{E})

考慮到邊的總價值等於所有的點相連的邊的總價值減去那些已經選擇的點和不選擇的點之間的邊除去2就是選擇的邊的總價值。也就是選擇的點所連線的邊的總價值減去與不選擇的點之間的最小割/2，具體上可以看胡伯濤論文中的這幅圖：

其中藍紫色與棕色的數字是我自己標上的，其中藍紫色的為邊的價值，棕色的為與這個端點連線的邊的價值之和，黑色加粗的邊為選擇的邊，黑色虛線圓內的點（1,2,3）即是選擇的邊，我們不難發現圖中選擇的邊的總價值就是

[(21+27+12)-(1+2+8+9+7+3)]/2=15

其中(1+2+8+9+7+3)也就是紅色邊的價值之和就是已選擇的1,2,3與未選擇的4,5,6,7.8,9之間的最小割

我們用W_{VE}來表示與一點相連的所有的邊的價值總和,已經選擇的點集為V未選擇的點集為V'，那麼原式就可以表示為

\sum W_{v}-\frac{\sum W_{vx}-c[V,V_{ }^{'}]}{2}

進一步轉化，原式就變成了

\sum (W_{v}-\frac{W_{vx}}{2})+\frac{c[V,V_{'}]}{2}

為了使得原式更加整齊，所以對原式乘2，那麼原式就變成了

\sum (2W_{v}-W_{vx})+c[V,V_{'}]

因此原圖中的每個點的權值就是2W_{v}-W_{vx}，考慮最小割只能接受非負的邊權，所以要為所有的點權加上一個極大值，令為U，然後答案就是\frac{U*n-C[S,T]}{2}

可行性證明

C[S,T]=\sum_{u\in S,v\in T}c_{u,v}

=\sum_{v\in \overline{V'}}C_{s,v}+\sum_{u\in V'}C_{u,t}+\sum_{u\in V',v\in \overline{V'},(u,v)\in E } C_{u,v}

=\sum_{v\in \overline{V'}}U+\sum_{u\in V'}(U+2W_{v}-W_{vx})+\sum_{u\in V',v\in \overline{V'},(u,v)\in E} W_{E}

=U|V|+\sum_{u\in V'}(2*W_{v}-W_{vx}+\sum_{v\in \overline{V'},(u,v)\in E}W_{E})

=U|V|+\sum_{u\in V'}(2*W_{V}-\sum_{v\in V',(u,v)\in E}W_{E})

=U*n+2\sum W_V-2\sum W_E

=U*n-2(\sum W_E-\sum W_E)

=U*n-2*ans

所以ans=\frac{U*n-C[S,T]}{2}

據此我們得到上面例題的解：

首先是直接暴力建圖的超時答案：

/**************************************************************
    Problem: 1497
    User: FlyWhite
    Language: C++
    Result: Time_Limit_Exceed
****************************************************************/
 
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<queue>
#include<cstring>
#include<string>
#include<map>
using namespace std;
const int maxn=60005;
const int maxm=3e5+5;
const int inf=0x3f3f3f3f;
struct Edge{
    int to,nxt,cap,flow;
}edge[maxm];
int tol;
int head[maxn];
void init(){
    tol=2;
    memset(head,-1,sizeof(head));
}
void addedge(int u,int v,int w,int rw=0){
    edge[tol].to=v;edge[tol].cap=w;edge[tol].flow=0;
    edge[tol].nxt=head[u];head[u]=tol++;
    edge[tol].to=u;edge[tol].cap=rw;edge[tol].flow=0;
    edge[tol].nxt=head[v];head[v]=tol++;
}
int Q[maxn];
int dep[maxn],cur[maxn],sta[maxn];
bool bfs(int s,int t,int n){
    int front=0,tail=0;
    memset(dep,-1,sizeof(dep[0])*(n+1));
    dep[s]=0;
    Q[tail++]=s;
    while(front<tail){
        int u=Q[front++];
        for(int i=head[u];i!=-1;i=edge[i].nxt){
            int v=edge[i].to;
            if(edge[i].cap>edge[i].flow&&dep[v]==-1){
                dep[v]=dep[u]+1;
                if(v==t) return true;
                Q[tail++]=v;
            }
        }
    }
    return false;
}
int dinic(int s,int t,int n){
    int maxflow=0;
    while(bfs(s,t,n)){
        for(int i=0;i<n;i++) cur[i]=head[i];
        int u=s,tail=0;
        while(cur[s]!=-1){
            if(u==t){
                int tp=inf;
                for(int i=tail-1;i>=0;i--)
                {
                    tp=min(tp,edge[sta[i]].cap-edge[sta[i]].flow);
                }
                maxflow+=tp;
                for(int i=tail-1;i>=0;i--){
                    edge[sta[i]].flow+=tp;
                    edge[sta[i]^1].flow-=tp;
                    if(edge[sta[i]].cap-edge[sta[i]].flow==0) tail=i;
                }
                u=edge[sta[tail]^1].to;
            }
            else if(cur[u]!=-1&&edge[cur[u]].cap>edge[cur[u]].flow&&dep[u]+1==dep[edge[cur[u]].to]){
                sta[tail++]=cur[u];
                u=edge[cur[u]].to;
            }
            else{
                while(u!=s&&cur[u]==-1) u=edge[sta[--tail]^1].to;
                cur[u] = edge [cur[u]].nxt;
            }
        }
    }
    return maxflow;
}
int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    int ss=0,tt=n+m+1;
    init();
    for(int i=1;i<=n;i++)
    {
        int V;
        scanf("%d",&V);
        addedge(i,tt,V);
    }
    int W=0;
    for(int i=1;i<=m;i++)
    {
        int u,v,w;
        scanf("%d%d%d",&u,&v,&w);
        W+=w;
        addedge(ss,i+n,w);
        addedge(i+n,u,inf);
        addedge(i+n,v,inf);
    }
    printf("%d\n",W-dinic(ss,tt,tt+1));
}

 

下面是優化建圖之後的AC程式碼：

/**************************************************************
    Problem: 1497
    User: FlyWhite
    Language: C++
    Result: Accepted
    Time:464 ms
    Memory:7388 kb
****************************************************************/
 
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<queue>
#include<cstring>
#include<string>
#include<map>
using namespace std;
const int maxn=60005;
const int maxm=3e5+5;
const int inf=0x3f3f3f3f;
struct Edge{
    int to,nxt,cap,flow;
}edge[maxm];
int tol;
int head[maxn];
void init(){
    tol=2;
    memset(head,-1,sizeof(head));
}
void addedge(int u,int v,int w,int rw=0){
    edge[tol].to=v;edge[tol].cap=w;edge[tol].flow=0;
    edge[tol].nxt=head[u];head[u]=tol++;
    edge[tol].to=u;edge[tol].cap=rw;edge[tol].flow=0;
    edge[tol].nxt=head[v];head[v]=tol++;
}
int Q[maxn];
int dep[maxn],cur[maxn],sta[maxn];
bool bfs(int s,int t,int n){
    int front=0,tail=0;
    memset(dep,-1,sizeof(dep[0])*(n+1));
    dep[s]=0;
    Q[tail++]=s;
    while(front<tail){
        int u=Q[front++];
        for(int i=head[u];i!=-1;i=edge[i].nxt){
            int v=edge[i].to;
            if(edge[i].cap>edge[i].flow&&dep[v]==-1){
                dep[v]=dep[u]+1;
                if(v==t) return true;
                Q[tail++]=v;
            }
        }
    }
    return false;
}
int dinic(int s,int t,int n){
    int maxflow=0;
    while(bfs(s,t,n)){
        for(int i=0;i<n;i++) cur[i]=head[i];
        int u=s,tail=0;
        while(cur[s]!=-1){
            if(u==t){
                int tp=inf;
                for(int i=tail-1;i>=0;i--)
                {
                    tp=min(tp,edge[sta[i]].cap-edge[sta[i]].flow);
                }
                maxflow+=tp;
                for(int i=tail-1;i>=0;i--){
                    edge[sta[i]].flow+=tp;
                    edge[sta[i]^1].flow-=tp;
                    if(edge[sta[i]].cap-edge[sta[i]].flow==0) tail=i;
                }
                u=edge[sta[tail]^1].to;
            }
            else if(cur[u]!=-1&&edge[cur[u]].cap>edge[cur[u]].flow&&dep[u]+1==dep[edge[cur[u]].to]){
                sta[tail++]=cur[u];
                u=edge[cur[u]].to;
            }
            else{
                while(u!=s&&cur[u]==-1) u=edge[sta[--tail]^1].to;
                cur[u] = edge [cur[u]].nxt;
            }
        }
    }
    return maxflow;
}
int val[maxn]; 
int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    memset(val,0,sizeof(val));
    int U=5e6+10;
    int ss=0,tt=n+1;
    init();
    for(int i=1;i<=n;i++)
    {
        int V;
        scanf("%d",&V);
        val[i]+=2*V;
        addedge(ss,i,U);
    }
    int W=0;
    for(int i=1;i<=m;i++)
    {
        int u,v,w;
        scanf("%d%d%d",&u,&v,&w);
        W+=w;
        val[u]-=w;
        val[v]-=w;
        addedge(u,v,w);
        addedge(v,u,w);
    }
    for(int i=1;i<=n;i++)
    {
        addedge(i,tt,val[i]+U);
    }
    printf("%d\n",(n*U-dinic(ss,tt,tt+1))/2);
}

最大密度子圖

定義一個無向圖的密度為邊數|E|，除其點數|V|，即D=\frac{|E|}{|V|} ，給出一個無向圖G=(V,E)，其具有最大密度的子圖G=(V',E')稱為最大密度子圖。

我們設最大密度為Dmax那麼就可以得出下式

D_{max}\geqslant \frac{|E'|}{|V'|}

0\geqslant |E'|-D_{max}*|V'|

我們令f(D)=|E'|-D*|V'|,不難發現，當D>Dmax時，f(D)將小於0，D<Dmax時，f(D)將大於0，當D=Dmax時，f(D)=0

因此我們可以通過二分來確定D的值。接下來我們需要做的就是，在一個確定的D下maximize (f(D))

為此，我們將邊權設為1，點權設為D再去跑上述的那個二分性質的最大權閉合子圖即可。

例題： The Problem Needs 3D Arrays  UVALive - 7037 

AC程式碼（資料水，暴力建圖）

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<queue>
#include<cstring>
#include<string>
#include<vector>
#include<map>
using namespace std;
const int maxn=8005;
const double eps=1e-8;
const int maxm=1000005;
const double inf=0x3f3f3f3f;
struct Edge{
	int to,nxt;
	double cap,flow;
}edge[maxm];
int tol;
int head[maxn];
void init(){
	tol=2;
	memset(head,-1,sizeof(head));
}
void addedge(int u,int v,double w,double rw=0.0){
	edge[tol].to=v;edge[tol].cap=w;edge[tol].flow=0;
	edge[tol].nxt=head[u];head[u]=tol++;
	edge[tol].to=u;edge[tol].cap=rw;edge[tol].flow=0;
	edge[tol].nxt=head[v];head[v]=tol++;
}
int Q[maxn];
int dep[maxn];
int cur[maxn];int sta[maxn];
bool bfs(int s,int t,int n){
	int front=0,tail=0;
	memset(dep,-1,sizeof(dep[0])*(n+1));
	dep[s]=0;
	Q[tail++]=s;
	while(front<tail){
		int u=Q[front++];
		for(int i=head[u];i!=-1;i=edge[i].nxt){
			int v=edge[i].to;
			if(edge[i].cap>edge[i].flow&&dep[v]==-1){
				dep[v]=dep[u]+1;
				if(v==t) return true;
				Q[tail++]=v;
			}
		}
	}
	return false;
}
double dinic(int s,int t,int n){
	double maxflow=0.0;
	while(bfs(s,t,n)){
		for(int i=0;i<n;i++) cur[i]=head[i];
		int u=s,tail=0;
		while(cur[s]!=-1){
			if(u==t){
				double tp=inf;
				for(int i=tail-1;i>=0;i--)
				{
					tp=min(tp,edge[sta[i]].cap-edge[sta[i]].flow);
				}
				maxflow+=tp;
				for(int i=tail-1;i>=0;i--){
					edge[sta[i]].flow+=tp;
					edge[sta[i]^1].flow-=tp;
					if(edge[sta[i]].cap-edge[sta[i]].flow==0) tail=i;
				}
				u=edge[sta[tail]^1].to;
			}
			else if(cur[u]!=-1&&edge[cur[u]].cap>edge[cur[u]].flow&&dep[u]+1==dep[edge[cur[u]].to]){
				sta[tail++]=cur[u];
				u=edge[cur[u]].to;
			}
			else{
				while(u!=s&&cur[u]==-1) u=edge[sta[--tail]^1].to;
				cur[u] = edge [cur[u]].nxt;
			}
		}
	}
	return maxflow;
}
pair<int,int> Ex[10005];
int cnt;
int n;
int ss,tt;
void build(double val)
{
	init();
	ss=0,tt=cnt+n+1;
	for(int i=1;i<=cnt;i++)
	{
		addedge(ss,i,1.0);
	}
	for(int i=1;i<=n;i++) addedge(i+cnt,tt,val);
	for(int i=1;i<=cnt;i++)
	{
		addedge(i,cnt+Ex[i].first,inf);
		addedge(i,cnt+Ex[i].second,inf);
	}
}
bool check(double mid)
{
	return 1.0*cnt-dinic(ss,tt,tt+1)>=eps;
}
int arr[105];

int main()
{
	int t;
	scanf("%d",&t);
	int kace = 1;
	while(t--)
	{
		printf("Case #%d: ",kace++);
		scanf("%d",&n);
		for(int i=1;i<=n;i++)
		{
			scanf("%d",&arr[i]);
		}
		cnt=0;
		for(int i=1;i<=n;i++)
		{
			for(int j=1+i;j<=n;j++)
			{
				if(arr[j]<arr[i])
				{
					Ex[++cnt]=pair<int,int>(i,j);
				}
			}
		}
		double L=0,R=cnt;
		while(R-L>eps)
		{
			double mid=(R+L)/2;
			build(mid);
			if(check(mid)) L=mid;
			else R=mid;
		}
		printf("%.12f\n",L);
	}
}

 

相關推薦

從最小割角度解決最大權閉合圖問題及其在二分圖形式下的優化

引入問題： Kejin Game  UVALive - 7264  給出一張技能圖，有的技能需要先置條件才能學習，而通過氪金可以取消某一些先置條件或者直接學習某一項技能，假設學習某項技能或者氪金都需要你付出一些代價，問代價最少為多少？ 這個問題我寫過了https:

BZOJ 1001 狼抓兔子 (最小割轉化成最短路)

names assert urn tdi == space bool ems set 題意：中文題。 析：很容易看出是裸板的最小割，然後可能會超時，邊實在是太多了，有一種特殊的方法，可以把平面圖轉成最短路來求，也就是利用對偶圖，把原圖的而看成新圖的點，原圖的邊與兩個面相連的

最小割(zjoi2011,bzoj2229)(最小割樹)

小白在圖論課上學到了一個新的概念——最小割，下課後小白在筆記本上寫下了如下這段話： “對於一個圖，某個對圖中結點的劃分將圖中所有結點分成兩個部分，如果結點\(s,t\)不在同一個部分中，則稱這個劃分是關於\(s,t\)的割。 對於帶權圖來說，將所有頂點處在不同部分的邊的權值相加所得到的值定義為這個割的容量，而

網路流之最小割hihocoder116，最小割==最大流，點屬於的割集，最小割性質，關鍵割邊，最小割邊

點屬於的割集： 必在S割集的點: 所有由S開始bfs到達的點 必在T割集的點: 所有由T開始bfs到達的點 求一組最小割邊： 從S開始dfs，標記為true，對於一條邊，如果一端為true，另一端為fa

Codeforces 724E 最大流=最小割+dp求最小割

題意： 有n個城市，每個城市有p【i】的東西，可以在那個城市賣c【i】的東西，兩兩城市可以進行一次c的運送，只能從小的編號的往大的編號運。 問最多能賣多少貨物。 思路： 最大流：建圖，s到n個城

二分圖最小點權覆蓋 二分圖最大權獨立集 方格取數 最小割

補集 限制 成了 最小 選擇 沒有 構造 最大點權獨立集 棋盤 　　二分圖最小點權覆蓋: 　　　　每一條邊 (u, v) 都是一個限制條件, 要求 u 和 v 不能同時取得. 　　　　我們考慮先取得所有的, 然後減去最小的點權. 　　　　建立原點 S , 連向二分圖左邊的所

bzoj 1497 [NOI2006]最大獲利【最大權閉合子圖+最小割】

正數 bool string ios truct pac 我們 tdi cst 不要被5s時限和50000點數嚇倒！大膽網絡流！我一個5w級別的dinic只跑了1s+！ 看起來沒有最大權閉合子圖的特征——限制，實際上還是有的。 我們需要把中轉站看成負權點，把p看成點權，把客

BZOJ1565 NOI 2009 植物大戰僵屍 topo+最小割（最大權閉合子圖）

front 總結 algorithm str ring eof 而是 OS mat 題目鏈接：https://www.luogu.org/problemnew/show/P2805（bzoj那個實在是有點小小的辣眼睛。。。我就把洛谷的丟出來吧。。。） 題意概述：給出一張

網絡流——最小割求最大權閉合子圖

opened span pop 最大的 RM div eof 分享圖片 LV 定義 有一個有向圖，每一個點都有一個權值（可以為正或負或0），選擇一個權值和最大的子圖，使得每個點的後繼都在子圖裏面，這個子圖就叫最大權閉合子圖。 如下圖： 能選的子圖有?,{4},{3,4},

bzoj 3232 圈地遊戲 —— 01分數規劃+最小割建圖(最大權閉合子圖)

++ tar 答案 題目 zoj ems eps string sid 題目：https://www.lydsy.com/JudgeOnline/problem.php?id=3232 心煩意亂的時候調這道題真是...越調越氣，就這樣過了一晚上... 今天再認真看看，找出幾

最大權閉合子圖-最小割-網絡流

16px ems contest queue dream namespace const sin ORC 題目鏈接：這裡傳送 　　題目大意：給定一個n個數的序列，標號為1~n，有正有負，可以無數次操作：刪去一些數，條件是刪去編號為i的數同時，所有編號是i的整數倍的數都要被刪

CF1082G Petya and Graph（最小割，最大權閉合子圖)

題目連結 QWQ嚶嚶嚶 感覺是最水的一道 G G G題了 順便記錄一下第

LuoguP2762 太空飛行計劃問題(最大權閉合子圖，最小割)

題目描述 W 教授正在為國家航天中心計劃一系列的太空飛行。每次太空飛行可進行一系列商業性實驗而獲取利潤。現已確定了一個可供選擇的實驗集合E={E1，E2，…，Em}，和進行這些實驗需要使用的全部儀器的集合I={I1，I2，…In}。實驗Ej需要用到的儀器是I的子集RjÍI。配置儀器Ik的費用為ck美元。實驗

P4177 [CEOI2008]order 網絡流，最小割，最大權閉合子圖

problem pre cli www 最大 同時 oid pan org 題目鏈接 \(Click\) \(Here\) 如果沒有租用機器就是一個裸的最大權閉合子圖。現在有了租用機器應該怎麽辦呢？ 單獨拆點是不行的，因為會和直接買下的情況脫離關系，租借是和連邊直接相關的，

BZOJ 2039 人員雇傭(最小割)

dfs long pac close lld linker stack type 最小割 最小割的建圖模式一般是，先算出總收益，然後再通過網絡模型進行割邊減去部分權值。 然後我們需要思考什麽才能帶來收益，什麽才能有權值沖突。 s連向選的點，t連向不選的點，那麽收益的減少量應

hdu4289 Control --- 最小割，拆點

|| 每一個 i++ edge 最小割 += tor () string 給一個無向圖。告知敵人的起點和終點。你要在圖上某些點安排士兵。使得敵人不管從哪條路走都必須經過士兵。 每一個點安排士兵的花費不同，求最小花費。 分析： 題意可抽象為，求一些點，使得去掉這些點之

USACO 4.4.2 追查壞牛奶 oj1341 網絡流最小割問題

+= source dinic fread ati script str one color 描述 Description 你第一天接手三鹿牛奶公司就發生了一件倒黴的事情：公司不小心發送了一批有三聚氰胺的牛奶。很不幸，你發現這件事的時候，有三聚氰胺的牛奶已經進入了送貨網

【bzoj2127】happiness 網絡流最小割

targe ffffff 計算 def pre pin bre 網絡流 turn 題目描述 高一一班的座位表是個n*m的矩陣，經過一個學期的相處，每個同學和前後左右相鄰的同學互相成為了好朋友。這學期要分文理科了，每個同學對於選擇文科與理科有著自己的喜悅值，而一對好朋友如果

ZOJ 3792 Romantic Value 最小割（最小費用下最小邊數)

post algorithm tracking anti can fine ini eof clu 求最小割及最小花費 把邊權c = c*10000+1 然後跑一個最小割，則flow / 10000就是費用 flow%10000就是邊數。 且是邊數最少

【BZOJ4519】[Cqoi2016]不同的最小割 最小割樹

main href family iostream 有趣的 rip tput ans val 【BZOJ4519】[Cqoi2016]不同的最小割 Description 學過圖論的同學都知道最小割的概念：對於一個圖，某個對圖中結點的劃分將圖中所有結點分成兩個部分，