程式師世界 >> 編程語言 >> C語言 >> C++ >> 關於C++ >> There is a war (hdu 2435 最小割+枚舉)

There is a war (hdu 2435 最小割+枚舉)

編輯：關於C++

There is a war

Time Limit: 5000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 970 Accepted Submission(s): 277

Problem Description There is a sea.
There are N islands in the sea.
There are some directional bridges connecting these islands.
There is a country called Country One located in Island 1.
There is another country called Country Another located in Island N.
There is a war against Country Another, which launched by Country One.
There is a strategy which can help Country Another to defend this war by destroying the bridges for the purpose of making Island 1 and Island n disconnected.
There are some different destroying costs of the bridges.
There is a prophet in Country Another who is clever enough to find the minimum total destroying costs to achieve the strategy.
There is an architecture in Country One who is capable enough to rebuild a bridge to make it unbeatable or build a new invincible directional bridge between any two countries from the subset of island 2 to island n-1.
There is not enough time for Country One, so it can only build one new bridge, or rebuild one existing bridge before the Country Another starts destroying, or do nothing if happy.
There is a problem: Country One wants to maximize the minimum total destroying costs Country Another needed to achieve the strategy by making the best choice. Then what’s the maximum possible result?

Input There are multiple cases in this problem.
There is a line with an integer telling you the number of cases at the beginning.
The are two numbers in the first line of every case, N(4<=N<=100) and M(0<=M<=n*(n-1)/2), indicating the number of islands and the number of bridges.
There are M lines following, each one of which contains three integers a, b and c, with 1<=a, b<=N and 1<=c<=10000, meaning that there is a directional bridge from a to b with c being the destroying cost.
There are no two lines containing the same a and b.

Output There is one line with one integer for each test case, telling the maximun possible result.

Sample Input

Sample Output

Source 2008 Asia Chengdu Regional Contest Online
Recommend lcy | We have carefully selected several similar problems for you: 2433 2432 2430 2429 2431

題意：n個國家，m條有向邊，國家1要去攻打國家n，n想切斷1到n的道路來防御，切斷每條道路有一定費用，國家1有一個NB魔法，可以建一條新邊或者加固一條已有的邊，這條邊不能被n破壞，現在求最大化n國花費之和的最小值。

思路：可知就是求最小割邊集，先建圖，跑一遍最大流得ans，然後從S集到T集枚舉割邊使容量為INF，在殘留網絡中再跑網絡流並記錄最大值Max，那麼最後答案就是ans+Max。在枚舉的時候也可以直接重新建圖，這樣應該好理解一些。

代碼：

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include
#include 
#include 
#include 
#include 
#pragma comment (linker,/STACK:102400000,102400000)
#define pi acos(-1.0)
#define eps 1e-6
#define lson rt<<1,l,mid
#define rson rt<<1|1,mid+1,r
#define FRE(i,a,b)  for(i = a; i <= b; i++)
#define FREE(i,a,b) for(i = a; i >= b; i--)
#define FRL(i,a,b)  for(i = a; i < b; i++)
#define FRLL(i,a,b) for(i = a; i > b; i--)
#define mem(t, v)   memset ((t) , v, sizeof(t))
#define sf(n)       scanf(%d, &n)
#define sff(a,b)    scanf(%d %d, &a, &b)
#define sfff(a,b,c) scanf(%d %d %d, &a, &b, &c)
#define pf          printf
#define DBG         pf(Hi
)
typedef long long ll;
using namespace std;

#define INF 0x3f3f3f3f
#define mod 1000000009
const int maxn = 1005;
const int MAXN = 2005;
const int MAXM = 200010;

struct Edge
{
    int to,next,cap,flow;
}edge[MAXM],e[MAXM];

int n,m;
int tol;
int head[MAXN];
int gap[MAXN],dep[MAXN],pre[MAXN],cur[MAXN],hed[MAXN];
int S[MAXN],T[MAXN];

void init()
{
    tol=0;
    memset(head,-1,sizeof(head));
}

//加邊，單向圖三個參數，雙向圖四個參數
void addedge(int u,int v,int w,int rw=0)
{
    edge[tol].to=v; edge[tol].cap=w; edge[tol].next=head[u];
    edge[tol].flow=0; head[u]=tol++;
    edge[tol].to=u; edge[tol].cap=rw; edge[tol].next=head[v];
    edge[tol].flow=0; head[v]=tol++;
}

//輸入參數：起點，終點，點的總數
//點的編號沒有影響，只要輸入點的總數
int sap(int start,int end,int N)
{
    memset(gap,0,sizeof(gap));
    memset(dep,0,sizeof(dep));
    memcpy(cur,head,sizeof(head));
    int u=start;
    pre[u]=-1;
    gap[0]=N;
    int ans=0;
    while (dep[start]edge[i].cap-edge[i].flow)
                    Min=edge[i].cap-edge[i].flow;
            for (int i=pre[u];i!=-1;i=pre[edge[i^1].to])
            {
                edge[i].flow+=Min;
                edge[i^1].flow-=Min;
            }
            u=start;
            ans+=Min;
            continue;
        }
        bool flag=false;
        int v;
        for (int i=cur[u];i!=-1;i=edge[i].next)
        {
            v=edge[i].to;
            if (edge[i].cap-edge[i].flow && dep[v]+1==dep[u])
            {
                flag=true;
                cur[u]=pre[v]=i;
                break;
            }
        }
        if (flag)
        {
            u=v;
            continue;
        }
        int Min=N;
        for (int i=head[u];i!=-1;i=edge[i].next)
            if (edge[i].cap-edge[i].flow && dep[edge[i].to]0&&!vis[v])
            dfs(v);
    }
}

int main()
{
#ifndef ONLINE_JUDGE
    freopen(C:/Users/lyf/Desktop/IN.txt,r,stdin);
#endif
    int i,j,t,u,v,w;
    scanf(%d,&t);
    while (t--)
    {
        scanf(%d%d,&n,&m);
        init();
        for (i=0;i