C++博客-夜幻梦回-随笔分类-图论

poj 3680 Intervals——费用流经典构图：费用流邻接spfa，二分查找离散化值

火碳黑 — Fri, 29 Apr 2011 14:01:00 GMT

Intervals

Description

You are given N weighted open intervals. The ith interval covers (a_i, b_i) and weighs w_i. Your task is to pick some of the intervals to maximize the total weights under the limit that no point in the real axis is covered more than k times.

Input

The first line of input is the number of test case.
The first line of each test case contains two integers, N and K (1 ≤ K ≤ N ≤ 200).
The next N line each contain three integers a_i, b_i, w_i(1 ≤ a_i < b_i ≤ 100,000, 1 ≤ w_i ≤ 100,000) describing the intervals.
There is a blank line before each test case.

Output

For each test case output the maximum total weights in a separate line.

Sample Input

4

3 1
1 2 2
2 3 4
3 4 8

3 1
1 3 2
2 3 4
3 4 8

3 1
1 100000 100000
1 2 3
100 200 300

3 2
1 100000 100000
1 150 301
100 200 300

Sample Output

题意：给出一些开区间，每个区间配一个权值。
问：在区间每个点不被重叠k次能取到的最大权值。
分析：区间内每个点不能被重叠k次。则每个点可以配一个容量为k的边。设k为1，这样一段区间A包含区间B，则B的权限比A的低，因为B要选取得看看A是否被选取，如果A被选取，则A的左端点已经满了，所以B在权值小于A的话是不被选的。对其他重叠情况也是如此，这样保证了每个区间之多被重叠k次。感觉这样构图之后就成了边连通度的模型了。由于很多点可以被离散化，所以建成图的点数就少了。最多也就401个点。这个经典的构图太帅了，可惜不是自己想的。
代码：

#include <stdio.h>
#include <stdlib.h>
#include <queue>
#define maxn 1010
#define inf (1 << 28)
using namespace std;
struct Edge
{
    int u, v, c, f, w, next;
}e[210000];
int cnt;
int head[maxn], dis[maxn], visit[maxn], pos[maxn];
void addEdge(int u, int v, int c, int w)
{
    e[cnt].u = u, e[cnt].v = v, e[cnt].c = c, e[cnt].f = 0;
     e[cnt].w = w, e[cnt].next = head[u], head[u] = cnt++;
     e[cnt].u = v, e[cnt].v = u, e[cnt].c = 0, e[cnt].f = 0;
     e[cnt].w = -w, e[cnt].next = head[v], head[v] = cnt++;
}
void spfa(int s, int t, int ver)
{
    int i, j, u, v;
    for (i = 0; i <= ver; i++)
    {
        visit[i] = 0;
        dis[i] = -1;
        pos[i] = -1;
    }
    queue <int> que;
    que.push(s);
    dis[s] = 0;
    visit[s] = 1;
    while (!que.empty())
    {
        u = que.front();
        que.pop();
        visit[u] = 0;
        for (i = head[u]; i + 1; i = e[i].next)
        {
            v = e[i].v;
            if (e[i].c > e[i].f && dis[v] < dis[u] + e[i].w)
            {
                dis[v] = dis[u] + e[i].w;
                pos[v] = i;
                if (!visit[v])
                {
                    visit[v] = 1;
                    que.push(v);
                }
            }
        }
    }
}
int CostFlow(int s, int t, int ver)
{
    int i;
    int cost = 0, flow = 0, minf;
    while (1)
    {
        spfa(s, t, ver);
        if (dis[t] == -1)
        {
            break;
        }
        minf = inf;
        for (i = pos[t]; i != -1; i = pos[e[i].u])
        {
            minf = min(minf, e[i].c - e[i].f);
        }
        for (i = pos[t]; i != -1; i = pos[e[i].u])
        {
            e[i].f += minf, e[i^1].f -= minf;
        }
        flow += minf;
        cost += minf * dis[t];
    }
    return cost;
}
int interval[maxn][3], lsh[maxn];
int cmp(const void * a, const void * b)
{
    return *((int*)a) - *((int*)b);
}
int bsc(int l, int r, int x)
{
    int mid;
    while (l <= r)
    {
        mid = (l + r ) / 2;
        if (lsh[mid] < x)
        {
             l = mid + 1;
        }
        else if (lsh[mid] > x)
        {
            r = mid - 1;
        }
        else
        {
            return mid;
        }
    }

}
int main()
{
    int ca, n, k, i, j, m;
    scanf("%d", &ca);
    while (ca--)
    {
        scanf("%d%d", &n, &k);
        for (i = 0, j = 0; i < n; i++)
        {
            scanf("%d%d%d", &interval[i][0], &interval[i][1], &interval[i][2]);
            lsh[j++] = interval[i][0], lsh[j++] = interval[i][1];
        }
        qsort(lsh, j, sizeof(int), cmp);
        m = j;
        for (i = 0, j = 1; j < m; j++)
        {
            if (lsh[i] != lsh[j])
            {
                lsh[++i] = lsh[j];
            }
        }
        m = i;
        int s = 0, t = m + 1, ver = t + 1;
        int u, v;
        cnt = 0;
        for (i = 0; i <= ver; i++) head[i] = -1;
        for (i = 0; i <= m; i++)
        {
            addEdge(i, i + 1, k, 0);
        }
        for (i = 0; i < n; i++)
        {
            u = bsc(0, m, interval[i][0]) + 1;
            v = bsc(0, m, interval[i][1]) + 1;
            addEdge(u, v, 1, interval[i][2]);
        }
        int ans = CostFlow(s, t, ver);
        printf("%d\n", ans);/**/
    }
    return 0;
}

火碳黑 2011-04-29 22:01 发表评论

poj 3498 March of the Penguins——最大流

火碳黑 — Thu, 28 Apr 2011 10:00:00 GMT

March of the Penguins

Description

Somewhere near the south pole, a number of penguins are standing on a number of ice floes. Being social animals, the penguins would like to get together, all on the same floe. The penguins do not want to get wet, so they have use their limited jump distance to get together by jumping from piece to piece. However, temperatures have been high lately, and the floes are showing cracks, and they get damaged further by the force needed to jump to another floe. Fortunately the penguins are real experts on cracking ice floes, and know exactly how many times a penguin can jump off each floe before it disintegrates and disappears. Landing on an ice floe does not damage it. You have to help the penguins find all floes where they can meet.

A sample layout of ice floes with 3 penguins on them.

Input

On the first line one positive number: the number of testcases, at most 100. After that per testcase:

One line with the integer N (1 ≤ N ≤ 100) and a floating-point number D (0 ≤ D ≤ 100 000), denoting the number of ice pieces and the maximum distance a penguin can jump.
N lines, each line containing x_i, y_i, n_i and m_i, denoting for each ice piece its X and Y coordinate, the number of penguins on it and the maximum number of times a penguin can jump off this piece before it disappears (−10 000 ≤ x_i, y_i ≤ 10 000, 0 ≤ n_i ≤ 10, 1 ≤ m_i ≤ 200).

Output

Per testcase:

One line containing a space-separated list of 0-based indices of the pieces on which all penguins can meet. If no such piece exists, output a line with the single number −1.

Sample Input

Sample Output

1 2 4
-1

题意：海上有些冰块，冰块上有些企鹅，现在所有企鹅要聚在一起，企鹅都有一样的跳远距离。一个企鹅登陆冰块时，冰块不会受损，但一个企鹅跳离冰块，冰块会受损，受损度为1。给出每个冰块的坐标、能承受的受损度，还有企鹅的跳远距离。问所有企鹅最后所在的位置。
分析：每个冰块拆成两点u,u'，容量为它的受损度x，表示可以让x只企鹅跳出去。源到每个点的容量为每个冰块开始的企鹅数量，接下来如果u,v两点的距离小于等于企鹅的跳远距离，则u'到v容量为无穷，表示v可以让无数只企鹅登陆（因为登陆不受损）。然后枚举汇点。最大流......
代码：

#include <stdio.h>
#include <iostream>
#include <cmath>
#include <string.h>
using namespace std;
const int N=20010;
const int MAXE=200010;
const int inf = 1<<29;
struct Edge
{
    int v, next, w;
}edge[MAXE*8];
int head[N], pre[N], cur[N], level[N], gap[N];
int cnt;
void addedge(int u, int v, int w)
{
    edge[cnt].v = v;
    edge[cnt].w = w;
    edge[cnt].next = head[u];
    head[u] = cnt++;
    edge[cnt].v = u;
    edge[cnt].w = 0;
    edge[cnt].next = head[v];
    head[v] = cnt++;
}
int sap(int s, int t, int n)
{
    int flow = 0, aug = inf;
    int u;
    bool flag;
    for(int i = 0; i <= n; i++)
    {
        cur[i] = head[i];
        gap[i] = level[i] = 0;
    }
    gap[s] = n;
    u = pre[s] = s;
    while (level[s] < n)
    {
        flag = 0;
        for (int &j = cur[u]; j != -1; j = edge[j].next)
        {
            int v = edge[j].v;
            if (edge[j].w > 0 && level[u] == level[v] + 1)
            {
                flag = 1;
                if (edge[j].w < aug) aug = edge[j].w;
                pre[v] = u;
                u = v;
                if (u == t)
                {
                    flow += aug;
                    while (u != s)
                    {
                        u = pre[u];
                        edge[cur[u]].w -= aug;
                        edge[cur[u]^1].w += aug;
                    }
                    aug = inf;
                }
                break;
            }
        }
        if(flag)
            continue;
        int mindis = n;
        for(int j = head[u]; j != -1; j = edge[j].next)
        {
            int v = edge[j].v;
            if(edge[j].w > 0 && level[v] < mindis)
            {
                mindis = level[v];
                cur[u] = j;
            }
        }
        if((--gap[level[u]]) == 0)
            break;
        gap[level[u]=mindis+1]++;
        u = pre[u];
    }
    return flow;
}
struct P
{
    int x, y, cap, time;
}floes[110];
int redis(P& a, P& b)
{
    return (a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y);
}
void build (int s, int t, int ver, int n, double maxdis)
{
    int i, j;
    cnt = 0;
    for (i = 0; i <= ver; i++)
    {
        head[i] = -1;
    }
    for (i = 1; i <= n; i++)
    {
        addedge(s, i, floes[i].cap);
        addedge(i, i + n, floes[i].time);
    }
    for (i = 1; i <= n; i++)
    {
        for (j = 1; j <= n; j++)
        {
            if (maxdis * maxdis > (double)redis(floes[i], floes[j]))
            {
                addedge(i + n, j, inf);
            }
        }
    }
}
int main()
{
    int ca, n, sum, i, s, t, ver;
    double maxdis;
    scanf("%d", &ca);
    while (ca--)
    {
        scanf("%d%lf", &n, &maxdis);
        int s = 0, t, ver = n + n + 1;
        for (i = 1, sum = 0; i <= n; i++)
        {
            scanf("%d%d%d%d", &floes[i].x, &floes[i].y, &floes[i].cap, &floes[i].time);
            sum += floes[i].cap;
        }
        int sign;
        for (i = 1, sign = 0; i <= n; i++)
        {
            t = i;
            build (s, t, ver, n, maxdis);
            int ans = sap(s, t, ver);
            if (ans == sum)
            {
                sign = 1;
                printf("%d ", t - 1);
            }
        }
        if (!sign) printf("-1");
        printf("\n");

    }
    return 0;
}

