HDU 5294 Tricks Device 最短路+最小割

题意:给你一个无向图 问你 至少和至多 删除多少条边 可以使从起点到终点的最短路变长(并不一定不可到达)

思路:比赛的时候想的方法是费用流+二分 无限超时 水的不行- - 正解是先用最短路预处理出所有的最短路径 建图后求最小割即为至少删除的边数 因为删除了最小割上的边 最短路上的起点和终点就不连通了 放在原图上最短路必然增大 而原图所有边数减去最短路径上边数最少的那条路径的值就是至多删除的边数 代码写得很糟乱 懂了思想就好。。

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;

#define REP( i, a, b ) for( int i = a; i < b; i++ )
#define FOR( i, a, b ) for( int i = a; i <= b; i++ )
#define CLR( a, x ) memset( a, x, sizeof a )
#define CPY( a, x ) memcpy( a, x, sizeof a )

const int maxn = 2000 + 10;
const int maxe  = 240000 + 10;
const int INF = 1e9;

struct Edge{
          int v, c, f;
          int next;
          Edge() {}
          Edge(int v, int c, int f, int next) : v(v), c(c), f(f), next(next) {}
};

struct ISAP{
          int n, s, t;
          int num[maxn], cur[maxn], d[maxn], p[maxn];
          int Head[maxn], cntE;
          int Q[maxn], head, tail;
          Edge edge[maxe];
          void Init(int n){
                    this -> n = n;
                    cntE = 0;
                    CLR(Head, -1);
          }
          void Add(int u, int v, int c){
                    edge[cntE] = Edge(v, c, 0, Head[u]);
                    Head[u] = cntE++;
                    edge[cntE] = Edge(u, 0, 0, Head[v]);
                    Head[v] = cntE++;
          }
          void Bfs(){
                    CLR(d, -1);
                    CLR(num, 0);
                    d[t] = 0;
                    head = tail = 0;
                    Q[tail++] = t;
                    num[0] = 1;
                    while(head != tail){
                              int u = Q[head++];
                              for(int i = Head[u]; ~i; i = edge[i].next){
                                        Edge &e = edge[i];
                                        if(~d[e.v]) continue;
                                        d[e.v] = d[u] + 1;
                                        Q[tail++] = e.v;
                                        num[d[e.v]] ++;
                              }
                    }
          }
          int Maxflow(int s, int t){
                    this -> s = s;
                    this -> t = t;
                    CPY(cur, Head);
                    Bfs();
                    int flow = 0, u = p[s] = s;
                    while(d[s] < n){
                              if(u == t){
                                        int f = INF, neck;
                                        for(int i = s; i != t; i = edge[cur[i]].v){
                                                  if(f > edge[cur[i]].c - edge[cur[i]].f){
                                                            f = edge[cur[i]].c - edge[cur[i]].f;
                                                            neck = i;
                                                  }
                                        }
                                        for(int i = s; i != t; i = edge[cur[i]].v){
                                                  edge[cur[i]].f += f;
                                                  edge[cur[i]^1].f -= f;
                                        }
                                        flow += f;
                                        u = neck;
                              }
                              int ok = 0;
                              for(int i = cur[u]; ~i; i = edge[i].next){
                                        Edge &e = edge[i];
                                        if(e.c > e.f && d[e.v] + 1 == d[u]){
                                                  ok = 1;
                                                  cur[u] = i;
                                                  p[e.v] = u;
                                                  u = e.v;
                                                  break;
                                        }
                              }
                              if(!ok){
                                        int m = n - 1;
                                        if(--num[d[u]] == 0) break;
                                        for(int i = Head[u]; ~i; i = edge[i].next){
                                                  Edge &e = edge[i];
                                                  if(e.c - e.f > 0 && m > d[e.v]){
                                                            cur[u] = i;
                                                            m = d[e.v];
                                                  }
                                        }
                                        ++num[d[u] = m + 1];
                                        u = p[u];
                              }
                    }
                    return flow;
          }

}solver;

struct SPFA{
          int top, cntE, n;
          int Head[maxn], vis[maxn], cnt[maxn], STACK[maxn], dist[maxn];
          Edge edge[maxe];
          void init(int n){
                    this -> n = n;
                    CLR(Head, -1);
                    CLR(vis, 0);
                    cntE = top = 0;
          }
          void add(int u, int v, int d){
                    edge[cntE] = Edge(v, d, 0, Head[u]);
                    Head[u] = cntE++;
          }
          bool spfa(int s){
                    CLR(vis, 0);
                    CLR(cnt, 0);
                    vis[s] = cnt[s] = 1;
                    STACK[top++] = s;
                    REP(i, 0, n) dist[i] = INF;
                    dist[s] = 0;
                    while(top){
                              int u = STACK[--top];
                              vis[u] = 0;
                              for(int i = Head[u]; ~i; i = edge[i].next){
                                        int v = edge[i].v;
                                        if(dist[v] > dist[u] + edge[i].c){
                                                  dist[v] = dist[u] + edge[i].c;
                                                  if(!vis[v]){
                                                            vis[v] = 1;
                                                            STACK[top++] = v;
                                                            if(++cnt[v] > n) return false;
                                                  }
                                        }
                              }
                    }
                    return true;
          }
}Spfa, Spfa2;

int n, m;
int vis[maxn];

void bfs(){
          memset(vis, 0, sizeof(vis));
          vis[n-1] = 1;
          queue<int> Q;
          Q.push(n-1);
          while(!Q.empty()){
                    int u = Q.front(); Q.pop();
                    for(int i = Spfa.Head[u]; ~i; i = Spfa.edge[i].next){
                              int v = Spfa.edge[i].v;
                              if(Spfa.dist[v] + Spfa.edge[i].c == Spfa.dist[u]){
                                        solver.Add(u, v, 1);
                                        Spfa2.add(u, v, 1);
//                                        printf(".. %d %d\n", u+1, v+1);
                                        if(!vis[v]) Q.push(v);
                                        vis[v] = 1;
                              }
                    }
          }
          Spfa2.spfa(n-1);
          printf("%d %d\n", solver.Maxflow(n-1, 0), m - Spfa2.dist[0]);
}

void solve(){
          Spfa.init(n);
          Spfa2.init(n);
          solver.Init(n);
          REP(i, 0, m){
                    int u, v, d;
                    scanf("%d%d%d", &u, &v, &d);
                    --u; --v;
                    Spfa.add(u, v, d);
                    Spfa.add(v, u, d);
          }
          Spfa.spfa(0);
          bfs();
}

int main()
{
//          freopen("in.txt", "r", stdin);
          while(~scanf("%d%d", &n, &m)) solve();
          return 0;
}


  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值