C++博客-第七天堂-文章分类-图论

HDU4009:Transfer water

LLawliet — Sat, 15 Oct 2011 14:20:00 GMT

Transfer water

Time Limit: 5000/3000 MS (Java/Others) Memory Limit: 65768/65768 K (Java/Others)
Total Submission(s): 1770 Accepted Submission(s): 650

Problem Description

XiaoA lives in a village. Last year flood rained the village. So they decide to move the whole village to the mountain nearby this year. There is no spring in the mountain, so each household could only dig a well or build a water line from other household. If the household decide to dig a well, the money for the well is the height of their house multiplies X dollar per meter. If the household decide to build a water line from other household, and if the height of which supply water is not lower than the one which get water, the money of one water line is the Manhattan distance of the two households multiplies Y dollar per meter. Or if the height of which supply water is lower than the one which get water, a water pump is needed except the water line. Z dollar should be paid for one water pump. In addition,therelation of the households must be considered. Some households may do not allow some other households build a water line from there house. Now given the 3‐dimensional position (a, b, c) of every household the c of which means height, can you calculate the minimal money the whole village need so that every household has water, or tell the leader if it can’t be done.

Input

Multiple cases.
First line of each case contains 4 integers n (1<=n<=1000), the number of the households, X (1<=X<=1000), Y (1<=Y<=1000), Z (1<=Z<=1000).
Each of the next n lines contains 3 integers a, b, c means the position of the i‐th households, none of them will exceeded 1000.
Then next n lines describe the relation between the households. The n+i+1‐th line describes the relation of the i‐th household. The line will begin with an integer k, and the next k integers are the household numbers that can build a water line from the i‐th household.
If n=X=Y=Z=0, the input ends, and no output for that.

Output

One integer in one line for each case, the minimal money the whole village need so that every household has water. If the plan does not exist, print “poor XiaoA” in one line.

Sample Input

Sample Output

30

HintIn  3‐dimensional  space  Manhattan  distance  of  point  A  (x1,  y1,  z1)  and  B(x2,  y2,  z2)  is |x2‐x1|+|y2‐y1|+|z2‐z1|.

Source

The 36th ACM/ICPC Asia Regional Dalian Site —— Online Contest

Recommend

lcy

今年大连赛区网络赛一道题.....我怎么一点印象也没有呢.....
一道赤裸的最小树形图，除了数据有点大而已.....
思路：因为没有根，所以虚拟一个根，所有点和这个根连线，权值是该点造井的价格，这样以这个根出发，构造出来的最小树形图就是最小的费用了。
代码：

#include <cstdio>
#include <cstring>
#include <cmath>
#include <iostream>
using namespace std;

const int maxn = 1100;
const int maxm = 1100000;
const int maxint = 0x3fffffff;

struct edge
{
    int u, v, w;
    edge(){}
    edge(int u1, int v1, int w1) : u(u1), v(v1), w(w1){}
} e[maxm];

int root, n, edgeNum, vis[maxn], pre[maxn], belong[maxn], in[maxn];
int a[maxn], b[maxn], c[maxn];
int Abs(int a)
{
    return a > 0 ? a : -a;
}

int Dis(int i, int j)
{
    return Abs(a[i] - a[j]) + Abs(b[i] - b[j]) + Abs(c[i] - c[j]);
}

int solve()
{
    int i, j, k, num, sum = 0;
    n++;
    while (1)
    {
        for (i = 0; i < n; ++i)
            in[i] = maxint;
        for (i = 0; i < edgeNum; ++i)
        {
            if (in[e[i].v] > e[i].w && e[i].u != e[i].v)
            {
                pre[e[i].v] = e[i].u;
                in[e[i].v] = e[i].w;
            }
        }

        memset(vis, -1, sizeof(vis));
        memset(belong, -1, sizeof(belong));
        in[root] = 0;
        for (num = 0, i = 0; i < n; ++i)
        {
            sum += in[i];
            j = i;
            while (vis[j] != i && belong[j] == -1 && j != root)
            {
                vis[j] = i;
                j = pre[j];
            }
            if (vis[j] == i)
            {
                for (k = pre[j]; k != j; k = pre[k])
                    belong[k] = num;
                belong[j] = num++;
            }
        }

        if (!num) return sum;
        for (i = 0; i < n; ++i)
            if (belong[i] == -1)
                belong[i] = num++;

        for (i = 0; i < edgeNum; ++i)
        {
            int j = e[i].v;
            e[i].u = belong[e[i].u];
            e[i].v = belong[e[i].v];
            e[i].w -= in[j];
        }
        n = num;
        root = belong[root];
    }
    return sum;
}