火碳黑 2011-04-28 18:00 发表评论

poj 3308 Paratroopers——最小点权覆盖

火碳黑 — Tue, 26 Apr 2011 12:05:00 GMT

Paratroopers

Description

It is year 2500 A.D. and there is a terrible war between the forces of the Earth and the Mars. Recently, the commanders of the Earth are informed by their spies that the invaders of Mars want to land some paratroopers in the m × n grid yard of one their main weapon factories in order to destroy it. In addition, the spies informed them the row and column of the places in the yard in which each paratrooper will land. Since the paratroopers are very strong and well-organized, even one of them, if survived, can complete the mission and destroy the whole factory. As a result, the defense force of the Earth must kill all of them simultaneously after their landing.

In order to accomplish this task, the defense force wants to utilize some of their most hi-tech laser guns. They can install a gun on a row (resp. column) and by firing this gun all paratroopers landed in this row (resp. column) will die. The cost of installing a gun in the ith row (resp. column) of the grid yard is r_i (resp. c_i ) and the total cost of constructing a system firing all guns simultaneously is equal to the product of their costs. Now, your team as a high rank defense group must select the guns that can kill all paratroopers and yield minimum total cost of constructing the firing system.

Input

Input begins with a number T showing the number of test cases and then, T test cases follow. Each test case begins with a line containing three integers 1 ≤ m ≤ 50 , 1 ≤ n ≤ 50 and 1 ≤ l ≤ 500 showing the number of rows and columns of the yard and the number of paratroopers respectively. After that, a line with m positive real numbers greater or equal to 1.0 comes where the ith number is r_i and then, a line with n positive real numbers greater or equal to 1.0 comes where the ith number is c_i. Finally, l lines come each containing the row and column of a paratrooper.

Output

For each test case, your program must output the minimum total cost of constructing the firing system rounded to four digits after the fraction point.

Sample Input

1
4 4 5
2.0 7.0 5.0 2.0
1.5 2.0 2.0 8.0
1 1
2 2
3 3
4 4
1 4

Sample Output

16.0000

题目：给出一个矩阵，矩阵上会有伞兵溅落，每次可杀死某一行的所有兵或者杀死某一列的所有兵。每个行、每个列都有一个花费。
求：杀掉所有兵的最少投资花费（投资花费为被选上的花费(可以是行，可以是列)的乘积）。
分析：杀死一个兵，可通过选行或者选列，最小点权覆盖模型，每个兵拆成两个点(u,v），s->u为选择行的花费的对数，v->t为选择列的花费的对数，u->v为无穷。最大流后结果用exp(maxflow)就是最小花费。
代码：

#include <stdio.h>
#include <string.h>
#include <queue>
#include <cmath>
#include <algorithm>
#include <iostream>
#define Min(a, b) (a) < (b) ? a : b
#define Max(a, b) (a) > (b) ? a : b
using namespace std;
const int MAXN = 2005;
const int MAXM = 700000;
const double INF = 1100000000;//double
struct Edge
{
    int st, ed, next;
    double flow, cap;//double
}edge[MAXM];
int head[MAXN], level[MAXN], que[MAXN], stk[MAXN], pre[MAXN], del[MAXN], E;
void add(int u, int v, double w)
{
    edge[E].flow = 0, edge[E].cap = w, edge[E].st = u, edge[E].ed = v;
    edge[E].next = head[u], head[u] = E++;
    edge[E].flow = 0, edge[E].cap = 0, edge[E].st = v, edge[E].ed = u;
    edge[E].next = head[v], head[v] = E++;
}
int dinic_bfs(int src, int dest, int ver)
{
    int i, j;
    for (i = 0; i <= ver; i++)
    {
        level[i] = -1;
    }
    int rear = 1;
    que[0] = src, level[src] = 0;
    for (i = 0; i < rear; i++)
    {
        for (j = head[que[i]]; j != -1; j = edge[j].next)
        {
            if (level[edge[j].ed] == -1 && edge[j].cap > edge[j].flow)
            {
                level[edge[j].ed] = level[que[i]] + 1;
                que[rear++] = edge[j].ed;
            }
        }
    }
    return level[dest] >= 0;
}
double dinic_dfs(int src, int dest, int ver)//double返回值
{
    int top = 0, cur, ptr, i;
    double ret = 0, minf;//double
    for (i = 0; i <= ver; i++)
    {
        del[i] = 0;
    }
    stk[top++] = src;
    pre[src] = src;
    cur = src;
    while (top)
    {
        while (cur != dest && top)
        {
            for (i = head[cur]; i != -1; i = edge[i].next)
            {
                if (level[edge[i].ed] == level[cur] + 1 && edge[i].cap > edge[i].flow && !del[edge[i].ed])
                {
                    stk[top++] = edge[i].ed;
                    cur = edge[i].ed;
                    pre[edge[i].ed] = i;
                    break;
                }
            }
            if (i == -1)
            {
                del[cur] = 1;
                top--;
                if (top) cur = stk[top-1];
            }
        }
        if (cur == dest)
        {
            minf = INF;
            while (cur != src)
            {
                cur = pre[cur];
                minf = Min(minf, edge[cur].cap - edge[cur].flow);
                cur = edge[cur].st;
            }
            cur = dest;
            while (cur != src)
            {
                cur = pre[cur];
                edge[cur].flow += minf;
                edge[cur^1].flow -= minf;
                if (edge[cur].cap - edge[cur].flow == 0)
                {
                    ptr = edge[cur].st;
                }
                cur = edge[cur].st;
            }
            while (top > 0 && stk[top-1] != ptr) top--;
            if (top) cur = stk[top-1];
            ret += minf;
        }
    }
    return ret;
}
double Dinic(int src, int dest, int ver)//double返回值
{
    double ret = 0, t;//double
    while (dinic_bfs(src, dest, ver))//bfs
    {
        t = dinic_dfs(src, dest, ver);//dfs
        if (t) ret += t;
        else break;
    }
    return ret;
}
int main()
{
    int ca, n, m, k, i, j;
    double w;
    scanf("%d", &ca);
    while (ca--)
    {
        scanf("%d%d%d", &n, &m, &k);
        int s = 0, t = n + m + 1, ver = t + 1;
        E = 0;
        for (i = 0; i <= ver; i++)
        {
            head[i] = -1;
        }
        for (i = 1; i <= n; i++)
        {
            scanf("%lf", &w);
            add(s, i, log(w));
        }
        for (i = 1; i <= m; i++)
        {
            scanf("%lf", &w);
            add(i + n, t, log(w));
        }
        while (k--)
        {
            scanf("%d%d", &i, &j);
            add(i, j + n, INF);
        }

        double ans = Dinic(s, t, ver);
        printf("%.4f\n", exp(ans));
    }
    return 0;
}
/*
1
4 4 5
2.0 7.0 5.0 2.0
1.5 2.0 2.0 8.0
1 1
2 2
3 3
4 4
1 4
*/

火碳黑 2011-04-26 20:05 发表评论

poj 2125 Destroying The Graph——最小点权覆盖+最小割

火碳黑 — Tue, 26 Apr 2011 11:52:00 GMT

Destroying The Graph

Description

Alice and Bob play the following game. First, Alice draws some directed graph with N vertices and M arcs. After that Bob tries to destroy it. In a move he may take any vertex of the graph and remove either all arcs incoming into this vertex, or all arcs outgoing from this vertex.
Alice assigns two costs to each vertex: Wi⁺ and Wi^-. If Bob removes all arcs incoming into the i-th vertex he pays Wi⁺ dollars to Alice, and if he removes outgoing arcs he pays Wi^- dollars.
Find out what minimal sum Bob needs to remove all arcs from the graph.

Input

Input file describes the graph Alice has drawn. The first line of the input file contains N and M (1 <= N <= 100, 1 <= M <= 5000). The second line contains N integer numbers specifying Wi⁺. The third line defines Wi^- in a similar way. All costs are positive and do not exceed 10⁶ . Each of the following M lines contains two integers describing the corresponding arc of the graph. Graph may contain loops and parallel arcs.

Output

On the first line of the output file print W --- the minimal sum Bob must have to remove all arcs from the graph. On the second line print K --- the number of moves Bob needs to do it. After that print K lines that describe Bob's moves. Each line must first contain the number of the vertex and then '+' or '-' character, separated by one space. Character '+' means that Bob removes all arcs incoming into the specified vertex and '-' that Bob removes all arcs outgoing from the specified vertex.

Sample Input

Sample Output

题意：对每个点可以选择删除它的所有入边，也可以选择删除它所有出边，每个点的每种删除方法会消耗不同的钱。
问：用最少的钱删掉所有边并输出一个删除方案。
分析：对每个点有两种操作，一种是删除它所有入边，消费是x，另一种是删除它所有出边，消费是y。将每个点拆成两个点u1，u2。s到u1为删除点所有出边的花费，u2到t为删除点所有入边的花费。对图中的每条边（u，v),有u1到v2是正无穷。即一个二分图再加上源跟汇，最大流即为最小费用。
题目要求输出方案，对每个点，如果u1在割中，则u有一个删出边的操作，如果u2在割中，则u有一个删除入边的操作。
如何判断点在s临边的个还是t临边的割。在二分图里，从s能到达的最后一个点与t成一最小割，如果s是不能到达的点，则s与该点成一最小割。所以最小割不能简单的认为是流路中容量最小的边，因为会有容量最小且相等的。在二分图结构里，因为每个流路只有三条边，可能会出现s->u->v->t，而u->v是容量无穷的，所以不会成个最小割，如果s->u跟v->t容量一样小，则可认为最小割是任选一个。对于任意图，一个流路会出现多条边容量一样是最小的。这种情况下会有s->a->b->c->d->e->...->t。则第一个满流量的或者最后一个满流量的边是最小割。其实二分图的最小割也是满足这个说法。
代码：

