HDU 5886 - Tower Defence(最短路+最小割)

题目

题意：
n个点，m条边，构建有权无向图
告诉你有人从n点一定会选最短路走到1，然后你是1，要在某些地方设置障碍，要求断开N。

思路：
比赛时理解出了问题，以为是使1与n不连通，即求整个图的最小割，实际上题目中要求对方一定走最短路，是要先跑最短路，根据最短路来建图，在新图上跑最小割就可以了。

#include<iostream>
#include<cstring>
#include<cstdio> 
#include<algorithm>
#include<queue>
using namespace std;
#define INF 0x3f3f3f3f
const int maxn = 1111,maxm = 11111;

struct Edge
{
    int v,w,next;
} eg[maxm*5],teg[maxm*5];

int ds[maxn];
bool vis[maxn];
int head[maxn],thead[maxn];
int n,tp,ttp,st,en;

void Add(int u,int v,int w)
{
    eg[tp].v = v;
    eg[tp].w = w;
    eg[tp].next = head[u];
    head[u] = tp++;

    eg[tp].v = u;
    eg[tp].w = 0;
    eg[tp].next = head[v];
    head[v] = tp++;
}

void add(int u,int v,int w)
{
    teg[ttp].v = v;
    teg[ttp].w = w;
    teg[ttp].next = thead[u];
    thead[u] = ttp++;
}

int dis[maxn];
int gap[maxn];
int pre[maxn];
int cur[maxn];

int isap()
{
    memset(dis,0,sizeof(dis));
    memset(gap,0,sizeof(gap));
    memset(pre,-1,sizeof(pre));
    memset(cur,-1,sizeof(cur));

    gap[0] = n;
    int u,v,flow,ans;

    flow = INF;
    u = pre[0] = 0;
    ans = 0;

    while(dis[1] < en)
    {
        for(int &i = cur[u]; i != -1; i = eg[i].next)
        {
            if(eg[i].w && dis[eg[i].v]+1 == dis[u]) break;
        }

        if(cur[u] != -1)
        {
            v = eg[cur[u]].v;
            flow = min(flow,eg[cur[u]].w);
            pre[v] = u;
            u = v;

            if(u == en)
            {
                for(; u != 0; u = pre[u])
                {
                    eg[cur[pre[u]]].w -= flow;
                    eg[cur[pre[u]]^1].w += flow;
                }

                ans += flow;
                flow = INF;
            }
        }
        else
        {
            int mn = n;
            for(int i = head[u]; i != -1; i = eg[i].next)
            {
                if(eg[i].w && dis[eg[i].v] < mn)
                {
                    mn = dis[eg[i].v];
                    cur[u] = i;
                }
            }

            if(!(--gap[dis[u]])) break;
            dis[u] = mn+1;
            gap[dis[u]]++;
            u = pre[u];
        }
    }
    return ans;
}

void bfs()
{
    queue <int> q;
    memset(vis,0,sizeof(vis));
    memset(ds,INF,sizeof(ds));
    ds[0] = 0;
    q.push(0);
    int u,v;

    while(!q.empty())
    {
        u = q.front();
        q.pop();
        vis[u] = 0;

        for(int i = thead[u]; i != -1; i = teg[i].next)
        {
            v = teg[i].v;

            if(ds[v] > ds[u]+1)
            {
                ds[v] = ds[u]+1;

                if(!vis[v])
                {
                    q.push(v);
                    vis[v] = 1;
                }
            }
        }
    }
}

int main()
{


    int t;
    int m;
    int u,v,w;

    scanf("%d",&t);

    while(t--)
    {
        scanf("%d%d",&n,&m);

        memset(head,-1,sizeof(head));
        memset(thead,-1,sizeof(thead));
        tp = ttp = 0;

        st = 0,en = n-1;

        for(int i = 0; i < m; ++i)
        {
            scanf("%d%d%d",&u,&v,&w);


            u--,v--;
            add(u,v,w);
            add(v,u,w);
        }

        bfs();

        for(int i = 0; i < n; ++i)
        {
            for(int j = thead[i]; j != -1; j = teg[j].next)
            {
                u = i;
                v = teg[j].v;
                if(ds[v] == ds[u]+1)
                {
                    //printf("%d %d\n",u,v);
                    Add(u,v,teg[j].w);
                }
            }
        }

        printf("%d\n",isap());
    }


    return 0;
}