int main()
{
    int x, y, z, i, j, k, ii, d;
    while (scanf("%d%d%d%d", &n, &x, &y, &z) != EOF)
    {
        if (!n && !x && !y && !z) break;
        for (edgeNum = 0, i = 1; i <= n; ++i)
        {
            scanf("%d%d%d", &a[i], &b[i], &c[i]);
            e[edgeNum++] = edge(0, i, c[i] * x);
        }
        for (i = 1; i <= n; ++i)
        {
            scanf("%d", &k);
            while (k--)
            {
                scanf("%d", &ii);
                if (i == ii) continue;
                d = Dis(i, ii);
                if (c[i] >= c[ii])
                    e[edgeNum++] = edge(i, ii, d * y);
                else
                    e[edgeNum++] = edge(i, ii, d * y + z);
            }
        }

        root = 0;
        printf("%d\n", solve());
    }
    return 0;
}

LLawliet 2011-10-15 22:20 发表评论

HDU2121:Ice_cream’s world II

LLawliet — Sat, 15 Oct 2011 14:18:00 GMT

摘要: Ice_cream’s world IITime Limit: 3000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)Total Submission(s): 938 Accepted Submission(s):... 阅读全文

LLawliet 2011-10-15 22:18 发表评论

POJ3164:Command Network

LLawliet — Sat, 15 Oct 2011 14:18:00 GMT

Command Network

Time Limit: 1000MS		Memory Limit: 131072K
Total Submissions: 7267		Accepted: 2160

Description

After a long lasting war on words, a war on arms finally breaks out between littleken’s and KnuthOcean’s kingdoms. A sudden and violent assault by KnuthOcean’s force has rendered a total failure of littleken’s command network. A provisional network must be built immediately. littleken orders snoopy to take charge of the project.

With the situation studied to every detail, snoopy believes that the most urgent point is to enable littenken’s commands to reach every disconnected node in the destroyed network and decides on a plan to build a unidirectional communication network. The nodes are distributed on a plane. If littleken’s commands are to be able to be delivered directly from a node A to another node B, a wire will have to be built along the straight line segment connecting the two nodes. Since it’s in wartime, not between all pairs of nodes can wires be built. snoopy wants the plan to require the shortest total length of wires so that the construction can be done very soon.

Input

The input contains several test cases. Each test case starts with a line containing two integer N (N ≤ 100), the number of nodes in the destroyed network, and M (M ≤ 10⁴), the number of pairs of nodes between which a wire can be built. The next N lines each contain an ordered pair x_i and y_i, giving the Cartesian coordinates of the nodes. Then follow M lines each containing two integers i and j between 1 and N (inclusive) meaning a wire can be built between node i and node j for unidirectional command delivery from the former to the latter. littleken’s headquarter is always located at node 1. Process to end of file.

Output

For each test case, output exactly one line containing the shortest total length of wires to two digits past the decimal point. In the cases that such a network does not exist, just output ‘poor snoopy’.

Sample Input

Sample Output

31.19 
poor snoopy

Source

POJ Monthly--2006.12.31, galaxy

裸的最小树形图，我就是为了检验模板....结果还错了.....%.2lf在POJ上用G++会莫名的挂掉，所以用C++就行了。
代码：

#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#define MAXN 110
#define INF 1e30
using namespace std;

inline double sqr(double x)
{
    return x * x;
}

struct point
{
    double _x, _y;
    double dist_with(const point &rh) const
    {
        return sqrt(sqr(_x - rh._x) + sqr(_y - rh._y));
    }
} po[MAXN];

double g[MAXN][MAXN];