#include <stdio.h>
#include <string.h>
#include <queue>
#include <algorithm>
#include <iostream>
#define Min(a, b) (a) < (b) ? a : b
#define Max(a, b) (a) > (b) ? a : b
using  namespace std;
const  int MAXN = 2005;
const  int MAXM = 700000;
const  int INF = 1100000000;
struct  Edge
{
    int  st, ed;
    int  next;
    int  flow;
    int cap;
}edge[MAXM];
int  head[MAXN], level[MAXN], que[MAXN], E;
void add(int u, int v, int w)
{
    edge[E].flow = 0;
    edge[E].cap = w;
    edge[E].st = u;
    edge[E].ed = v;
    edge[E].next = head[u];
    head[u] = E++;
    edge[E].flow = 0;
    edge[E].cap = 0;
    edge[E].st = v;
    edge[E].ed = u;
    edge[E].next = head[v];
    head[v] = E++;
}
int dinic_bfs(int src, int dest, int ver)
{
    int i, j;
    for (i = 0; i <= ver; i++)
    {
        level[i] = -1;
    }
    int rear = 1;
    que[0] = src; level[src] = 0;
    for(i = 0; i < rear; i++)
    {
          for(j = head[que[i]]; j != -1; j = edge[j].next)
         {
            if(level[edge[j].ed] == -1 && edge[j].cap > edge[j].flow)
            {
              level[edge[j].ed] = level[que[i]]+1;
              que[rear++] = edge[j].ed;
            }
         }
    }
    return  level[dest] >= 0;
}

int dinic_dfs(int src, int dest, int ver)
{
    int stk[MAXN], top = 0;
    int ret = 0, cur, ptr, pre[MAXN], minf, i;
    int del[MAXN];
    for (i = 0; i <= ver; i++)
    {
        del[i] = 0;
    }
    stk[top++] = src;
    pre[src] = src;
    cur = src;
    while(top)
    {
        while(cur != dest && top)
        {
            for(i = head[cur]; i != -1; i = edge[i].next)
            {
                if(level[edge[i].ed] == level[cur] + 1 && edge[i].cap > edge[i].flow  && !del[edge[i].ed])
                {
                    stk[top++] = edge[i].ed;
                    cur = edge[i].ed;
                    pre[edge[i].ed] = i;
                    break;
                }
            }
            if(i == -1)
            {
                del[cur] = 1;
                top--;
                if(top) cur = stk[top-1];
            }
        }
        if(cur == dest)
        {
            minf = INF;
            while(cur != src)
            {
                cur = pre[cur];
                if(edge[cur].cap - edge[cur].flow < minf) minf = edge[cur].cap - edge[cur].flow;
                cur = edge[cur].st;
            }
            cur = dest;
            while(cur != src)
            {
                cur = pre[cur];
                edge[cur].flow += minf;
                edge[cur^1].flow -= minf;
                if(edge[cur].cap - edge[cur].flow == 0)
                {
                     ptr = edge[cur].st;
                }
                cur = edge[cur].st;
            }
            while(top > 0&& stk[top-1] != ptr) top--;
            if(top)  cur = stk[top-1];
            ret += minf;
        }
    }
    return ret;
}
int Dinic(int src, int dest, int ver)
{
    int  ret = 0, t;
    while(dinic_bfs(src, dest, ver))
    {
        t = dinic_dfs(src, dest, ver);
        if(t) ret += t;
        else  break;
    }
    return ret;
}
int visit[MAXN];
void dfs(int u)
{
    visit[u] = 1;
    int i;
    for (i = head[u]; i != -1; i = edge[i].next)
    {
        if (!visit[edge[i].ed] && edge[i].cap > edge[i].flow)
        {
            visit[edge[i].ed] = 1;
            dfs(edge[i].ed);
        }
    }
}
int main()
{
    int n, m, i, u, v, w;
    scanf("%d%d", &n, &m);
    int s = 0, t = n + n + 1, ver = t + 1;
    E = 0;
    for (i = 0; i <= ver; i++)
    {
        head[i] = -1;
    }
    for (i = 1; i <= n; i++)
    {
        scanf("%d", &w);
        add(i + n, t, w);
    }
    for (i = 1; i <= n; i++)
    {
        scanf("%d", &w);
        add(0, i, w);
    }
    while (m--)
    {
        scanf("%d%d", &u, &v);
        add(u, v + n, INF);
    }
    int ans = Dinic(s, t, ver);
    for (i = 0; i <= ver; i++)
    {
        visit[i] = 0;
    }
    dfs(s);
    int num = 0;
    for (i = 1; i <= n; i++)
    {
        if (visit[i + n]) num++;
        if (!visit[i]) num++;
    }
    printf("%d\n%d\n", ans, num);
    for (i = 1; i <= n; i++)
    {
        if (visit[i + n])
        {
            printf("%d +\n", i);
        }
        if (!visit[i])
        {
            printf("%d -\n", i);
        }
    }
    return 0;
}
/*
3 2
2 1 1
3 1 3
2 1
3 1

3 2
3 1 1
3 1 3
2 1
3 1

3 2
3 1 1
3 1 2
2 1
3 1

3 2
3 1 1
3 1 1
2 1
3 1

2 1
1 1
1 1
1 2

*/

火碳黑 2011-04-26 19:52 发表评论

poj 3204 Ikki's Story I - Road Reconstruction——最大流最小割+残流理解

火碳黑 — Sun, 24 Apr 2011 08:11:00 GMT

Ikki's Story I - Road Reconstruction

Description

Ikki is the king of a small country – Phoenix, Phoenix is so small that there is only one city that is responsible for the production of daily goods, and uses the road network to transport the goods to the capital. Ikki finds that the biggest problem in the country is that transportation speed is too slow.

Since Ikki was an ACM/ICPC contestant before, he realized that this, indeed, is a maximum flow problem. He coded a maximum flow program and found the answer. Not satisfied with the current status of the transportation speed, he wants to increase the transportation ability of the nation. The method is relatively simple, Ikki will reconstruct some roads in this transportation network, to make those roads afford higher capacity in transportation. But unfortunately, the country of Phoenix is not so rich in GDP that there is only enough money to rebuild one road. Ikki wants to find such roads that if reconstructed, the total capacity of transportation will increase.

He thought this problem for a loooong time but cannot get it. So he gave this problem to frkstyc, who put it in this POJ Monthly contest for you to solve. Can you solve it for Ikki?

Input

The input contains exactly one test case.

The first line of the test case contains two integers N, M (N ≤ 500, M ≤ 5,000) which represents the number of cities and roads in the country, Phoenix, respectively.

M lines follow, each line contains three integers a, b, c, which means that there is a road from city a to city b with a transportation capacity of c (0 ≤ a, b < n, c ≤ 100). All the roads are directed.

Cities are numbered from 0 to n − 1, the city which can product goods is numbered 0, and the capital is numbered n − 1.

Output

You should output one line consisting of only one integer K, denoting that there are K roads, reconstructing each of which will increase the network transportation capacity.

Sample Input

2 1
0 1 1

Sample Output

题意：这个题意真坑爹。给出点跟边，问对最大流之后的每条路径中只重建一条边。使得流更大。
分析：这么说来，能被重建的边就满足最小割。但每个流路中最小割可以多个，由于题目要求每个流路只能重建一条边。所有一个流路出现两个最小割就肯定不能被重建边。如果只出现一个最小割边u,v，那最大流后，从源还可容纳更多流到u，从v还有更多流量到t，只要增加u跟v的容量，就是一个满足题意的边。所以最大流之后从s做dfs，在从t做dfs。

#include <stdio.h>
#include <string.h>
#include <queue>
#include <algorithm>
#include <iostream>
#define Min(a, b) (a) < (b) ? a : b
#define Max(a, b) (a) > (b) ? a : b
using  namespace std;
const  int MAXN = 2005;
const  int MAXM = 700000;
const  int INF = 1100000000;
struct  Edge
{
    int  st, ed;
    int  next;
    int  flow;
    int cap;
}edge[MAXM];
int  head[MAXN], level[MAXN], que[MAXN], E;
int lf[MAXN], rf[MAXN], map[MAXN][MAXN];
void add(int u, int v, int w)
{
    edge[E].flow = 0;
    edge[E].cap = w;
    edge[E].st = u;
    edge[E].ed = v;
    edge[E].next = head[u];
    head[u] = E++;
    edge[E].flow = 0;
    edge[E].cap = 0;
    edge[E].st = v;
    edge[E].ed = u;
    edge[E].next = head[v];
    head[v] = E++;
}
int dinic_bfs(int src, int dest, int ver)
{
    int i, j;
    for (i = 0; i <= ver; i++)
    {
        level[i] = -1;
    }
    int rear = 1;
    que[0] = src; level[src] = 0;
    for(i = 0; i < rear; i++)
    {
          for(j = head[que[i]]; j != -1; j = edge[j].next)
         {
            if(level[edge[j].ed] == -1 && edge[j].cap > edge[j].flow)
            {
              level[edge[j].ed] = level[que[i]]+1;
              que[rear++] = edge[j].ed;
            }
         }
    }
    return  level[dest] >= 0;
}

