USACO 4.4.2 milk6

题目：

http://ace.delos.com/usacoprob2?a=H4mXhbyi4yi&S=milk6

http://www.nocow.cn/index.php/Translate:USACO/milk6

 

Pollutant Control
Hal Burch

It's your first day in Quality Control at Merry Milk Makers, and already there's been a catastrophe: a shipment of bad milk has been sent out. Unfortunately, you didn't discover this until the milk was already into your delivery system on its way to stores. You know which grocer that milk was destined for, but there may be multiple ways for the milk to get to that store.

The delivery system is made up of a several warehouses, with trucks running from warehouse to warehouse moving milk. While the milk will be found quickly, it is important that it does not make it to the grocer, so you must shut down enough trucks to ensure that it is impossible for the milk to get to the grocer in question. Every route costs a certain amount to shut down. Find the minimum amount that must be spent to ensure the milk does not reach its destination, along with a set of trucks to shut down that achieves this goal at that cost.

PROGRAM NAME: milk6

INPUT FORMAT

Line 1:	Two space separated integers, N and M. N (2 <= N <= 32) is the number of warehouses that Merry Milk Makers has, and M (0 <= M <= 1000) is the number of trucks routes run. Warehouse 1 is actually the productional facility, while warehouse N is the grocer to which which the bad milk was destined.
Line 2..M+1:	Truck routes: three space-separated integers, Si, Ei, and Ci. Si and Ei (1 <= Si,Ei <= N) correspond to the pickup warehouse and dropoff warehouse for the truck route. Ci (0 <= Ci <= 2,000,000) is the cost of shutting down the truck route.

SAMPLE INPUT (file milk6.in)

4 5
1 3 100
3 2 50
2 4 60
1 2 40
2 3 80

OUTPUT FORMAT

The first line of the output should be two integers, C and T. C is the minimum amount which must be spent in order to ensure the our milk never reaches its destination. T is the minimum number of truck routes that you plan to shut down in order to achive this goal. The next T lines sould contain a sorted list of the indexes of the truck routes that you suggest shutting down. If there are multiple sets of truck routes that achieve the goal at minimum cost, choose one that shuts down the minimum number of routes. If there are still multiple sets, choose the one whose initial routes have the smallest index.

SAMPLE OUTPUT (file milk6.out)

60 1
3

题解：
　　这题与第五章某道题相似，那道题是删点，这道题是删边，然后那道题我很容易过了，这道题我就写疯了…………………………

　　把权值当做流量来建边，这样做一道网络流后我们便可以知道最少代价是多少了，解决第一问。

　　第二问要求边最少，解决方案是每条边的权值变为1001*v+1，这样一来对于以下这种情况：

　　便会选取1->2的边而不会选取2->3和2->4这两条边（原谅画图和鼠标的问题），于是第二问解决。（具体证明可以自行yy，这里只是给了一个例子）

　　对于第三问，要求字典序最小，考虑两种情况：
　　　　1、有割边。
　　　　2、无割边。

　　对于第一种情况，把最小字典序割边找出来即可，这个不难……………………对于第二种情况，我们从头开始枚举，每次删除一条边，如果删除该边后对流量有影响，那么说明该边为要选取的边，即做m次网络流……………………第三问解决。

　　注意：
　　　　1、写非递归的网络流，递归的T了。（这个问题有可能是我递归的写的有问题而导致的）
　　　　2、DFS的迭代加深MS不科学，不推荐。
　　　　3、64位整数。

/*
ID:zhongh1
PROB:milk6
LANG:C++
*/

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<queue>

using namespace std;

const int maxn=40;
const int maxm=2001;
const int INF=12345678912345678ll;

int s,e,d[maxn],en,n,m,l,x[maxm],y[maxm],stack[maxn];

long long ans,z[maxm];

bool use[maxm],use2[maxn];

queue<int> que;

struct edge
{
    int e;
    long long f;
    edge *op,*next;
}ed[maxm],*v[maxn],*fe[maxn],*p[maxn];

void add_edge(int s,int e,int f)
{
    en++;
    ed[en].next=v[s];v[s]=ed+en;v[s]->e=e;v[s]->f=f;
    en++;
    ed[en].next=v[e];v[e]=ed+en;v[e]->e=s;v[e]->f=0;
    v[s]->op=v[e];v[e]->op=v[s];
}

void add_edge2(int s,int e)
{
    en++;
    ed[en].next=v[s];v[s]=ed+en;v[s]->e=e;
}