int pre[MAXN];
bool is_out[MAXN];
int vis[MAXN], vcnt;

double solve(int n, int root)
{
    memset(is_out, false, n);
    double ans = 0;
    while (1)
    {
        int i, j, k;
        for (i = 0; i < n; ++i)
            if (i != root && !is_out[i])
            {
                pre[i] = i;
                for (j = 0; j < n; ++j)
                    if (!is_out[j] && g[pre[i]][i] > g[j][i])
                        pre[i] = j;
                if (pre[i] == i) throw false;
            }
        for (i = 0; i < n; ++i)
            if (i != root && !is_out[i])
            {
                j = i;
                vis[i] = ++vcnt;
                while (vis[pre[j]] != vcnt && pre[j] != root)
                {
                    j = pre[j];
                    vis[j] = vcnt;
                }
                if (pre[j] == i)
                    break;
            }
        if (i == n)
        {
            for (j = 0; j < n; ++j)
                if (j != root && !is_out[j])
                    ans += g[pre[j]][j];
            break;
        }
        j = i;
        do
        {
            is_out[j] = true;
            ans += g[pre[j]][j];
            j = pre[j];
        } while (j != i);
        for (int j = 0; j < n; ++j)
            if (vis[j] == vcnt)
                for (int k = 0; k < n; ++k)
                    if (!is_out[k])
                    {
                        if (g[i][k] > g[j][k])
                            g[i][k] = g[j][k];
                        if (g[k][i] > g[k][j] - g[pre[j]][j] && g[k][j] != INF)
                            g[k][i] = g[k][j] - g[pre[j]][j];
                    }
        is_out[i] = false;
    }
    return ans;
}

int main()
{
    int n, m;
    while (scanf("%d%d", &n, &m) != EOF)
    {
        for (int i = 0; i < n; ++i)
            for (int j = 0; j < n; ++j)
                g[i][j] = INF;
        for (int i = 0; i < n; ++i)
            scanf("%lf%lf", &po[i]._x, &po[i]._y);
        for (int i = 0; i < m; ++i)
        {
            int a, b;
            scanf("%d%d", &a, &b);
            if (a != b)
                g[a - 1][b - 1] = po[a - 1].dist_with(po[b - 1]);
        }
        try
        {
            printf("%.2lf\n", solve(n, 0));
        }
        catch (bool)
        {
            printf("poor snoopy\n");
        }
    }
    return 0;
}

LLawliet 2011-10-15 22:18 发表评论

ZOJ3316：Game

LLawliet — Sat, 15 Oct 2011 14:17:00 GMT

传送门：http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemId=3726

一道看似博弈论的题，其实就是模板题而已。

分析：
平面上N个点，两个人轮流取点，而且规定当前取的点和上一个取的点的曼哈顿距离要小于L，所以，点可以看成两两成对消去。
这也就转成了一般图匹配，如果存在完美匹配，那么后手的人总可以取完，如果不存在，那么先手的人可以拿一个孤立点，这样第二个人要么没有匹配点，要么只能拆到一个匹配对，但这样又造成了孤立点。

网上有个人拿二分图匹配过了....看来数据很弱.....
代码：

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <cmath>
#define MAXN 450
using namespace std;

int x[MAXN], y[MAXN];

struct Graph
{
    bool mat[MAXN + 1][MAXN + 1];
    int n;

    bool inque[MAXN + 1];
    int que[MAXN], head, tail;

    int match[MAXN + 1], father[MAXN + 1], base[MAXN + 1];

    void init(int _n)
    {
        n = _n;
        for (int i = 1; i <= n; ++i)
        {
            match[i] = 0;
            for (int j = 1; j <= n; ++j)
                mat[i][j] = false;
        }
    }

    int pop()
    {
        return que[head++];
    }

    void push(int x)
    {
        que[tail++] = x;
        inque[x] = true;
    }

    void add_edge(int a, int b)
    {
        mat[a][b] = mat[b][a] = true;
    }

    int inpath[MAXN + 1];
    static int pcnt;