int dinic_dfs(int src, int dest, int ver)
{
    int stk[MAXN], top = 0;
    int ret = 0, cur, ptr, pre[MAXN], minf, i;
    int del[MAXN];
    for (i = 0; i <= ver; i++)
    {
        del[i] = 0;
    }
    stk[top++] = src;
    pre[src] = src;
    cur = src;
    while(top)
    {
        while(cur != dest && top)
        {
            for(i = head[cur]; i != -1; i = edge[i].next)
            {
                if(level[edge[i].ed] == level[cur] + 1 && edge[i].cap > edge[i].flow  && !del[edge[i].ed])
                {
                    stk[top++] = edge[i].ed;
                    cur = edge[i].ed;
                    pre[edge[i].ed] = i;
                    break;
                }
            }
            if(i == -1)
            {
                del[cur] = 1;
                top--;
                if(top) cur = stk[top-1];
            }
        }
        if(cur == dest)
        {
            minf = INF;
            while(cur != src)
            {
                cur = pre[cur];
                if(edge[cur].cap - edge[cur].flow < minf) minf = edge[cur].cap - edge[cur].flow;
                cur = edge[cur].st;
            }
            cur = dest;
            while(cur != src)
            {
                cur = pre[cur];
                edge[cur].flow += minf;
                edge[cur^1].flow -= minf;
                if(edge[cur].cap - edge[cur].flow == 0)
                {
                     ptr = edge[cur].st;
                }
                cur = edge[cur].st;
            }
            while(top > 0&& stk[top-1] != ptr) top--;
            if(top)  cur = stk[top-1];
            ret += minf;
        }
    }
    return ret;
}
int Dinic(int src, int dest, int ver)
{
    int  ret = 0, t;
    while(dinic_bfs(src, dest, ver))
    {
        t = dinic_dfs(src, dest, ver);
        if(t) ret += t;
        else  break;
    }
    return ret;
}
void dfs(int u)
{
    lf[u] = 1;
    int i;
    for (i = head[u]; i != -1; i = edge[i].next)
    {
        //表示能提供流量。这要保证每个走向t的弧有残流就可增广
        if (!lf[edge[i].ed] && edge[i].cap - edge[i].flow > 0)
        {
            dfs(edge[i].ed);
        }
    }
}
void revdfs(int u)//通过t反搜
{
    rf[u] = 1;
    int i;
    for (i = head[u]; i != -1; i = edge[i].next)
    {
        /*
        如果edge[i]是反向弧，正弧有残流才可增广
        */
        /*
        如果edge[i]是正向弧：
        1.如果edge[i]为空，这是反弧没残流，
         2.如果edge[i]不为空，则反弧一定有残流
        */
        //所以不管现在指向s的是什么弧，保证指向t的弧有残流，就可以增广
        if (!rf[edge[i].ed] && edge[i].cap - edge[i].flow >= 0 && edge[i^1].cap > edge[i^1].flow)//
        {
            revdfs(edge[i].ed);
        }
    }
}
int main()
{
    int n, m, i, j, u, v, w;

    scanf("%d%d", &n, &m);
    int s = 0, t = n - 1, ver = t + 1;
    E = 0;
    for (i = 0; i <= ver; i++)
    {
        head[i] = -1;
    }
    for (i = 0; i < n; i++)
    {
        for (j = 0; j < n; j++)
        {
            map[i][j] = -1;
        }
    }
    while (m--)
    {
        scanf("%d%d%d", &u, &v, &w);
        add(u, v, w);
        /*在这里标记出现了u到v的边。
        出现重边时，也只能有一条被重，因为这条边按题意可以被扩大最小割不再这个边上
        */
        map[u][v] = 1;
    }
    int ans, num;
    ans = Dinic(s, t, ver);
    for (i = 0; i <= ver; i++)
    {
        lf[i] = rf[i] = 0;
    }
    dfs(s), revdfs(t);
    num = 0;
    for (i = 0; i < E; i += 2)//这些都是正向弧，原图中的边。
    {
        u = edge[i].st, v = edge[i].ed;
        if (map[u][v] == 1 && lf[u] && rf[v])
        {
            num++;
            map[u][v] = -1;//被重建过后就下次不会再被重建了。
        }
    }
    printf("%d\n", num);
    return 0;
}
/*
4 4
0 1 2
1 2 1
1 2 1
2 3 2

4 4
0 1 3
1 2 1
1 2 1
2 3 3

6 6
0 1 2
1 2 1
1 3 1
2 4 1
3 4 1
4 5 2

2 1
0 1 1

2 1
0 1 0

4 3
0 1 2
2 1 2
2 3 2

*/

火碳黑 2011-04-24 16:11 发表评论

hdu 3416 Marriage Match IV——双向最短路确定最短路的边+最大流（图边连通度）

火碳黑 — Sat, 23 Apr 2011 13:19:00 GMT

摘要: Marriage Match IV Problem Description Do not sincere non-interference。Like that show, now starvae also take part in a show, but it take place between city A and B. Starvae is in city A and girl... 阅读全文

火碳黑 2011-04-23 21:19 发表评论

poj 3189 Steady Cow Assignment——二分+最大流dinic

火碳黑 — Sat, 23 Apr 2011 03:57:00 GMT

Steady Cow Assignment

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 3062		Accepted: 1060

Description

Farmer John's N (1 <= N <= 1000) cows each reside in one of B (1 <= B <= 20) barns which, of course, have limited capacity. Some cows really like their current barn, and some are not so happy.

FJ would like to rearrange the cows such that the cows are as equally happy as possible, even if that means all the cows hate their assigned barn.

Each cow gives FJ the order in which she prefers the barns. A cow's happiness with a particular assignment is her ranking of her barn. Your job is to find an assignment of cows to barns such that no barn's capacity is exceeded and the size of the range (i.e., one more than the positive difference between the the highest-ranked barn chosen and that lowest-ranked barn chosen) of barn rankings the cows give their assigned barns is as small as possible.

Input

Line 1: Two space-separated integers, N and B

Lines 2..N+1: Each line contains B space-separated integers which are exactly 1..B sorted into some order. The first integer on line i+1 is the number of the cow i's top-choice barn, the second integer on that line is the number of the i'th cow's second-choice barn, and so on.

Line N+2: B space-separated integers, respectively the capacity of the first barn, then the capacity of the second, and so on. The sum of these numbers is guaranteed to be at least N.

Output

Line 1: One integer, the size of the minumum range of barn rankings the cows give their assigned barns, including the endpoints.

Sample Input

Sample Output

Hint

Explanation of the sample:

Each cow can be assigned to her first or second choice: barn 1 gets cows 1 and 5, barn 2 gets cow 2, barn 3 gets cow 4, and barn 4 gets cows 3 and 6.

题意：fj想将牛重新分配到牛棚里，每只牛对所有牛棚的喜爱度不同，题目给出每只牛对牛棚的喜爱程度，最喜欢的排在最前。每个牛棚有容量限制。
求：分配牛，让所有牛中最高兴的跟最不高兴的差距最小。(高兴程度：分配后，牛所在的牛棚在它心中的喜爱程度)
分析：二分枚举差距，再暴力喜爱程度的起点。就形成每只牛只能选取喜爱值从x到y的牛棚，能形成最大流，则是可行解。一直下去，直到满足最大流的最小差距。用dinic的话：从小到大枚举差距，9百多ms，用二分就2百多ms。
代码：

#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <iostream>
#define Min(a, b) (a) < (b) ? a : b
#define Max(a, b) (a) > (b) ? a : b
using  namespace std;
const  int MAXN = 2005;
const  int MAXM = 210000;
const  int INF = 1100000000;
struct  Edge
{
    int  st, ed;
    int  next;
    int  flow;
    int cap;
}edge[MAXM];
int  head[MAXN], level[MAXN], que[MAXN], E;
void  add(int u, int v, int w)
{
    //printf("add %d %d %d\n", u, v, w);
    edge[E].flow = 0;
    edge[E].cap = w;
    edge[E].st = u;
    edge[E].ed = v;
    edge[E].next = head[u];
    head[u] = E++;
    edge[E].flow = 0;
    edge[E].cap = 0;
    edge[E].st = v;
    edge[E].ed = u;
    edge[E].next = head[v];
    head[v] = E++;
}
int  dinic_bfs(int src, int dest, int ver)
{
    int i, j;
    for (i = 0; i <= ver; i++)
    {
        level[i] = -1;
    }
    int rear = 1;
    que[0] = src; level[src] = 0;
    for(i = 0; i < rear; i++)
    {
          for(j = head[que[i]]; j != -1; j = edge[j].next)
         {
            if(level[edge[j].ed] == -1 && edge[j].cap > edge[j].flow)
            {
              level[edge[j].ed] = level[que[i]]+1;
              que[rear++] = edge[j].ed;
            }
         }
    }
    return  level[dest] >= 0;
}

int dinic_dfs(int src, int dest, int ver)
{
    int stk[MAXN], top = 0;
    int ret = 0, cur, ptr, pre[MAXN], minf, i;
    int del[MAXN];
    for (i = 0; i <= ver; i++)
    {
        del[i] = 0;
    }
    stk[top++] = src;
    pre[src] = src;
    cur = src;
    while(top)
    {
        while(cur != dest && top)
        {
            for(i = head[cur]; i != -1; i = edge[i].next)
            {
                if(level[edge[i].ed] == level[cur] + 1 && edge[i].cap > edge[i].flow  && !del[edge[i].ed])
                {
                    stk[top++] = edge[i].ed;
                    cur = edge[i].ed;
                    pre[edge[i].ed] = i;
                    break;
                }
            }
            if(i == -1)
            {
                del[cur] = 1;
                top--;
                if(top) cur = stk[top-1];
            }
        }
        if(cur == dest)
        {
            minf = INF;
            while(cur != src)
            {
                cur = pre[cur];
                if(edge[cur].cap - edge[cur].flow < minf) minf = edge[cur].cap - edge[cur].flow;
                cur = edge[cur].st;
            }
            cur = dest;
            while(cur != src)
            {
                cur = pre[cur];
                edge[cur].flow += minf;
                edge[cur^1].flow -= minf;
                if(edge[cur].cap - edge[cur].flow == 0)
                {
                     ptr = edge[cur].st;
                }
                cur = edge[cur].st;
            }
            while(top > 0&& stk[top-1] != ptr) top--;
            if(top)  cur = stk[top-1];
            ret += minf;
        }
    }
    return ret;
}
int Dinic(int src, int dest, int ver)
{
    int  ret = 0, t;
    while(dinic_bfs(src, dest, ver))
    {
        t = dinic_dfs(src, dest, ver);
        if(t) ret += t;
        else  break;
    }
    return ret;
}
int map[MAXN][30], vec[30];
void build (int l, int r, int n, int b)//用喜爱之在l跟r之间的边建图
{
    int s = 0, t = n + b + 1, ver = t + 1;
    E = 0;
    int i, j, x, y;
    for (i = 0; i <= ver; i++)
    {
        head[i] = -1;
    }
    for (i = 1; i <= n; i++)
    {
        for (j = l; j <= r; j++)
        {
            add(i, map[i][j] + n, INF);
        }
    }
    for (i = 1; i <= n; i++)
    {
        add(s, i, 1);
    }
    for (i = 1; i <= b; i++)
    {
        add(i + n, t, vec[i]);
    }
}
int main()
{
    int n, b, i, j;
    scanf("%d%d", &n, &b);
    for (i = 1; i <= n; i++)
    {
        for (j = 1;  j <= b; j++)
        {
            scanf("%d", &map[i][j]);
        }
    }
    for (i = 1; i <= b; i++)
    {
        scanf("%d", &vec[i]);
    }
    int s = 0, t = n + b + 1, ver = t + 1, flow, sign;
    int l = 0, r = b + 1;
    while (l < r)//枚举差距
    {
        i = (l + r) >> 1;
        for (j = 1, sign = 0; j <= b - i + 1; j++)//暴力喜爱值起点
        {
            build (j, j + i - 1, n, b);
            flow = Dinic(0, t, ver);
            if (flow == n)
            {
                sign = 1;
                break;
            }
        }
        if (sign)
        {
            r = i;
        }
        else
        {
            l = i + 1;
        }
    }
    printf("%d\n", r);
    return 0;
}
/*
2 2
1 2
1 2
2 1

6 4
1 2 3 4
2 3 1 4
4 2 3 1
3 1 2 4
1 3 4 2
1 4 2 3
2 1 3 2
*/

火碳黑 2011-04-23 11:57 发表评论

poj 3084 Panic Room——图的边连通度

火碳黑 — Fri, 22 Apr 2011 13:59:00 GMT

