2019hdu多校第一题Path

题意大致为  先搜索一条最短路并找出最小割  然后在舍去这个最小割的时候使你的最短路变大  所需要的最小割总和

http://acm.hdu.edu.cn/contests/contest_showproblem.php?pid=1005&cid=848

 

首先  建图方式采用如下

const int MAXN=100005;
const int MAXM=200005;
struct graph
{
int head[MAXN];
int to[MAXM];
int next[MAXM];
int len[MAXM];
int tot;
void init()
{
tot=0;
memset(head,0xff,sizeof(head));
}
void add(int x,int y,int z)
{
to[tot]=y;
len[tot]=z;
next[tot]=head[x];
head[x]=tot++;
}
} g;

 

然后最短路最小割的板子一套就行了

 

#include 
using namespace std;
typedef long long ll;
const int maxn = 1e5+100;

int n, m;
ll dis[maxn];
bool vis[maxn];

struct Edge {
    ll cap, to, rev;
};

vector  ve[maxn], reverse_ve[maxn];//ve用来记录原本的图，reverse_ve用来记录将边反向后的图
vector  maps[maxn];//记录所有最短路径用到的边形成的新图

void init() {
    scanf("%d%d", &n, &m);
    for(int i=1;i<=n;i++) {
        ve[i].clear();
        reverse_ve[i].clear();
        maps[i].clear();
        dis[i] = LLONG_MAX/3;
        vis[i] = false;
    }
    for(int i=1;i<=m;i++) {
        ll a, b, c; scanf("%lld%lld%lld", &a, &b, &c);
        ve[a].push_back({c, b, 0});
        reverse_ve[b].push_back({c, a, 0});
    }
}

void spfa() {//得到1点到所有点的最短路径
    queue <int> qu;
    dis[1] = 0;
    qu.push(1);
    while(!qu.empty()) {
        int now = qu.front(); qu.pop();
        vis[now] = false;
        for(int i=0;i) {
            Edge e = ve[now][i];
            ll to = e.to;
            ll cap = e.cap;

            if(dis[to] > dis[now] + cap) {
                dis[to] = dis[now] + cap;
                if(!vis[to]) {
                    vis[to] = true;
                    qu.push(to);
                }
            }
        }
    }
}

void get_new_map() {//得到新图
    queue <int> qu;
    qu.push(n);
    while(!qu.empty()) {
        int now = qu.front(); qu.pop();

        for(int i=0;i) {
            int to = reverse_ve[now][i].to;
            int cap = reverse_ve[now][i].cap;

            if(dis[to] + cap == dis[now]) {
                if(!vis[to]) {
                    qu.push(to);
                    vis[to] = true;
                }
                maps[to].push_back({cap, now, maps[now].size()});
                maps[now].push_back({0, to, maps[to].size()-1});
            }
        }
    }
}


//以下是最大流的板子
ll level[maxn], iter[maxn];

void bfs(int s) {
    memset(level, -1, sizeof(level));
    queue <int> qu;

    level[s] = 0;
    qu.push(s);
    while(!qu.empty()) {
        int v = qu.front(); qu.pop();
        for(int i=0;i) {
            Edge &e = maps[v][i];
            if(e.cap > 0 && level[e.to] < 0) {
                level[e.to] = level[v] + 1;
                qu.push(e.to);
            }
        }
    }
}

ll dfs(ll v, ll t, ll f) {
    if(v == t) return f;
    for(ll &i=iter[v]; i) {
        Edge &e = maps[v][i];
        if(e.cap > 0 && level[v] < level[e.to]) {
            ll d = dfs(e.to, t, min(f, e.cap));
            if(d > 0) {
                e.cap -= d;
                maps[e.to][e.rev].cap += d;
                return d;
            }
        }
    }
    return 0;
}

ll max_flow() {
    ll flow = 0;
    while(true) {
        bfs(1);
        if(level[n] < 0) return flow;
        memset(iter, 0, sizeof(iter));
        ll f = 0;
        while(true) {
            f = dfs(1, n, LLONG_MAX/3);
            if(f <= 0) break;
            flow += f;
        }
    }
}

int main() {
//    freopen("1.in.txt", "r", stdin);
    int t; scanf("%d", &t);
    while(t--) {
        init();
        spfa();
        get_new_map();

        printf("%lld\n", max_flow());
    }
    return 0;
}