    int find_ancestor(int u, int v)
    {
        ++pcnt;
        while (u)
        {
            u = base[u];
            inpath[u] = pcnt;
            u = father[match[u]];
        }

        while (true)
        {
            v = base[v];
            if (inpath[v] == pcnt)
                return v;
            v = father[match[v]];
        }
    }

    int inblossom[MAXN + 1];
    static int bcnt;

    void reset(int u, int anc)
    {
        while (u != anc)
        {
            int v = match[u];
            inblossom[base[v]] = bcnt;
            inblossom[base[u]] = bcnt;
            v = father[v];
            if (base[v] != anc) father[v] = match[u];
            u = v;
        }
    }

    void contract(int u, int v)
    {
        int anc = find_ancestor(u, v);
        ++bcnt;
        reset(u, anc);
        reset(v, anc);
        if (base[u] != anc) father[u] = v;
        if (base[v] != anc) father[v] = u;
        for (int i = 1; i <= n; ++i)
            if (inblossom[base[i]] == bcnt)
            {
                base[i] = anc;
                if (!inque[i]) push(i);
            }
    }

    int find_augment(int start)
    {
        for (int i = 1; i <= n; ++i)
        {
            father[i] = 0;
            inque[i] = false;
            base[i] = i;
        }
        head = 0, tail = 0, push(start);
        while (head < tail)
        {
            int u = pop();
            for (int v = 1; v <= n; ++v)
                if (mat[u][v] && base[v] != base[u] && match[v] != u)
                {
                    if (v == start || (match[v] && father[match[v]]))
                        contract(u, v);
                    else
                    {
                        if (father[v] == 0)
                        {
                            if (match[v])
                            {
                                push(match[v]);
                                father[v] = u;
                            }
                            else
                            {
                                father[v] = u;
                                return v;
                            }
                        }
                    }
                }
        }
        return 0;
    }

    void augment(int finish)
    {
        int u = finish, v, w;
        while (u)
        {
            v = father[u];
            w = match[v];
            match[u] = v;
            match[v] = u;
            u = w;
        }
    }

    int graph_max_match()
    {
        int ans = 0;
        for (int i = 1; i <= n; ++i)
            if (match[i] == 0)
            {
                int finish = find_augment(i);
                if (finish)
                {
                    augment(finish);
                    ans += 2;
                }
            }
        return ans;
    }
} g;

int Graph :: bcnt = 0, Graph :: pcnt = 0;

int dis(int i, int j, int l)
{
    int d;
    d = abs(x[i] - x[j]) + abs(y[i] - y[j]);
    if (d <= l) return 1;
    else return 0;
}

int main()
{
    int n;
    while (scanf("%d", &n) != EOF)
    {
        int l;
        g.init(n);
        for (int i = 1; i <= n; ++i)
            scanf("%d%d", &x[i], &y[i]);
        scanf("%d", &l);
        for (int i = 1; i < n; ++i)
            for (int j = i + 1; j <= n; ++j)
            {
                if (dis(i, j, l)) g.add_edge(i, j);
            }
        int sum;
        sum = g.graph_max_match();
        if (sum == n) puts("YES");
        else puts("NO");
    }
    return 0;
}

LLawliet 2011-10-15 22:17 发表评论

URAL1099:Work Scheduling(任意图匹配，带花树)

LLawliet — Sat, 15 Oct 2011 14:16:00 GMT

1099. Work Scheduling

Time Limit: 0.5 second
Memory Limit: 16 MB

There is certain amount of night guards that are available to protect the local junkyard from possible junk robberies. These guards need to scheduled in pairs, so that each pair guards at different night. The junkyard CEO ordered you to write a program which given the guards characteristics determines the maximum amount of scheduled guards (the rest will be fired). Please note that each guard can be scheduled with only one of his colleagues and no guard can work alone.

Input

The first line of the input contains one number N ≤ 222 which is the amount of night guards. Unlimited number of lines consisting of unordered pairs (i, j) follow, each such pair means that guard #i and guard #j can work together, because it is possible to find uniforms that suit both of them (The junkyard uses different parts of uniforms for different guards i.e. helmets, pants, jackets. It is impossible to put small helmet on a guard with a big head or big shoes on guard with small feet). The input ends with Eof.