摘要: Panic Room Description You are the lead programmer for the Securitron 9042, the latest and greatest in home security software from Jellern Inc. (Motto: We secure your stuff so YOU can't even get ... 阅读全文

火碳黑 2011-04-22 21:59 发表评论

poj 2455 Secret Milking Machine——图的边连通度，二分边值求最大流

火碳黑 — Thu, 21 Apr 2011 13:47:00 GMT

Secret Milking Machine

Description

Farmer John is constructing a new milking machine and wishes to keep it secret as long as possible. He has hidden in it deep within his farm and needs to be able to get to the machine without being detected. He must make a total of T (1 <= T <= 200) trips to the machine during its construction. He has a secret tunnel that he uses only for the return trips.

The farm comprises N (2 <= N <= 200) landmarks (numbered 1..N) connected by P (1 <= P <= 40,000) bidirectional trails (numbered 1..P) and with a positive length that does not exceed 1,000,000. Multiple trails might join a pair of landmarks.

To minimize his chances of detection, FJ knows he cannot use any trail on the farm more than once and that he should try to use the shortest trails.

Help FJ get from the barn (landmark 1) to the secret milking machine (landmark N) a total of T times. Find the minimum possible length of the longest single trail that he will have to use, subject to the constraint that he use no trail more than once. (Note well: The goal is to minimize the length of the longest trail, not the sum of the trail lengths.)

It is guaranteed that FJ can make all T trips without reusing a trail.

Input

* Line 1: Three space-separated integers: N, P, and T

* Lines 2..P+1: Line i+1 contains three space-separated integers, A_i, B_i, and L_i, indicating that a trail connects landmark A_i to landmark B_i with length L_i.

Output

* Line 1: A single integer that is the minimum possible length of the longest segment of Farmer John's route.

Sample Input

Sample Output

Hint

Farmer John can travel trails 1 - 2 - 3 - 7 and 1 - 6 - 7. None of the trails travelled exceeds 5 units in length. It is impossible for Farmer John to travel from 1 to 7 twice without using at least one trail of length 5.

Huge input data,scanf is recommended.

题意：fj想从一个点a到另外一个点b，在每条边只走一次的情况下，走k次从a到b，使得经过的边最大的尽量小。
分析：又是二分，这个题就是图的边连通度，其每条通过流量的路径被称为弱独立轨。原图中u->v，如果是有向图，则从u到v一条容量为1的边。如果是无向图，则从u到v一条容量为1的边，从v到u一条容量为1的边。这样保证每条边只经过一个流量，而每个点可以被通关过多次，只要这个点有多个入度跟出度。就这样了，最大流。

#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <iostream>
#define Min(a, b) (a) < (b) ? a : b
#define Max(a, b) (a) > (b) ? a : b
using  namespace std;
const  int MAXN = 1005;
const  int MAXM = 210000;
const  int INF = 1100000000;
struct  Edge
{
    int  st, ed;
    int  next;
    int  flow;
    int cap;
}edge[MAXM];
int  head[MAXN], level[MAXN], que[MAXN], E;
struct List
{
    int u, v, w;
}list[40000];
void  add(int u, int v, int w)
{
    //printf("add %d %d %d\n", u, v, w);
    edge[E].flow = 0;
    edge[E].cap = w;
    edge[E].st = u;
    edge[E].ed = v;
    edge[E].next = head[u];
    head[u] = E++;
    edge[E].flow = 0;
    edge[E].cap = 0;
    edge[E].st = v;
    edge[E].ed = u;
    edge[E].next = head[v];
    head[v] = E++;
}
int  dinic_bfs(int src, int dest, int ver)
{
    int i, j;
    for (i = 0; i <= ver; i++)
    {
        level[i] = -1;
    }
    int rear = 1;
    que[0] = src; level[src] = 0;
    for(i = 0; i < rear; i++)
    {
          for(j = head[que[i]]; j != -1; j = edge[j].next)
         {
            if(level[edge[j].ed] == -1 && edge[j].cap > edge[j].flow)
            {
              level[edge[j].ed] = level[que[i]]+1;
              que[rear++] = edge[j].ed;
            }
         }
    }
    return  level[dest] >= 0;
}

int dinic_dfs(int src, int dest, int ver)
{
    int stk[MAXN], top = 0;
    int ret = 0, cur, ptr, pre[MAXN], minf, i;
    int del[MAXN];
    for (i = 0; i <= ver; i++)
    {
        del[i] = 0;
    }
    stk[top++] = src;
    pre[src] = src;
    cur = src;
    while(top)
    {
        while(cur != dest && top)
        {
            for(i = head[cur]; i != -1; i = edge[i].next)
            {
                if(level[edge[i].ed] == level[cur] + 1 && edge[i].cap > edge[i].flow  && !del[edge[i].ed])
                {
                    stk[top++] = edge[i].ed;
                    cur = edge[i].ed;
                    pre[edge[i].ed] = i;
                    break;
                }
            }
            if(i == -1)
            {
                del[cur] = 1;
                top--;
                if(top) cur = stk[top-1];
            }
        }
        if(cur == dest)
        {
            minf = INF;
            while(cur != src)
            {
                cur = pre[cur];
                if(edge[cur].cap - edge[cur].flow < minf) minf = edge[cur].cap - edge[cur].flow;
                cur = edge[cur].st;
            }
            cur = dest;
            while(cur != src)
            {
                cur = pre[cur];
                edge[cur].flow += minf;
                edge[cur^1].flow -= minf;
                if(edge[cur].cap - edge[cur].flow == 0)
                {
                     ptr = edge[cur].st;
                }
                cur = edge[cur].st;
            }
            while(top > 0&& stk[top-1] != ptr) top--;
            if(top)  cur = stk[top-1];
            ret += minf;
        }
    }
    return ret;
}
int Dinic(int src, int dest, int ver)
{
    int  ret = 0, t;
    while(dinic_bfs(src, dest, ver))
    {
        t = dinic_dfs(src, dest, ver);
        if(t) ret += t;
        else  break;
    }
    return ret;
}
void build (int length, int n, int m)
{
    E = 0;
    int i, u, v, w;
    int s = 0, t = n + 1, ver = t + 1;
    for (i = 0; i <= ver; i++)
    {
        head[i] = -1;
    }
    for (i = 0; i < m; i++)
    {
        u = list[i].u, v = list[i].v, w = list[i].w;
        if (w <= length)
        {
            add(u, v, 1);
            add(v, u, 1);
        }
    }
    add(s, 1, INF);
    add(n, t, INF);
}
int main()
{
    int n, m, k, i, max, s, t, ver, l, r, mid, flow;
    scanf("%d%d%d", &n, &m, &k);
    for (i = 0, max = 0; i < m; i++)
    {
        scanf("%d%d%d", &list[i].u, &list[i].v, &list[i].w);
        max = Max(max, list[i].w);
    }
    s = 0, t = n + 1, ver = t + 1;
    l = 0, r = max + 1;
    while (l < r)
    {
        mid = (l + r) >> 1;
        build(mid, n, m);
        flow = Dinic(s, t, ver);
        if (flow >= k)
        {
            r = mid;
        }
        else
        {
            l = mid + 1;
        }
    }
    printf("%d\n", r);
    return 0;
}
/*

*/

火碳黑 2011-04-21 21:47 发表评论

poj 2391 Ombrophobic Bovines——floyd+二分+最大流

火碳黑 — Thu, 21 Apr 2011 07:26:00 GMT

摘要: Ombrophobic Bovines Description FJ's cows really hate getting wet so much that the mere thought of getting caught in the rain makes them shake in their hooves. They have decided to put a rain sir... 阅读全文

火碳黑 2011-04-21 15:26 发表评论

poj 2112 Optimal Milking——最短路floyd+二分+最大流dinic

火碳黑 — Wed, 20 Apr 2011 12:49:00 GMT

Optimal Milking

Description

FJ has moved his K (1 <= K <= 30) milking machines out into the cow pastures among the C (1 <= C <= 200) cows. A set of paths of various lengths runs among the cows and the milking machines. The milking machine locations are named by ID numbers 1..K; the cow locations are named by ID numbers K+1..K+C.

Each milking point can "process" at most M (1 <= M <= 15) cows each day.

Write a program to find an assignment for each cow to some milking machine so that the distance the furthest-walking cow travels is minimized (and, of course, the milking machines are not overutilized). At least one legal assignment is possible for all input data sets. Cows can traverse several paths on the way to their milking machine.

Input

* Line 1: A single line with three space-separated integers: K, C, and M.

* Lines 2.. ...: Each of these K+C lines of K+C space-separated integers describes the distances between pairs of various entities. The input forms a symmetric matrix. Line 2 tells the distances from milking machine 1 to each of the other entities; line 3 tells the distances from machine 2 to each of the other entities, and so on. Distances of entities directly connected by a path are positive integers no larger than 200. Entities not directly connected by a path have a distance of 0. The distance from an entity to itself (i.e., all numbers on the diagonal) is also given as 0. To keep the input lines of reasonable length, when K+C > 15, a row is broken into successive lines of 15 numbers and a potentially shorter line to finish up a row. Each new row begins on its own line.

Output

A single line with a single integer that is the minimum possible total distance for the furthest walking cow.

Sample Input

Sample Output

2
题意：有k个牛奶机跟c头牛。他们之间有路相连，农民想让每个牛能到其中一个牛奶机，又想让最累的牛累的程度最小。
分析：本来傻傻的用费用流，但发现不对，因为每个增广路不是单纯的一个牛走的路，会包含其他牛走过的路在里面，详细另一篇关于最大流的归纳。
这个题是求牛走的最长路，那枚举ans，然后对牛到奶牛机的最短距离满足ans的连一条容量inf的边，如果最大流等于牛的数量，则ans是合法的。
二分最大流代码：

#include <stdio.h>  
#include <string.h>  
#include <algorithm>
#define Min(a, b) (a) < (b) ? a : b  
using  namespace std;  
const  int MAXN = 1005;  
const  int MAXM = 210000;  
const  int INF = 1000000000;  
struct  Edge  
{  
    int  st, ed;  
    int  next;  
    int  flow; 
    int cap; 
}edge[MAXM]; 
int  head[MAXN], level[MAXN], E, map[MAXN][MAXN];
void  add(int u, int v, int w)  
{  
    //printf("add %d %d %d\n", u, v, w);
    edge[E].flow = 0;  
    edge[E].cap = w;
    edge[E].st = u;  
    edge[E].ed = v;  
    edge[E].next = head[u];  
    head[u] = E++;      
    edge[E].flow = 0; 
    edge[E].cap = 0; 
    edge[E].st = v;  
    edge[E].ed = u;  
    edge[E].next = head[v];  
    head[v] = E++;  
}
int  dinic_bfs(int src, int dest, int ver)        
{        
    int i, j;         
    for (i = 0; i <= ver; i++)
    {    
        level[i] = -1;
    }
    int  que[MAXN], rear = 1;        
    que[0] = src; level[src] = 0;        
    for(i = 0; i < rear; i++) 
    {        
          for(j = head[que[i]]; j != -1; j = edge[j].next)
         {        
            if(level[edge[j].ed] == -1 && edge[j].cap > edge[j].flow)        
            {        
              level[edge[j].ed] = level[que[i]]+1;        
              que[rear++] = edge[j].ed;        
            }
         }
    }
    return  level[dest] >= 0;        
}        
     
int dinic_dfs(int src, int dest, int ver)        
{        
    int stk[MAXN], top = 0;        
    int ret = 0, cur, ptr, pre[MAXN], minf, i;        
    int del[MAXN];        
    for (i = 0; i <= ver; i++) 
    {
        del[i] = 0;
    }
    stk[top++] = src;         
    pre[src] = src; 
    cur = src;        
    while(top)        
    {        
        while(cur != dest && top)        
        {        
            for(i = head[cur]; i != -1; i = edge[i].next)        
            {        
                if(level[edge[i].ed] == level[cur] + 1 && edge[i].cap > edge[i].flow  && !del[edge[i].ed])        
                {        
                    stk[top++] = edge[i].ed;      
                    cur = edge[i].ed;        
                    pre[edge[i].ed] = i;                       
                    break;     
                }        
            }     
            if(i == -1)       
            {        
                del[cur] = 1;        
                top--;        
                if(top) cur = stk[top-1];        
            }        
        }                
        if(cur == dest)        
        {       
            minf = INF;        
            while(cur != src)        
            {        
                cur = pre[cur];        
                if(edge[cur].cap - edge[cur].flow < minf) minf = edge[cur].cap - edge[cur].flow;        
                cur = edge[cur].st;        
            }
            cur = dest;        
            while(cur != src)        
            {        
                cur = pre[cur];        
                edge[cur].flow += minf;        
                edge[cur^1].flow -= minf;        
                if(edge[cur].cap - edge[cur].flow == 0)
                {
                     ptr = edge[cur].st;
                }
                cur = edge[cur].st;        
            }        
            while(top > 0&& stk[top-1] != ptr) top--;        
            if(top)  cur = stk[top-1];        
            ret += minf;      
        }        
    }        
    return ret;        
}        
int Dinic(int src, int dest, int ver)        
{        
    int  ret = 0, t;        
    while(dinic_bfs(src, dest, ver))        
    {        
        t = dinic_dfs(src, dest, ver);        
        if(t) ret += t;        
        else  break;        
    }        
    return ret;        
}
void floyd(int n)//每个点的最近距离,这个不多说了。保证map[i][k]跟map[k][j]都以存在就行 
{
    int k, i, j;
    for (k = 1; k <= n; k++)//k表示中间点，一定放在最外面 
    {
        for (i = 1; i <= n; i++)
        {
            for (j = 1; j <= n; j++)
            { 
                if (i != j && map[i][k] != INF && map[k][j] != INF && map[i][k] + map[k][j] < map[i][j])
                {
                    map[i][j] = map[i][k] + map[k][j];
                }
            }
        }
    }
}
void build(int distance, int k, int c, int m)
{
    int n = c + k, i, j;
    E = 0;
    for (i = 0; i <= n + 1; i++)
    {
        head[i] = -1;
    }
    for (i = k + 1; i <= n; i++) 
    {
        add(0, i, 1);//源到牛的容量是1 ，题目是要求每只牛都能去任意一个奶牛机就行了 
        for (j = 1; j <= k; j++)
        {
            if (map[i][j] <= distance)//对满足距离的两个点牛跟牛奶机 
            {
                add(i, j, INF);//牛到牛奶机的容量inf 
            }
        }
    }
    for (j = 1; j <= k; j++)//牛奶机到汇的容量为m 
    {
        add(j, n + 1, m);
    }
}
int main()
{
    int c, k, m, n, i, j;
    scanf("%d%d%d", &k, &c, &m);
    n = c + k;
    for (i = 1; i <= n; i++)
    {
        for (j = 1; j <= n; j++)
        {
            scanf("%d", &map[i][j]);
            if (map[i][j] == 0)
            {
                map[i][j] = INF;
            }
        }    
    }
    floyd(n);
    int l = 0, r = INF - 10, mid, ans;
    int s = 0, t = c + k + 1, ver = t + 1;
    while (l < r)//因为二分出现l+1=r的时候，(l+r) >> 1 = l的。所以l+1就等于r了，当l跟r相等的时候就是解 
    {
        mid = (l + r) >> 1;
        build(mid, k, c, m);
        ans = Dinic(0, t, ver);
        if (ans == c)
        {
            r = mid;//r是保证能满足最大流等于牛的数量 
        }
        else
        {
            l = mid + 1; 
        }
    }
    printf("%d\n", r);
    return 0;
}
/*
2 3 2
0 3 2 1 1
3 0 3 2 0
2 3 0 1 0
1 2 1 0 2
1 0 0 2 0

1 1 1
0 1
1 0

2 2 1
0 0 1 3
0 0 2 100
1 2 0 0
3 100 0 0
*/

火碳黑 2011-04-20 20:49 发表评论

poj 1966——Cable TV Network 计算整个图的点连通度

火碳黑 — Mon, 18 Apr 2011 10:27:00 GMT

Cable TV Network

Description

The interconnection of the relays in a cable TV network is bi-directional. The network is connected if there is at least one interconnection path between each pair of relays present in the network. Otherwise the network is disconnected. An empty network or a network with a single relay is considered connected. The safety factor f of a network with n relays is:
1. n, if the net remains connected regardless the number of relays removed from the net.
2. The minimal number of relays that disconnect the network when removed.

For example, consider the nets from figure 1, where the circles mark the relays and the solid lines correspond to interconnection cables. The network (a) is connected regardless the number of relays that are removed and, according to rule (1), f=n=3. The network (b) is disconnected when 0 relays are removed, hence f=0 by rule (2). The network (c) is disconnected when the relays 1 and 2 or 1 and 3 are removed. The safety factor is 2.

Input

Write a program that reads several data sets from the standard input and computes the safety factor for the cable networks encoded by the data sets. Each data set starts with two integers: 0<=n<=50,the number of relays in the net, and m, the number of cables in the net. Follow m data pairs (u,v), u < v, where u and v are relay identifiers (integers in the range 0..n-1). The pair (u,v) designates the cable that interconnects the relays u and v. The pairs may occur in any order.Except the (u,v) pairs, which do not contain white spaces, white spaces can occur freely in input. Input data terminate with an end of file and are correct.

Output

For each data set, the program prints on the standard output, from the beginning of a line, the safety factor of the encoded net.

Sample Input

0 0
1 0
3 3 (0,1) (0,2) (1,2)
2 0
5 7 (0,1) (0,2) (1,3) (1,2) (1,4) (2,3) (3,4)

Sample Output

题意：给出一个图，求删去最少点，使这个图会被分割成至少两部分。
对任意两个不相邻的点，求他们之间的独立轨数P（a,b)。最后是Min（P(a,b))就是整个图的连通度。
题意出现了好多特判的数据。

