BZOJ 1266: [AHOI2006]上学路线route(最短路+最小割)

第一问最短路.第二问,先把最短路的图建出来(边(u,v)满足d[s->u]+d[v->t]+d(u,v)==最短路径长度,就在图中,可以从源点和汇点分别跑一次最短路得到每个点到源点和汇点的最短路),然后跑一遍最大流就OK了.

---------------------------------------------------------------------------------------

#include<cstdio>

#include<cstring>

#include<algorithm>

#include<vector>

#include<queue>

#include<cctype>

 

#define rep(i,n) for(int i=0;i<n;++i)

#define clr(x,c) memset(x,c,sizeof(x))

#define Rep(i,l,r) for(int i=l;i<r;++i)

 

using namespace std;

 

const int maxn=505;

const int inf=0x7fffffff;

 

struct ISAP {

struct Edge {

int from,to,cap,flow;

Edge(int u,int v,int c,int f):

from(u),to(v),cap(c),flow(f) {}

};

int s,t,n;

int d[maxn];

int cur[maxn];

int p[maxn];

int num[maxn];

vector<int> g[maxn];

vector<Edge> edges;

void init(int n) {

this->n=n;

rep(i,n) g[i].clear();

edges.clear();

}

void addEdge(int u,int v,int c) {

edges.push_back( (Edge) {u,v,c,0} );

edges.push_back( (Edge) {v,u,0,0} );

int m=edges.size();

g[u].push_back(m-2);

g[v].push_back(m-1);

}

int augment() {

int a=inf,x=t;

while(x!=s) {

Edge &e=edges[p[x]];

a=min(a,e.cap-e.flow);

x=e.from;

}

x=t;

while(x!=s) {

Edge &e=edges[p[x]];

e.flow+=a;

edges[p[x]^1].flow-=a;

x=e.from;

}

return a;

}

 

int maxFlow(int s,int t) {

this->s=s; this->t=t;

clr(d,0); clr(cur,0);

clr(num,0); num[0]=n;

int x=s,flow=0;

while(d[s]<n) {

if(x==t) {

flow+=augment();

x=s;

}

int ok=0;

Rep(i,cur[x],g[x].size()) {

Edge &e=edges[g[x][i]];

if(e.flow<e.cap && d[x]==d[e.to]+1) {

ok=1;

p[e.to]=g[x][i];

cur[x]=i;

x=e.to;

break;

}

}

if(!ok) {

int m=n-1;

rep(i,g[x].size()) {

Edge &e=edges[g[x][i]];

if(e.cap>e.flow) m=min(m,d[e.to]);

}

if(--num[d[x]]==0) break;

num[d[x]=m+1]++;

cur[x]=0;

if(x!=s) x=edges[p[x]].from;

}

}

return flow;

}

 

} isap;

struct DIJKSTRA {

struct Edge {

int from,to,dist,cost;

Edge(int u,int v,int d,int w):

from(u),to(v),dist(d),cost(w) {}

};

struct node {

int u,d;

bool operator < (const node &o) const {

return d>o.d;

}

};

vector<int> g[maxn];

vector<Edge> edges;

int d[maxn];

int n;

void init(int n) {

this->n=n;

rep(i,n) g[i].clear();

edges.clear();

}

void addEdge(int u,int v,int d,int w) {

edges.push_back( (Edge) {u,v,d,w} );

g[u].push_back(edges.size()-1);

}

int Dijkstra(int s,int t) {

rep(i,n) d[i]=inf;

priority_queue<node> q;

d[s]=0; q.push( (node) {s,0} );

while(!q.empty()) {

node x=q.top(); q.pop();

if(x.d!=d[x.u]) continue;

rep(i,g[x.u].size()) {

Edge &e=edges[g[x.u][i]];

if(d[e.to]>d[x.u]+e.dist) {

d[e.to]=d[x.u]+e.dist;

q.push( (node) {e.to,d[e.to]} );

}

}

}

return d[t];

}

} dij[2];

 

inline int read() {

char c=getchar();

int ans=0;

while(!isdigit(c)) c=getchar();

while(isdigit(c)) { (ans*=10)+=c-'0'; c=getchar(); }

return ans;

}

 

void add(int ans) {

rep(i,dij[0].edges.size()) {

DIJKSTRA::Edge &e=dij[0].edges[i];

if(dij[0].d[e.from]+dij[1].d[e.to]+e.dist==ans) {

isap.addEdge(e.from,e.to,e.cost);

}

}

}

  

int main()

{

// freopen("test.in","r",stdin);

// freopen("test.out","w",stdout);

int n,m,u,v,d,c;

n=read(); m=read();

rep(i,2) dij[i].init(n); isap.init(n);

rep(i,m) {

u=read(); v=read();

d=read(); c=read();

dij[0].addEdge(--u,--v,d,c);

dij[0].addEdge(v,u,d,c);

dij[1].addEdge(u,v,d,c);

dij[1].addEdge(v,u,d,c);

}

printf("%d ",dij[0].Dijkstra(0,n-1));

add(dij[1].Dijkstra(n-1,0));

printf("%d",isap.maxFlow(0,n-1));

return 0;

}

--------------------------------------------------------------------------------------- 

1266: [AHOI2006]上学路线route

Time Limit: 3 Sec  Memory Limit: 162 MB
Submit: 1464  Solved: 495
[Submit][Status][Discuss]

Description

可可和卡卡家住合肥市的东郊，每天上学他们都要转车多次才能到达市区西端的学校。直到有一天他们两人参加了学校的信息学奥林匹克竞赛小组才发现每天上学的乘车路线不一定是最优的。 可可：“很可能我们在上学的路途上浪费了大量的时间，让我们写一个程序来计算上学需要的最少时间吧！” 合肥市一共设有N个公交车站，不妨将它们编号为1…N的自然数，并认为可可和卡卡家住在1号汽车站附近，而他们学校在N号汽车站。市内有M条直达汽车路线，执行第i条路线的公交车往返于站点pi和qi之间，从起点到终点需要花费的时间为ti。(1<=i<=M, 1<=pi, qi<=N) 两个人坐在电脑前，根据上面的信息很快就编程算出了最优的乘车方案。然而可可忽然有了一个鬼点子，他想趁卡卡不备，在卡卡的输入数据中删去一些路线，从而让卡卡的程序得出的答案大于实际的最短时间。而对于每一条路线i事实上都有一个代价ci：删去路线的ci越大卡卡就越容易发现这个玩笑，可可想知道什么样的删除方案可以达到他的目的而让被删除的公交车路线ci之和最小。 [任务] 编写一个程序：  从输入文件中读取合肥市公交路线的信息；  计算出实际上可可和卡卡上学需要花费的最少时间；  帮助可可设计一个方案，删除输入信息中的一些公交路线，使得删除后从家到学校需要的最少时间变大，而被删除路线的ci和最小；向输出文件输出答案。

Input

输入文件中第一行有两个正整数N和M，分别表示合肥市公交车站和公交汽车路线的个数。以下M行，每行（第i行，总第(i+1)行）用四个正整数描述第i条路线：pi, qi, ti, ci；具体含义见上文描述。

Output

输出文件最多有两行。 第一行中仅有一个整数，表示从可可和卡卡家到学校需要的最短时间。 第二行输出一个整数C,表示Ci之和

Sample Input

6 7
1 2 1 3
2 6 1 5
1 3 1 1
3 4 1 1
4 6 1 1
5 6 1 2
1 5 1 4

Sample Output

2
5