/*
典型的最大流问题,图中点分成四列:源节点source,牛,机器,汇节点sink;
源点向所有牛的点连接容量为1的边,所有机器的点向汇节点连接容量为m的边,问题是走的最远的牛行走的路程最近,想到利用二分法:
而分出一个答案x,对于每一头牛的点,与距离他的长度小于x的机器(牛与机器距离提前用Floyd预处理)连一条边,表示该头牛能走到
对应的机器,对于这张图求最大流,若结果为牛的头数k,则该二分出的答案可取,否则不可取,二分直至取得结果。
顺便总结一下这类典型最大流问题的特征:
1、具有两个对象(牛和机器)且二者具有某种对应关系;
2、与源点、汇点相连的边往往意味着某种限制条件:如本题与源点相连容量为1意味一条线只代表一头牛,与汇点相连容量为m代表每个
机器包含不超过m头牛
*/
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
#define mem(a,x) memset(a,x,sizeof(a))
using namespace std;
const int inf = 1000000000;
const int maxn = 250;
int k,c,m,source,sink;
int dis[maxn][maxn];
struct Edge
{
int from,to,cap,flow;
};
struct Dicnic
{
int n,m,s,t;
int d[maxn],cur[maxn],vis[maxn];
vector<int>G[maxn];
vector<Edge>edges;
void AddEdge(int from,int to,int cap)
{
Edge e1 = {from,to,cap,0};
Edge e2 = {to,from,0,0};
edges.push_back(e1);
edges.push_back(e2);
int m = edges.size();
G[from].push_back(m-2);
G[to].push_back(m-1);
}
void init(int n)
{
this -> n = n;
for(int i = 0;i<=n;i++){
G[i].clear();
}
edges.clear();
}
bool BFS()
{
mem(vis,0);
queue<int>Q;
Q.push(s);
vis[s] = 1;
d[s] = 0;
while(!Q.empty()){
int x = Q.front(); Q.pop();
for(int i=0;i<G[x].size();i++){
Edge &e = edges[G[x][i]];
if(!vis[e.to]&&e.cap>e.flow){
vis[e.to] = 1;
d[e.to] = d[x] + 1;
Q.push(e.to);
}
}
}
return vis[t];
}
int DFS(int x ,int a)
{
if(x==t||a==0) return a;
int flow = 0 , f;
for(int &i = cur[x];i<G[x].size();i++){
Edge &e = edges[G[x][i]];
if(d[e.to]==d[x]+1&&(f = DFS(e.to,min(a,e.cap-e.flow)))>0){
e.flow += f;
edges[G[x][i]^1].flow -= f;
flow += f;
a -= f;
if(a==0) break;
}
}
return flow;
}
int MaxFlow(int s,int t)
{
this -> s = s; this ->t = t;
int flow = 0;
while(BFS()){
mem(cur,0);
flow += DFS(s,inf);
}
return flow;
}
};
Dicnic g;
void Floyd(int n)
{
for(int k=1;k<=n;k++){
for(int i=1;i<=n;i++){
for(int j=1;j<=n;j++){
dis[i][j] = min(dis[i][j],dis[i][k]+dis[k][j]);
}
}
}
}
bool valid(int x)
{
g.init(k+c);
for(int j = 1;j<=c;j++){
g.AddEdge(source,k + j,1);
}
for(int i = 1;i<=k;i++){
g.AddEdge(i,sink,m);
}
for(int i = 1;i<=k + c;i++){
for(int j = 1;j<=k +c ; j++){
if(i<=k&&j>k&&j<=k+c){
if(dis[i][j]<=x) g.AddEdge( j , i , 1);
}
}
}
int ret = g.MaxFlow(source,sink);
if(ret == c) return true;
return false;
}
int bsearch(int left ,int right)
{
int mid,ret = -1;
while(left <= right){
mid = left + (right - left)/2;
if(valid(mid)){
ret = mid;
right = mid - 1;
}
else{
left = mid + 1;
}
}
return ret;
}
int main()
{
while(scanf("%d %d %d",&k,&c,&m)!=EOF){
source = 0 , sink = k + c + 1;
for(int i=1;i<=k+c;i++){
for(int j = 1;j<=k+c;j++){
scanf("%d",&dis[i][j]);
if(i==j) {
dis[i][j] = 0; continue;
}
else if(dis[i][j]==0){
dis[i][j] = inf;
}
}
}
Floyd(k+c);
int ans = bsearch(1,inf);
printf("%d\n",ans);
}
return 0;
}
典型的最大流问题,图中点分成四列:源节点source,牛,机器,汇节点sink;
源点向所有牛的点连接容量为1的边,所有机器的点向汇节点连接容量为m的边,问题是走的最远的牛行走的路程最近,想到利用二分法:
而分出一个答案x,对于每一头牛的点,与距离他的长度小于x的机器(牛与机器距离提前用Floyd预处理)连一条边,表示该头牛能走到
对应的机器,对于这张图求最大流,若结果为牛的头数k,则该二分出的答案可取,否则不可取,二分直至取得结果。
顺便总结一下这类典型最大流问题的特征:
1、具有两个对象(牛和机器)且二者具有某种对应关系;
2、与源点、汇点相连的边往往意味着某种限制条件:如本题与源点相连容量为1意味一条线只代表一头牛,与汇点相连容量为m代表每个
机器包含不超过m头牛
*/
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
#define mem(a,x) memset(a,x,sizeof(a))
using namespace std;
const int inf = 1000000000;
const int maxn = 250;
int k,c,m,source,sink;
int dis[maxn][maxn];
struct Edge
{
int from,to,cap,flow;
};
struct Dicnic
{
int n,m,s,t;
int d[maxn],cur[maxn],vis[maxn];
vector<int>G[maxn];
vector<Edge>edges;
void AddEdge(int from,int to,int cap)
{
Edge e1 = {from,to,cap,0};
Edge e2 = {to,from,0,0};
edges.push_back(e1);
edges.push_back(e2);
int m = edges.size();
G[from].push_back(m-2);
G[to].push_back(m-1);
}
void init(int n)
{
this -> n = n;
for(int i = 0;i<=n;i++){
G[i].clear();
}
edges.clear();
}
bool BFS()
{
mem(vis,0);
queue<int>Q;
Q.push(s);
vis[s] = 1;
d[s] = 0;
while(!Q.empty()){
int x = Q.front(); Q.pop();
for(int i=0;i<G[x].size();i++){
Edge &e = edges[G[x][i]];
if(!vis[e.to]&&e.cap>e.flow){
vis[e.to] = 1;
d[e.to] = d[x] + 1;
Q.push(e.to);
}
}
}
return vis[t];
}
int DFS(int x ,int a)
{
if(x==t||a==0) return a;
int flow = 0 , f;
for(int &i = cur[x];i<G[x].size();i++){
Edge &e = edges[G[x][i]];
if(d[e.to]==d[x]+1&&(f = DFS(e.to,min(a,e.cap-e.flow)))>0){
e.flow += f;
edges[G[x][i]^1].flow -= f;
flow += f;
a -= f;
if(a==0) break;
}
}
return flow;
}
int MaxFlow(int s,int t)
{
this -> s = s; this ->t = t;
int flow = 0;
while(BFS()){
mem(cur,0);
flow += DFS(s,inf);
}
return flow;
}
};
Dicnic g;
void Floyd(int n)
{
for(int k=1;k<=n;k++){
for(int i=1;i<=n;i++){
for(int j=1;j<=n;j++){
dis[i][j] = min(dis[i][j],dis[i][k]+dis[k][j]);
}
}
}
}
bool valid(int x)
{
g.init(k+c);
for(int j = 1;j<=c;j++){
g.AddEdge(source,k + j,1);
}
for(int i = 1;i<=k;i++){
g.AddEdge(i,sink,m);
}
for(int i = 1;i<=k + c;i++){
for(int j = 1;j<=k +c ; j++){
if(i<=k&&j>k&&j<=k+c){
if(dis[i][j]<=x) g.AddEdge( j , i , 1);
}
}
}
int ret = g.MaxFlow(source,sink);
if(ret == c) return true;
return false;
}
int bsearch(int left ,int right)
{
int mid,ret = -1;
while(left <= right){
mid = left + (right - left)/2;
if(valid(mid)){
ret = mid;
right = mid - 1;
}
else{
left = mid + 1;
}
}
return ret;
}
int main()
{
while(scanf("%d %d %d",&k,&c,&m)!=EOF){
source = 0 , sink = k + c + 1;
for(int i=1;i<=k+c;i++){
for(int j = 1;j<=k+c;j++){
scanf("%d",&dis[i][j]);
if(i==j) {
dis[i][j] = 0; continue;
}
else if(dis[i][j]==0){
dis[i][j] = inf;
}
}
}
Floyd(k+c);
int ans = bsearch(1,inf);
printf("%d\n",ans);
}
return 0;
}