Output

You should output one possible optimal assignment. On the first line of the output write the even number C, the amount of scheduled guards. Then output C/2 lines, each containing 2 integers (i, j) that denote that i and j will work together.

Sample

input	output
3 1 2 2 3 1 3	2 1 2

Problem Author: Jivko Ganev

模板题.....一般图匹配主要看模板，剩下的就是自己YY建图了.....

模板：

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
#define MAXN 256
using namespace std;

struct Graph
{
    bool mat[MAXN + 1][MAXN + 1];
    int n;

    bool inque[MAXN + 1];
    int que[MAXN], head, tail;

    int match[MAXN + 1], father[MAXN + 1], base[MAXN + 1];

    void init(int _n)
    {
        n = _n;
        for (int i = 1; i <= n; ++i)
        {
            match[i] = 0;
            for (int j = 1; j <= n; ++j)
                mat[i][j] = false;
        }
    }

    int pop()
    {
        return que[head++];
    }

    void push(int x)
    {
        que[tail++] = x;
        inque[x] = true;
    }

    void add_edge(int a, int b)
    {
        mat[a][b] = mat[b][a] = true;
    }

    int inpath[MAXN + 1];
    static int pcnt;

    int find_ancestor(int u, int v)
    {
        ++pcnt;
        while (u)
        {
            u = base[u];
            inpath[u] = pcnt;
            u = father[match[u]];
        }

        while (true)
        {
            v = base[v];
            if (inpath[v] == pcnt)
                return v;
            v = father[match[v]];
        }
    }

    int inblossom[MAXN + 1];
    static int bcnt;

    void reset(int u, int anc)
    {
        while (u != anc)
        {
            int v = match[u];
            inblossom[base[v]] = bcnt;
            inblossom[base[u]] = bcnt;
            v = father[v];
            if (base[v] != anc) father[v] = match[u];
            u = v;
        }
    }

    void contract(int u, int v)
    {
        int anc = find_ancestor(u, v);
        ++bcnt;
        reset(u, anc);
        reset(v, anc);
        if (base[u] != anc) father[u] = v;
        if (base[v] != anc) father[v] = u;
        for (int i = 1; i <= n; ++i)
            if (inblossom[base[i]] == bcnt)
            {
                base[i] = anc;
                if (!inque[i]) push(i);
            }
    }

    int find_augment(int start)
    {
        for (int i = 1; i <= n; ++i)
        {
            father[i] = 0;
            inque[i] = false;
            base[i] = i;
        }
        head = 0, tail = 0, push(start);
        while (head < tail)
        {
            int u = pop();
            for (int v = 1; v <= n; ++v)
                if (mat[u][v] && base[v] != base[u] && match[v] != u)
                {
                    if (v == start || (match[v] && father[match[v]]))
                        contract(u, v);
                    else
                    {
                        if (father[v] == 0)
                        {
                            if (match[v])
                            {
                                push(match[v]);
                                father[v] = u;
                            }
                            else
                            {
                                father[v] = u;
                                return v;
                            }
                        }
                    }
                }
        }
        return 0;
    }

    void augment(int finish)
    {
        int u = finish, v, w;
        while (u)
        {
            v = father[u];
            w = match[v];
            match[u] = v;
            match[v] = u;
            u = w;
        }
    }

    int graph_max_match()
    {
        int ans = 0;
        for (int i = 1; i <= n; ++i)
            if (match[i] == 0)
            {
                int finish = find_augment(i);
                if (finish)
                {
                    augment(finish);
                    ans += 2;
                }
            }
        return ans;
    }
} g;

int Graph :: bcnt = 0, Graph :: pcnt = 0;

int main()
{
    int n;
    scanf("%d", &n);
    g.init(n);
    int a, b;
    while (scanf("%d%d", &a, &b) != EOF)
        g.add_edge(a, b);
    printf("%d\n", g.graph_max_match());
    for (int i = 1; i <= n; ++i)
        if (g.match[i])
        {
            printf("%d %d\n", i, g.match[i]);
            g.match[g.match[i]] = 0;
        }
    return 0;
}

LLawliet 2011-10-15 22:16 发表评论