#include <stdio.h>
#include <string.h>
#include <algorithm>
#define Min(a, b) (a) < (b) ? a : b
using  namespace std;
const  int MAXN = 1005;
const  int MAXM = 210000;
const  int INF = 1000000000;
struct  Edge
{
    int  st, ed;
    int  next;
    int  flow;
    int cap;
}edge[MAXM];
int  head[MAXN], level[MAXN], E;
int cable[MAXN][2], hash[100][100];
void  add(int u, int v, int w)
{
    edge[E].flow = 0;
    edge[E].cap = w;
    edge[E].st = u;
    edge[E].ed = v;
    edge[E].next = head[u];
    head[u] = E++;
    edge[E].flow = 0;
    edge[E].cap = 0;
    edge[E].st = v;
    edge[E].ed = u;
    edge[E].next = head[v];
    head[v] = E++;
}
int  dinic_bfs(int src, int dest, int ver)
{
    int i, j;
    for (i = 0; i <= ver; i++)
    {
        level[i] = -1;
    }
    int  que[MAXN], rear = 1;
    que[0] = src; level[src] = 0;
    for(i = 0; i < rear; i++)
    {
          for(j = head[que[i]]; j != -1; j = edge[j].next)
         {
            if(level[edge[j].ed] == -1 && edge[j].cap > edge[j].flow)
            {
              level[edge[j].ed] = level[que[i]]+1;
              que[rear++] = edge[j].ed;
            }
         }
    }
    return  level[dest] >= 0;
}

int dinic_dfs(int src, int dest, int ver)
{
    int stk[MAXN], top = 0;
    int ret = 0, cur, ptr, pre[MAXN], minf, i;
    int del[MAXN];
    for (i = 0; i <= ver; i++)
    {
        del[i] = 0;
    }
    stk[top++] = src;
    pre[src] = src;
    cur = src;
    while(top)
    {
        while(cur != dest && top)
        {
            for(i = head[cur]; i != -1; i = edge[i].next)
            {
                if(level[edge[i].ed] == level[cur] + 1 && edge[i].cap > edge[i].flow  && !del[edge[i].ed])
                {
                    stk[top++] = edge[i].ed;
                    cur = edge[i].ed;
                    pre[edge[i].ed] = i;
                    break;
                }
            }
            if(i == -1)
            {
                del[cur] = 1;
                top--;
                if(top) cur = stk[top-1];
            }
        }
        if(cur == dest)
        {
            minf = INF;
            while(cur != src)
            {
                cur = pre[cur];
                if(edge[cur].cap - edge[cur].flow < minf) minf = edge[cur].cap - edge[cur].flow;
                cur = edge[cur].st;
            }
            cur = dest;
            while(cur != src)
            {
                cur = pre[cur];
                edge[cur].flow += minf;
                edge[cur^1].flow -= minf;
                if(edge[cur].cap - edge[cur].flow == 0)
                {
                     ptr = edge[cur].st;
                }
                cur = edge[cur].st;
            }
            while(top > 0&& stk[top-1] != ptr) top--;
            if(top)  cur = stk[top-1];
            ret += minf;
        }
    }
    return ret;
}
int Dinic(int src, int dest, int ver)
{
    int  ret = 0, t;
    while(dinic_bfs(src, dest, ver))
    {
        t = dinic_dfs(src, dest, ver);
        if(t) ret += t;
        else  break;
    }
    return ret;
}
void build(int x, int y, int ver, int n, int m)
{
    E = 0;
    int i;
    for (i = 0; i <= ver; i++)
    {
        head[i] = -1;
    }
    for (i = 1; i <= n; i++)
    {
        add(i, i + n, 1);
    }
    for (i = 0; i < m; i++)
    {
        add(cable[i][0] + n, cable[i][1], INF);
        add(cable[i][1] + n, cable[i][0], INF);
    }
    add(x, x + n, INF);
    add(y, y + n, INF);
}
int main()
{
    int n, m, u, v, s, t, ver, i, j;
    while (scanf("%d%d", &n, &m) - EOF)
    {
        ver = n + n + 1;
        for (i = 1; i <= n; i++)
        {
            for (j = 1; j <= n; j++)
            {
                hash[i][j] = 0;
            }
        }
        for (i = 0; i < m; i++)
        {
            scanf(" (%d,%d)", &u, &v);
            u++, v++;
            cable[i][0] = u, cable[i][1] = v;
            hash[u][v] = 1;
        }
        if (m == 0)
        {
            if (n == 1) printf("1\n");
            else printf("0\n");
            continue;
        }
        int pre, min, sign = 0;
        for (i = 1, min = INF; i <= n; i++)
        {
            for (j = i + 1; j <= n; j++)
            {
                if (!hash[i][j])
                {
                    sign = 1;//如果存在不相邻点，标记1
                    build (i, j, ver, n, m);
                    pre = Dinic(i, j + n, ver);
                    min = Min(min, pre);
                }
            }
        }
        if (sign)
        {
            printf("%d\n", min);
        }
        else//所有点都相邻，则任意删掉一些节点都不会影响
        {
            printf("%d\n", n);
        }
    }
    return 0;
}