bool bfs()
{
    memset(d,-1,sizeof(d));
    while (que.size())
        que.pop();
    que.push(s);
    d[s]=0;
    while (que.size())
    {
        int now=que.front();
        que.pop();
        for (edge *e=v[now];e;e=e->next)
            if (d[e->e]==-1 && e->f)
            {
                d[e->e]=d[now]+1;
                que.push(e->e);
            }
    }
    return d[e]!=-1;
}

long long dfs(int now,long long cur_flow)
{
    if (now==e) return cur_flow;
    long long rest=cur_flow;
    for (edge *e=v[now];e;e=e->next)
        if (d[e->e]==d[now]+1 && e->f)
        {
            long long new_flow=dfs(e->e,min(rest,e->f));
            e->f-=new_flow;
            e->op->f+=new_flow;
            rest-=new_flow;
        }
    return cur_flow-rest;
}

bool dfs3(int now)
{
    if (now==e) return true;
    use2[now]=true;
    for (edge *e=v[now];e;e=e->next)
        if (!use2[e->e])
        {
            if (dfs3(e->e)) return true;
        }
    return false;
}

void agument()
{
    int now,next,stop;
    long long delta;
    for (int a=s;a<=e;a++)
        p[a]=v[a];
    stack[stop=1]=s;
    while (stop>0)
    {
        now=stack[stop];
        if (now!=e)
        {
            for (;p[now];p[now]=p[now]->next)
                if ((p[now]->f) && (d[now]+1==d[next=p[now]->e])) break;
            if (p[now])
            {
                stack[++stop]=next;
                fe[stop]=p[now];
            }
            else
            {
                stop--;
                d[now]=-1;
            }
        }
        else
        {
            delta=INF;
            for (int a=stop;a>=2;a--)
                if (fe[a]->f<delta) delta=fe[a]->f;
            ans+=delta;
            for (int a=stop;a>=2;a--)
            {
                fe[a]->f-=delta;
                fe[a]->op->f+=delta;
                if (fe[a]->f==0) stop=a-1;
            }
        }
    }
}


void dinic()
{
    while (bfs())
        agument();
}

int main()
{
    freopen("milk6.in","r",stdin);
    freopen("milk6.out","w",stdout);

    scanf("%d%d",&n,&m);
    for (int a=1;a<=m;a++)
    {
        int s,e;
        long long v;
        scanf("%d%d%lld",&s,&e,&v);
        l++;
        x[l]=s;y[l]=e;z[l]=v;
        add_edge(s,e,v*1001+1);
    }
    s=1;e=n;
    dinic();
    printf("%lld %lld\n",ans / 1001,ans % 1001);
    if (ans % 1001==0)
    {
        return 0;
    }
    int cnt=0;
    for (int a=1;a<=m;a++)
        if (!use[a])
        {
            if (ans % 1001-cnt==0) break;
            en=0;
            memset(v,0,sizeof(v));
            for (int b=1;b<=m;b++)
                 if (x[a]!=x[b] || y[a]!=y[b]) add_edge2(x[b],y[b]);
            memset(use2,false,sizeof(use2));
            bool able=!dfs3(s);
            if (able)
            {
                int nowv=0;
                for (int b=1;b<=m;b++)
                    if (x[b]==x[a] && y[b]==y[a]) 
                    {
                        use[b]=true;
                        cnt++;
                        nowv+=z[b];
                    }
                if (nowv!=ans/1001)
                {
                    cnt=0;
                    for (int b=1;b<=m;b++)
                        if (x[b]==x[a] && y[b]==y[a]) use[b]=false;
                    continue;
                }
                break;
            }
        }
    en=0;
    memset(v,0,sizeof(v));
    for (int b=1;b<=m;b++)
        if (!use[b]) add_edge(x[b],y[b],z[b]);
    int nowcnt=ans%1001-cnt;
    ans=0;
    dinic();
    for (int a=1;a<=m;a++)
    {
        en=0;
        memset(v,0,sizeof(v));
        for (int b=1;b<=m;b++)
            if (!use[b] && b!=a) add_edge(x[b],y[b],z[b]);
        long long nowans=ans;
        ans=0;
        dinic();
        if (nowans-ans==z[a])
        {
            ans+=z[a];
            for (int b=1;b<=m;b++)
                if (x[b]==x[a] && y[b]==y[a])
                {
                    use[b]=true;
                    nowcnt--;
                    ans-=z[b];
                }
            if (nowcnt==0) break;
        }
        else ans=nowans;
    }
    for (int a=1;a<=m;a++)
        if (use[a]) printf("%d\n",a);

    return 0;
}