JOJ1871:Jogging Trails

LLawliet — Sat, 15 Oct 2011 14:13:00 GMT

1871: Jogging Trails

Result	TIME Limit	MEMORY Limit	Run Times	AC Times	JUDGE
	3s	8192K	59	17	Standard

Gord is training for a marathon. Behind his house is a park with a large network of jogging trails connecting water stations. Gord wants to find the shortest jogging route that travels along every trail at least once.

Input consists of several test cases. The first line of input for each case contains two positive integers: n <= 15, the number of water stations, and m < 1000, the number of trails. For each trail, there is one subsequent line of input containing three positive integers: the first two, between 1 and n, indicating the water stations at the end points of the trail; the third indicates the length of the trail, in cubits. There may be more than one trail between any two stations; each different trail is given only once in the input; each trail can be travelled in either direction. It is possible to reach any trail from any other trail by visiting a sequence of water stations connected by trails. Gord's route may start at any water station, and must end at the same station. A single line containing 0 follows the last test case.

For each case, there should be one line of output giving the length of Gord's jogging route.

Sample Input

Output for Sample Input

古老的图论问题：中国邮递员问题，曾经在某个图论书上看过，之后就没有之后了......

题目大意很简单：给一无向网络N，从点1出发，每条边至少进过一次后回到点1。
思路：（copy别人的）
1. 先解释下"度"的概念, 对于无向图中某结点, 它和n条边相连, 就称它的度为n. (有向图还分出度入度, 这里简化了, 不管)

2. 参考欧拉回路的概念, 无向图存在欧拉回路, 当前仅当所有点度数均为偶数.
证明比较简单, 因为走完一条回路, 对于所有点均进去一次, 出来一次. 故, 对于任意点的度数,都是成对的在"消耗".

3. 题中所描述的回路, 有重复经过某边, 这没关系. 现在假设邮递员按题目要求走了一条最短的回路P.
那么, 把P所有重复经过的边, 拆开. 即假设三次经过边L, 则我们可以人为的在原图上多加两条边, 对于所有重复经过的边都这样做. 修改后的图记为G2. (原图为G)
对于G2, 邮递员走的回路, 即为此图的欧拉回路. 这是重点. (其实很好想, 因为G2中的每条边都仅被邮递员走过一次.)

4. 原问题就可以转化为, 如何把G添加一些边, 变成G2
而G2所有点度数均为偶数(这是肯定的, 因为G2存在欧拉回路)
故转化为, 如何把G中某些边复制x次, 从而消灭G中的奇点(度数为奇数的点).

5. 可能有点晕, 举个例子
图G只有两个点a和b, 一条边连着ab, 那么ab均为奇点, 要消灭掉, 就把ab之间连线复制一次(因为你不可能随便给它加一条不存在的..)
然后变成两条边连着ab. 从G2的角度看, 是欧拉图了, 对应成G, 就是把这条边走了两次而已.

6. 奇点总是成对的被消灭, 就算两个奇点不互通, 而是经过很多点才能连通, 那也要连出一条路径来, 以消灭这对奇点.

7. 那就好办了.把所有奇点找出来, 然后配对, 如果某种配对方式代价最小, 即为所求.
这里还要用上floyd, 求最短路

8. 配对算法也要比较好, 裸着配大概会超时, 这个懒得说了.. 如果不会, 直接看代码吧.

给点扼要注释, deg记录度数, mp记录最短路. u记录递归时各点是否已配对. (偶点直接被记为已配对. 递归时只路过)
dfs返回在当前此种u记录的配对情况下, 把未配对的匹配完, 最小代价是多少

还是提一句吧, 每次配对时, 配对中的第一个可以直接取队列中的第一个没有配对的元素(其实随便取都行). 第二个, 循环一次剩下的即可.
因为配对是不关心顺序的, 所以第一个可以想怎么取都行. 为了方便, 就第一个了.

代码：

#include <cstdio>
#include <cstring>
#include <cmath>
#include <iostream>
#define N 17
#define inf 1 << 20
using namespace std;

int deg[N], map[N][N], u[N];
int ans, n, m;