火碳黑 2011-04-18 18:27 发表评论

poj 1815 Friendship——点连通度最大流，这个题得模板比较好。之前的那个dinic在这里会超时

火碳黑 — Thu, 14 Apr 2011 13:47:00 GMT

摘要: Friendship Description In modern society, each person has his own friends. Since all the people are very busy, they communicate with each other only by phone. You can assume that people A can kee... 阅读全文

火碳黑 2011-04-14 21:47 发表评论

poj 1149——PIGS 卖猪最大流

火碳黑 — Wed, 13 Apr 2011 02:47:00 GMT

PIGS

Description

Mirko works on a pig farm that consists of M locked pig-houses and Mirko can't unlock any pighouse because he doesn't have the keys. Customers come to the farm one after another. Each of them has keys to some pig-houses and wants to buy a certain number of pigs.
All data concerning customers planning to visit the farm on that particular day are available to Mirko early in the morning so that he can make a sales-plan in order to maximize the number of pigs sold.
More precisely, the procedure is as following: the customer arives, opens all pig-houses to which he has the key, Mirko sells a certain number of pigs from all the unlocked pig-houses to him, and, if Mirko wants, he can redistribute the remaining pigs across the unlocked pig-houses.
An unlimited number of pigs can be placed in every pig-house.
Write a program that will find the maximum number of pigs that he can sell on that day.

Input

The first line of input contains two integers M and N, 1 <= M <= 1000, 1 <= N <= 100, number of pighouses and number of customers. Pig houses are numbered from 1 to M and customers are numbered from 1 to N.
The next line contains M integeres, for each pig-house initial number of pigs. The number of pigs in each pig-house is greater or equal to 0 and less or equal to 1000.
The next N lines contains records about the customers in the following form ( record about the i-th customer is written in the (i+2)-th line):
A K1 K2 ... KA B It means that this customer has key to the pig-houses marked with the numbers K1, K2, ..., KA (sorted nondecreasingly ) and that he wants to buy B pigs. Numbers A and B can be equal to 0.

Output

The first and only line of the output should contain the number of sold pigs.

Sample Input

Sample Output

7
题意：
有农民在卖猪，有M个猪笼，每个人有某些猪笼的钥匙，所以每个人可以买他能打开的猪笼中的猪，人是按顺序买猪的，当第i-1个人买完后，
他能打开的猪笼可以中的猪可以被重新调整。就是在那些猪笼中移动猪。
给出每个猪笼的猪数量，给出每个人能打开的猪笼序号以及想购买的猪数量。
求：最多能卖多少猪。
分析：主要是怎么弄让被打开过的猪笼可以移动猪。如果i跟i+1两个人的钥匙没交集，则他们只能买自己的猪笼端的猪，如果两个人有交集，
那i+1的可以买i能打开的猪笼x的猪，i可以连向x，边的流量正无穷。
代码：


#include <iostream>
#include <stdlib.h>
using namespace std;
const int maxn= 20010;
const int M = 1010;
const __int64 inf=0x7fffffff;
struct node
{
    __int64 v,next;
    __int64 w;
}fn[500010];
__int64 level[maxn],g[maxn],que[maxn],out[maxn], th, tip, visit[maxn];
__int64 key[M][M], h[M], buy[M], hash[M][M], len[M];
inline void add(__int64 u,__int64 v,__int64 w)
{
    fn[th].v = v, fn[th].w = w, fn[th].next = g[u], g[u] = th++;    
    fn[th].v = u, fn[th].w = 0, fn[th].next = g[v], g[v] = th++;
}
void build_level(__int64  n,__int64 s,__int64  e)
{
    __int64 h=0,r=0,i,u;    
    for (i = 0; i <= n; i++) level[i]=0;
    level[s] = 1;
    que[0] = s;
    while(h <= r)
    {
        u = que[h++];
        for (i = g[u]; i != -1; i = fn[i].next)
        {
            if (fn[i].w && level[fn[i].v] == 0)
            {
                que[++r] = fn[i].v;
                level[fn[i].v] = level[u] + 1;
             }
        }
    }
 }
__int64 dinic(__int64 n,__int64 s,__int64 e)
{
    __int64 ret=0,i;
    while(1)
    {
        build_level(n,s,e);
        if (level[e] == 0) break;
        for (i = 0; i < n; ++i) out[i] = g[i];
        __int64 q = -1;
        while(1)
        {
            if (q < 0)
            {
                for (i = out[s]; i != -1; i = fn[i].next)
                {
                    if (fn[i].w && out[fn[i].v] != -1 && level[fn[i].v] == 2)
                    {
                        que[++q] = i;
                        out[s] = fn[i].next;
                        break;
                    }
                }
                if (i == -1)
                {
                    break;
                }
            }
            __int64 u = fn[que[q]].v;
            if(u == e)
            {
                __int64 tmp=inf;
                for(i = 0;i <= q; i++)
                    if(tmp > fn[que[i]].w)tmp = fn[que[i]].w;
                ret += tmp;
                for(i=0;i<=q;i++)
                {
                    fn[que[i]].w -= tmp;
                    fn[que[i]^1].w += tmp;   
                }
                for (i = 0; i <= q; i++)
                {
                    if(fn[que[i]].w == 0)
                    {
                        q = i-1;
                        break;
                    }
                }
            }
            else
            {
                for (i = out[u]; i != -1; i = fn[i].next)
                {
                    if (fn[i].w && out[fn[i].v] !=-1 && level[u] + 1 == level[fn[i].v]) 
                    {
                        que[++q] = i, out[u] = fn[i].next;
                        break;
                    }
                }
                if(i==-1)
                {
                    out[u] = -1, q--;
                 }
              
            }
        }
    }
    return ret;
}
int main()
{
    __int64 m, n, s, t, i, j, k;
    scanf("%I64d%I64d", &m, &n);
    s = 0, t = n + m + 1;
    for (i = 0; i < t + 10; i++)
    {
        g[i] = -1;
    }
    for (i = 1; i <= m; i++)
    {
        scanf("%I64d", &h[i]);
        add(i + n, t, h[i]);
    }
    for (i = 1; i <= n; i++)
    {
        for (j = 1; j <= m; j++)
        {
            hash[i][j] = 0;
        }
    }
    for (i = 1; i <= n; i++)
    {
        scanf("%I64d", &len[i]);
        for (j = 0; j < len[i]; j++)
        {
            scanf("%I64d", &key[i][j]);
            hash[i][key[i][j]] = 1;
        }
        scanf("%I64d", &buy[i]);
        add(0, i, buy[i]);
    }
    for (i = 1; i <= n; i++)
    {
        for (j = 0; j < len[i]; j++)
        {
            add(i, key[i][j] + n, inf);
        }
        for (j = 0; j < i; j++)//对前i-1的人，有钥匙交集的，i可以买他们能打开的猪笼
        {
            if (i != j)
            {
                for (k = 0; k < len[i]; k++)
                {
                    if (hash[j][key[i][k]])
                    {
                        break;
                    }
                }
                if (k != len[i])
                {
                    for (k = 0; k < len[j]; k++)
                    {
                        add(i, key[j][k] + n, inf);    
                    }
                }
            }
        }
        
    }
    printf("%I64d\n", dinic(t + 1, s, t));
    return 0;
}

火碳黑 2011-04-13 10:47 发表评论

poj 3422 Kaka's Matrix Travels——最大费用k次流。

火碳黑 — Mon, 11 Apr 2011 03:56:00 GMT

Kaka's Matrix Travels

Description

On an N × N chessboard with a non-negative number in each grid, Kaka starts his matrix travels with SUM = 0. For each travel, Kaka moves one rook from the left-upper grid to the right-bottom one, taking care that the rook moves only to the right or down. Kaka adds the number to SUM in each grid the rook visited, and replaces it with zero. It is not difficult to know the maximum SUM Kaka can obtain for his first travel. Now Kaka is wondering what is the maximum SUM he can obtain after his Kth travel. Note the SUM is accumulative during the K travels.

Input

The first line contains two integers N and K (1 ≤ N ≤ 50, 0 ≤ K ≤ 10) described above. The following N lines represents the matrix. You can assume the numbers in the matrix are no more than 1000.

Output

The maximum SUM Kaka can obtain after his Kth travel.

Sample Input

Sample Output

题意：给出一个矩阵上的数字，要求从左上走到右下，每次只能向右或向下走取数，被取过的地方不再取。
求走k次的最大和。
每个点map[i][j]拆成两个点x->x'，容量为1，消费会map[i][j]。然后能通向x的点A，A'->x,容量为inf，消费为0，x通向的点B，x->B',容量为inf，消费为0.这样保证每个点的值只被取一次，且能走过多次。
为了限制只走k次，矩阵左上的点x，加个s到0，容量为k，消费0，矩阵的最右下的点y，y'->t，容量为k，消费为0.

