现在假设受众已有 求图的所有最短路径 的前置知识
推荐阅读:白书P209 看懂最大流&最小割
今天没时间重构代码了。。。
就随便注释一下
题目呢是签到题
意思是给一个有向图
一个人要从1点走到n点
我们要阻碍他走最短路
而你堵塞一条边的代价就是这条边的长度
问最小代价
要是看懂了最小割
就知道这题几乎就是板子题
先用优先队列优化最短路,求所有最短路径的所有边
题解的方法可以学一手
采用的方法是先更新好所有点的最短距离 (题中的sp数组)
然后遍历所有边
接着如果说两个点的最短距离之差刚好是边的长度
那么这条边就是在最短路上
就是题解那个蜜汁公式的意思
for(int pos=1;pos<=n;++pos)
for(auto &e : D::G[pos])
if(sp[e.to]-sp[pos]==e.v)
I::AddEdge(pos,e.to,e.v);
上图的下面的for等价于
for(int i=0;i<G[pos].size();i++){
D::Edge e=G[pos][i];
}
学一手auto自适应类型
然后用最大流求答案。。。。
似乎就没了
#include <bits/stdc++.h>
template <class T>
bool Reduce(T &a,T const &b) {
return a>b?a=b,1:0;
}
const int XN=1e4+11;
const int INF=2e9;
const long long oo=1e18;
int n;
long long sp[XN];
namespace D {
struct Edge {
int to,v;
};
std::vector<Edge> G[XN];
//优先队列优化
void Run() {
static bool ud[XN];
std::priority_queue<std::pair<long long,int>,std::vector<std::pair<long long,int> >,std::greater<std::pair<long long,int> > > Q;//小根堆
std::fill(sp+1,sp+1+n,oo);
std::fill(ud+1,ud+1+n,0);
sp[1]=0;
Q.push(std::make_pair(0,1));
while(!Q.empty()) {
int pos=Q.top().second;Q.pop();
if(ud[pos])
continue;
ud[pos]=1;
for(auto int & e : G[pos]) {
int u=e.to;
if(Reduce(sp[u],sp[pos]+e.v))
Q.push(std::make_pair(sp[u],u));
}
}
}
}
namespace I {
//最大流求解
struct Edge {
int to,cap,v;
Edge *rev,*pre;
}*G[XN],*preArc[XN];
void AddEdge(int x,int y,int c) {
G[x]=new Edge{y,c,0,NULL,G[x]};
G[y]=new Edge{x,0,0,G[x],G[y]};
G[x]->rev=G[y];
}
int Aug() {
int d=INF;
for(int pos=n;preArc[pos];pos=preArc[pos]->rev->to)
Reduce(d,preArc[pos]->cap-preArc[pos]->v);
for(int pos=n;preArc[pos];pos=preArc[pos]->rev->to) {
preArc[pos]->v+=d;
preArc[pos]->rev->v-=d;
}
return d;
}
long long Run() {
static int num[XN],d[XN];
static Edge *cArc[XN];
std::fill(num+1,num+n,0);
std::fill(d+1,d+1+n,0);
std::copy(G+1,G+1+n,cArc+1);
num[0]=n;preArc[1]=0;
long long flow=0;
for(int pos=1;d[1]<n;) {
if(pos==n) {
flow+=Aug();
pos=1;
}
bool adv=0;
for(Edge *&e=cArc[pos];e;e=e->pre) {
int u=e->to;
if(e->cap>e->v && d[u]+1==d[pos]) {
adv=1;
preArc[pos=u]=e;
break;
}
}
if(!adv) {
if(--num[d[pos]]==0)
break;
d[pos]=n;
for(Edge *e=cArc[pos]=G[pos];e;e=e->pre)
if(e->cap>e->v)
Reduce(d[pos],d[e->to]+1);
num[d[pos]]++;
if(pos!=1)
pos=preArc[pos]->rev->to;//cArc
}
}
return flow;
}
}
int main() {
//freopen("test1.in","r",stdin);
std::ios::sync_with_stdio(0);
std::cin.tie(0);
int T;std::cin>>T;
while(T--) {
int m;std::cin>>n>>m;
for(int i=1;i<=n;++i) {
D::G[i].clear();
I::G[i]=0;
}
for(int i=1;i<=m;++i) {
int x,y,v;
std::cin>>x>>y>>v;
D::G[x].push_back({y,v});
}
D::Run();
if(sp[n]==oo)
std::cout<<0<<'\n';
else {
//蜜汁公式 求出所有最短路径边
for(int pos=1;pos<=n;++pos)
for(auto &e : D::G[pos])
if(sp[e.to]-sp[pos]==e.v)
I::AddEdge(pos,e.to,e.v);
std::cout<<I::Run()<<'\n';
}
}
return 0;
}
附上蒟蒻重写的代码
#include<bits/stdc++.h>
#define ll long long
#define MAX_V 10005
#define MAX_E 10005
using namespace std;
struct node{
int to,cost;
};
struct edge{
int to,cap,rev;
};
vector<edge> E[MAX_E];
int level[MAX_V];
int iter[MAX_V];
vector<node>G[MAX_E];//存边
const ll INF=1e18,INF2=2e9;
ll d[MAX_V];//储存最短距离
bool vis[MAX_V];//访问数组,如果还没访问就是0
int V,Ed;//点数和边数
//维护d数组
void shortest_path(int s){
priority_queue<pair<ll,int>/*储存和起始点最短距离&当前点*/,vector<pair<ll,int> >,greater<pair<ll,int> > >q;//小根堆优化
fill(d+1,d+1+V,INF);
fill(vis+1,vis+1+V,0);
d[1]=0;
q.push(make_pair(0,1));
while(!q.empty()){
int pos=q.top().second;
q.pop();
if(vis[pos]){
continue;
}
vis[pos]=1;
for(int i=0;i<G[pos].size();i++){
node e=G[pos][i];
int u=e.to;
if(d[u]>d[pos]+e.cost){
d[u]=d[pos]+e.cost;
q.push(make_pair(d[u],u));//把新状态压入队列
//cout<<"you";
}
}
}
}
//最大流模板
void add_edge(int from,int to,int cap){
E[from].push_back((edge){to,cap,E[to].size()});
E[to].push_back((edge){from,0,E[from].size()-1});
}
void bfs(int s){
memset(level,-1,sizeof(level));
queue<int>que;
level[s]=0;
que.push(s);
while(!que.empty()){
int v=que.front();
que.pop();
for(int i=0;i<E[v].size();i++){
edge &e=E[v][i];
if(e.cap>0&&level[e.to]<0){
level[e.to]=level[v]+1;
que.push(e.to);
}
}
}
}
int dfs(int v,int t,int f){
if(v==t)return f;
for(int &i=iter[v];i<E[v].size();i++){
edge &e=E[v][i];
if(e.cap>0&&level[v]<level[e.to]){
int d=dfs(e.to,t,min(f,e.cap));
if(d>0){
e.cap-=d;
E[e.to][e.rev].cap+=d;
return d;
}
}
}
return 0;
}
//注意是ll
ll max_flow(int s,int t){
ll flow=0;
for(;;){
bfs(s);
if(level[t]<0)return flow;
memset(iter,0,sizeof(iter));
int f;
while((f=dfs(s,t,INF2))>0)flow+=f;
}
}
int main(){
//freopen("02.in","r",stdin);
//freopen("02.out","w",stdout);
int t,x,y,c;
scanf("%d",&t);
while(t--){
scanf("%d%d",&V,&Ed);
for(int i=1;i<=V;i++){
vector<node>().swap(G[i]);//清空内存
vector<edge>().swap(E[i]);
}
for(int i=0;i<Ed;i++){
scanf("%d%d%d",&x,&y,&c);
node now;
now.to=y,now.cost=c;
G[x].push_back(now);
}
shortest_path(1);
if(d[V]==INF){
printf("0\n");
}else {
for(int pos=1;pos<=V;pos++){
for(int j=0;j<G[pos].size();j++){
node e=G[pos][j];
//如果一条边要到达的点和起点的最短距离之差 刚好为边的长度
if(d[e.to]-d[pos]==e.cost){
add_edge(pos,e.to,e.cost);
//cout<<"you";
}
}
}
printf("%lld\n",max_flow(1,V));//求解1到n的最小割
}
}
return 0;
}