int min(int a, int b)
{
    if (a > b) return b;
    return a;
}

int slove()
{
    int i, j, rnt = inf;
    for (i = 0; i < n; ++i)
    if (!u[i]) break;
    if (i == n) return 0;
    u[i] = 1;
    for (j = i + 1; j < n; ++j)
    {
        if (!u[j]) u[j] = 1, rnt = min(rnt, slove() + map[i][j]), u[j] = 0;
    }
    u[i] = 0;
    return rnt;
}

int main()
{
    while (scanf("%d", &n) && n)
    {
        memset(u, 0, sizeof(u));
        memset(deg, 0, sizeof(deg));
        for (int i = 0; i < n; ++i)
            for (int j = 0; j < n; ++j)
            map[i][j] = inf;
        ans = 0;
        scanf("%d", &m);
        for (int i = 1; i <= m; ++i)
        {
            int a, b, c;
            scanf("%d%d%d", &a, &b, &c);
            ans += c;
            a--; b--;
            deg[a]++;
            deg[b]++;
            map[a][b] = map[b][a] = min(map[a][b], c);
        }
        for (int k = 0; k < n; ++k)
            for (int i = 0; i < n; ++i)
                for (int j = 0; j < n; ++j)
                {
                    map[i][j] = min(map[i][j], map[i][k] + map[k][j]);
                }
        for (int i = 0; i < n; ++i)
        if (deg[i] % 2 == 0) u[i] = 1;
        printf("%d\n", ans + slove());
    }
    return 0;
}

LLawliet 2011-10-15 22:13 发表评论

ZOJ2697:Electricity

LLawliet — Sat, 15 Oct 2011 14:12:00 GMT

Electricity

Time Limit: 10 Seconds Memory Limit: 32768 KB Special Judge

After recent blackouts in some regions in North America, the government has decided to reorganize the power supply network of the continent.

The power supply network is the set of nodes, such as power plants or transformation stations, connected by transmission lines. All lines are used to transmit electricity from one node to another. For stability reasons the system is organized in such a way that there are no directed cycles.

Since the government is currently short of money due to several small peaceful militaristic operations, it cannot build new power lines for the moment. So after reorganization the same lines will be used, but some lines will have to transmit electricity in the direction opposite to the current one. To make the reorganization gentle enough, the management of the power network is planning to switch the transmission direction for exactly one line each day. Of course, no day there must be a cycle in a network, since this may cause damage to the system. The resulting network is also designed to be acyclic.

Help them to plan the reorganization.

Input

There are mutilple cases in the input file.

The first line of the input file contains n --- the number of nodes in the network, and m --- the number of transmission lines (2 <= n <= 1,000 , 1 <= m <= 10,000 ). The following m lines contain three integer numbers each. The first two give the source and the destination node for the corresponding line in the current node. The third number is 0 if the line must keep its transmission direction in the resulting network, and 1 if the direction must be reversed.

There can be several lines connecting the same pair of nodes, but due to acyclicity condition, they all transmit electricity in the same direction. This is also the reason why no line connects a node to itself.

There is an empty line after each case.

Output

First output k --- the number of days in the plan you suggest. You don't need to minimize this number, but it must not exceed 4m . After that print k integer numbers --- for each day output the number of the line that changes the transmission direction this day. If it is impossible to make the desired reorganization, output -1 instead of k .

There should be an empty line after each case.

Sample Input

Sample Output

Source: Andrew Stankevich's Contest #9

一道不错的图论题，大意是给一个有向网络N，必须将其中X条边反向，给出一个方案顺序，使得在执行反向的过程中，网络不会出现环，如果不存在这个方案，输出-1.