#include <stdio.h>
#include <stdlib.h>
#define M 200001
#define maxx 2000
#define Max(a, b) a > b ? a : b
#define Min(a, b) a < b ? a : b
#define inf (1 << 29)
struct T
{
    int u, v, val, next, cost;
}e[M];
int th;
int visit[M], pre[M], dis[M], que[M], g[M], pos[M], map[100][100];
void add(int u, int v, int val, int cost)
{
    e[th].u = u, e[th].v = v, e[th].val = val, e[th].cost = cost;
    e[th].next = g[u], g[u] = th++;
    e[th].u = v, e[th].v = u, e[th].val = 0, e[th].cost = -cost;
    e[th].next = g[v], g[v] = th++;
}
int spfa(int s, int t, int n)
{
    int i, u, v, k;
    for (i = 0; i <= n; i++)
    {
        pre[i] = -1, visit[i] = 0;
    }
    int head, tail;
    head = tail = 0;
    for (i = 0; i <= n; i++) dis[i] = -1;//求最小费用时这里得改成正无穷
    que[tail++] = s, pre[s] = s, dis[s] = 0, visit[s] = 1;
    while (head != tail)
    {
        int u = que[head++];
        visit[u] = 0;
        for (k = g[u]; k != -1; k = e[k].next)
        {
            v = e[k].v;
            if (e[k].val > 0 && dis[u] + e[k].cost > dis[v])//最大费用，求最小费用时这里的改符号
            {
                dis[v] = dis[u] + e[k].cost;
                pre[v] = u;
                pos[v] = k;
                if (!visit[v])
                {
                    visit[v] = 1;
                    que[tail++] = v;
                }
            }
        }
    }
    if (pre[t] != -1 && dis[t] > -1)//求最小费用时这里改成dit[t] < 正无穷
    {
        return 1;
    }
    return 0;
}
int MinCostFlow(int s, int t, int n)
{
    if (s == t)
    {
        //这里具体情况具体分析，如果有附加s跟t就不用，如果用数据中的点作为s跟t就得考虑
        //直接返回某个值。否则spfa里的队列会死循环。
    }
    int flow = 0, cost = 0;
    while (spfa(s, t, n))
    {
        int u, min = inf;
        for (u = t; u != s; u = pre[u])
        {
            min = Min(min, e[pos[u]].val);
        }
        flow += min;
        cost += dis[t] * min;
        for (u = t; u != s; u = pre[u])
        {
            e[pos[u]].val -= min;
            e[pos[u]^1].val += min;
        }
    }
    return cost;
}
int main()
{
    int n, m, i, j, k, s, t, u, v, cost, ans, x, num, tt;
    while (scanf("%d%d", &n, &m) - EOF)
    {
        for (i = 0, th = 0; i < n * n * 3 + 2; i++)
        {
            g[i] = -1;
        }
        for (i = 0; i < n; i++)
        {
            for (j = 0; j < n; j++)
            {
                scanf("%d", &map[i][j]);
            }
        }
        num = n * n;
        for (i = 0; i < n; i++)
        {
            for (j = 0; j < n; j++)
            {
                x = i * n + j;
                add(x, x + num, 1, map[i][j]);
                add(x, x + num, inf, 0);
                if (i + 1 < n)
                {
                    add(x + num, x + n, inf, 0);
                }
                if (j + 1 < n)
                {
                    add(x + num, x + 1, inf, 0);
                }
            }
        }
        s = 2 * n * n, t = s + 1, n = t + 1;
        add(s, 0, m, 0);
        add(s - 1, t, m, 0);
        ans = MinCostFlow(s, t, t + 1);
        printf("%d\n", ans);
    }
    return 0;
}

火碳黑 2011-04-11 11:56 发表评论

poj 2195 二分图最大权匹配KM

火碳黑 — Sat, 09 Apr 2011 05:51:00 GMT

摘要: 阅读全文

火碳黑 2011-04-09 13:51 发表评论

1904 King's Quest——二分图结构，强连通分量算法，对比之前的，这个才算正确的tarjan

火碳黑 — Sat, 02 Apr 2011 13:09:00 GMT

King's Quest

Description
Once upon a time there lived a king and he had N sons. And there were N beautiful girls in the kingdom and the king knew about each of his sons which of those girls he did like. The sons of the king were young and light-headed, so it was possible for one son to like several girls.

So the king asked his wizard to find for each of his sons the girl he liked, so that he could marry her. And the king's wizard did it -- for each son the girl that he could marry was chosen, so that he liked this girl and, of course, each beautiful girl had to marry only one of the king's sons.

However, the king looked at the list and said: "I like the list you have made, but I am not completely satisfied. For each son I would like to know all the girls that he can marry. Of course, after he marries any of those girls, for each other son you must still be able to choose the girl he likes to marry."

The problem the king wanted the wizard to solve had become too hard for him. You must save wizard's head by solving this problem.

Input
The first line of the input contains N -- the number of king's sons (1 <= N <= 2000). Next N lines for each of king's sons contain the list of the girls he likes: first Ki -- the number of those girls, and then Ki different integer numbers, ranging from 1 to N denoting the girls. The sum of all Ki does not exceed 200000.

The last line of the case contains the original list the wizard had made -- N different integer numbers: for each son the number of the girl he would marry in compliance with this list. It is guaranteed that the list is correct, that is, each son likes the girl he must marry according to this list.

Output
Output N lines.For each king's son first print Li -- the number of different girls he likes and can marry so that after his marriage it is possible to marry each of the other king's sons. After that print Li different integer numbers denoting those girls, in ascending order.

Sample Input

4
2 1 2
2 1 2
2 2 3
2 3 4
1 2 3 4

Sample Output

2 1 2
2 1 2
1 3
1 4

题意：给出一个n对n的二分图以及它的一个最大匹配M，问对一个点，可以选什么点，使得其他点仍然可以得到最大匹配。
对于xi喜欢的mm，连一条单向边，对于给出的匹配，从mm连向那个男生。
分析：对于给出的匹配中X集合，从xi出发看看是否有其他交错路径，使得xi可以选其他女人。对于给出的匹配xi->yi,现在尝试从xi出发选别的女孩xi->Y-yi，看最后能否达到终点yi，形成一个环。如果存在这样的路径，则路径会经过一样多的x点跟y点，使得一一对应，这条路径中分为两条交错路径，一个是原来的匹配，一个是另一个可行替换匹配，通过女人走到男人的是给定的M中的边，从男人走到女人的是非匹配的边。那一个出发点xi可以存在多个这样的环，问题就成为找强连通分量，xi可以配对的女人就在那连通分量里。

#include <iostream>
#include <stdlib.h>
#include <stdio.h>
#define maxn 4100
#define Min(a, b) a < b ? a : b
using namespace std;
struct T
{
    int v, next;
}fn[maxn * maxn];
int g[maxn], ans[maxn];
int stack[maxn], visit[maxn], scc[maxn], dfn[maxn], low[maxn], instack[maxn];
int n, th, top, id, time;
int cmp(const void * a, const void * b)
{
    return *((int*)a) - *((int*)b);
}
void set()
{
    int i;
    th = 1;
    for (i = 0; i <= 2 * n; i++)
    {
        g[i] = -1;
    }
}
void add(int u, int v)
{
    fn[th].v = v, fn[th].next = g[u], g[u] = th++;
}
void dfs(int u)
{
    int v, k;
    dfn[u] = low[u] = ++time;
    stack[++top] = u;//栈从1开始
    instack[u] = 1;//标记进栈
    for (k = g[u]; k != -1; k = fn[k].next)
    {
        v = fn[k].v;
        if (dfn[v] == 0)//dfn是时间戳，都初始化为0，被访问过的店带有时间
        {
            dfs(v);
            low[u] = Min(low[u], low[v]);
        }
        else if (instack[v])//如果在栈中，则表示该点没被归入任何一个scc中，还在当前搜索树中
        {
            low[u] = Min(low[u], low[v]);
        }
    }
    if (dfn[u] == low[u])
    {
        id++;
        do
        {
            v = stack[top--];
            instack[v] = 0;//防止交叉边长时进行low[u] = Min(low[u], low[v]).因为v已经属于一个连通分量
            scc[v] = id;
        }while (v != u);
    }
}
void tarjan()
{
    id = 0, top = 0, time = 0;
    int t = 0, i;
    for (i = 1; i <= 2 * n; i++)
    {
        dfn[i] = 0;//要设为0
        scc[i] = i;
        instack[i] = 0;//要设为0
    }
    for (i = 1; i <= 2 * n; i++)
    {
        if (!dfn[i])
        {
            dfs(i);
        }
    }
}
int main()
{
    int i, j, k, m, v;
    while (scanf("%d", &n) - EOF)
    {
        set();
        for (i = 1; i <= n; i++)
        {
            scanf("%d", &m);
            while (m--)
            {
                scanf("%d", &v);
                add(i, v + n);
            }
        }
        for (i = 1; i <= n; i++)
        {
            scanf("%d", &v);
            add(v + n, i);
        }
        tarjan();
        for (i = 1; i <= n; i++)
        {
            for (j = g[i], k = 0; j != -1; j = fn[j].next)
            {
                v = fn[j].v;
                if (scc[i] == scc[v])
                {
                    ans[k++] = v - n;
                }
            }
            qsort(ans, k, sizeof(int), cmp);
            for (printf("%d", k), j = 0; j < k; j++)
            {
                printf(" %d", ans[j]);
            }printf("\n");
        }
    }
    return 0;
}
/*
3
2 1 2
3 1 2 3
2 2 3
1 2 3

2
2 1 2
2 1 2
1 2

input :
5
3 3 4 5
2 4 5
1 3
3 1 2 3
3 1 4 5
5 4 3 2 1

output :
2 4 5
2 4 5
1 3
1 2
1 1

*/

火碳黑 2011-04-02 21:09 发表评论

C++博客-夜幻梦回-随笔分类-图论

poj 3680 Intervals——费用流经典构图：费用流邻接spfa，二分查找离散化值

poj 3498 March of the Penguins——最大流

poj 3308 Paratroopers——最小点权覆盖

poj 2125 Destroying The Graph——最小点权覆盖+最小割

poj 3204 Ikki's Story I - Road Reconstruction——最大流最小割+残流理解

hdu 3416 Marriage Match IV——双向最短路确定最短路的边+最大流（图边连通度）

poj 3189 Steady Cow Assignment——二分+最大流dinic

poj 3084 Panic Room——图的边连通度

poj 2455 Secret Milking Machine——图的边连通度，二分边值求最大流

poj 2391 Ombrophobic Bovines——floyd+二分+最大流

poj 2112 Optimal Milking——最短路floyd+二分+最大流dinic

poj 1966——Cable TV Network 计算整个图的点连通度

poj 1815 Friendship——点连通度 最大流，这个题得模板比较好。之前的那个dinic在这里会超时

poj 1149——PIGS 卖猪最大流

poj 3422 Kaka's Matrix Travels——最大费用k次流。

poj 2195 二分图最大权匹配KM

1904 King's Quest——二分图结构，强连通分量算法，对比之前的，这个才算正确的tarjan

poj 1815 Friendship——点连通度最大流，这个题得模板比较好。之前的那个dinic在这里会超时