思路：首先，判断不存在的情况：1.两个重边都要反转，那么在操作过程中肯定出现环；2.在初始网络或结束网络存在环。对于第二种情况，可以用topo排序求一下两个网络是否存在环，并记录下topp序列。
之后，我们要构造方案，构造方案的过程有两个：
1.一个点的可逆入度边（这句是废话，可逆边就是必须改变的边，肯定包含于方案，但注意是入度）
2.这个点必须从结尾网络的topo序列从后往前搜索.....（凌乱了吧....）
首先，我们要明白topo序列的性质，就是序列a1,a2,a3,...,an，表示的是网络n个点的线性关系，存在任意的i aj，也就是，如果用网络表示topo序列，那么只有往右边指向的边。
通过这一个性质，加上网络N前后两次的topo序列，我们不难发现，结尾网络topo序列的最后一个肯定是在操作中失去出度而从初始的topo序列降为（或停留）最后面，所以，将其可反转的入度边反向，肯定不会存在回射边从而产生环结构，因此，从最后一个点向前搜索，每次执行可执行的反转操作，那么一定能保持当前点的不存在回射边。
对于一个点，可存在同时支配多条可反转边，因为答案要求一次一次执行反转，如果对于同一个点顺序不当可能出现环，所以我们考虑以下问题：x->y, x->z,如果反转（x,y）从而导致了环的出现，那么可以肯定z->y是成立的，而在topo关系上z比y靠前，所以我们对于同一个点输出结果时，要按照其初始网络的topo顺序，从左向右输出。
思路完毕，AC，证明....略了吧，我证明了一草稿纸。
注意不要用矩阵，我因为那个吃了几次CE......
代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
#include <vector>
#define N 1100
#define M 10010
using namespace std;

int n, m;

struct edge
{
    int u, v, next;
} et[2][M];

int eh[2][N], tot[2];
int be[2 * N], ed[2 * N], sta[2 * N];
int deg[2][N], deg2[N];
int g[N][N];

void add(int u, int v, int i)
{
    int t = ++tot[i];
    et[i][t].u = u;
    et[i][t].v = v;
    et[i][t].next = eh[i][u];
    eh[i][u] = t;
    deg[i][v]++;
}

int topo(int eh[], edge et[], int que[], int deg[])
{
    int i, j, k, top = -1, qt = 0;
    for (i = 1; i <= n; ++i)
        deg2[i] = deg[i];
    for (i = 1; i <= n; ++i)
        if (deg2[i] == 0)
            sta[++top] = i;
    for (j = 1; j <= n; ++j)
    {
        if (top == -1) return 0;
        int u = sta[top--];
        que[qt++] = u;
        for (i = eh[u]; i != -1; i = et[i].next)
        {
            deg2[et[i].v]--;
            if (deg2[et[i].v] == 0) sta[++top] = et[i].v;
        }
    }
    return 1;
}

int was[M], cnt;
void slove()
{
    int i, j, k;
    memset(was, 0, sizeof(was));
    printf("%d\n", cnt);
    for (i = n - 1; i >= 0; --i)
    {
        int u = ed[i];
        for (j = 0; j < n; ++j)
          if (g[u][be[j]] > 0)
          {
              if (was[g[u][be[j]]] == 0)
              {
                  was[g[u][be[j]]] = 1;
                  printf("%d ", g[u][be[j]]);
              }
          }
    }
    if (cnt > 0) printf("\n");
}

int main()
{
    int i, j, k;
    while (scanf("%d%d", &n, &m) != EOF)
    {
        memset(eh, -1, sizeof(eh));
        memset(deg, 0, sizeof(deg));
        for (i = 1; i <= n; ++i)
          for (j = 1; j <= n; ++j)
            g[i][j] = 0;
        tot[1] = tot[0] = 0;
        cnt = 0;
        int flag = 1;
        for (i = 1; i <= m; ++i)
        {
            int a, b, c;
            scanf("%d%d%d", &a, &b, &c);
            add(a, b, 0);
            if (c)
            {
                add(b, a, 1);
                cnt++;
                if (g[a][b] > 0) flag = 0;
                g[a][b] = i;
            }
            else
              add(a, b, 1);
        }
        if (flag == 0)
        {
            printf("-1\n\n");
            continue;
        }
        int first = topo(eh[0], et[0], be, deg[0]);
        int last = topo(eh[1], et[1], ed, deg[1]);
        if (!(first && last))
        {
            printf("-1\n\n");
            continue;
        }
        slove();
        printf("\n");
    }
    return 0;
}

LLawliet 2011-10-15 22:12 发表评论