ZOJ-1542

依然是最小生成树。。被这题坑了好多次，首先sample output竟然是错的！！做到现在还没碰到过，第一次碰到。还有个坑是test case不止一个，别被迷惑了，开始我还以为处理一个case就行了，后来看了别人的代码才发现。最关键的问题是我在用prim算法和kruscal算法上纠结了好久。。开始用prim算法提交WA，以为这题不能用prim，后来发现两种算法都是可以的。。我了个去啊，各种坑爹难以言说。。懒的打字了，kruscal算法还没看过，明天看看吧，把剩下的最小生成树题搞搞

#include<stdio.h>
#include<string.h>
#include<stdlib.h>

int main()
{
    int n, m, i, j, x, y, z;
    while (scanf("%d %d", &n, &m) != EOF)
    {
        int **a = malloc((n + 1) * sizeof(int *));
        for (i = 0; i <= n; i++)
        {
            a[i] = malloc((n + 1) * sizeof(int));
            for (j = 0; j <= n; j++)
                a[i][j] = 0;
        }

        while (m--)
        {
            scanf("%d %d %d", &x, &y, &z);
            a[x][y] = z;
        }

        int k[1001], d[1001], p[1001];
        memset(k, 0, 1001 * sizeof(int));
        memset(p, 0, 1001 * sizeof(int));
        for (i = 0; i < 1001; i++)
            d[i] = 9999999;
        d[1] = 0;
        int min, now = 1, next;
        for (i = 1; i <= n; i++)
        {
            k[now] = 1;
            min = 9999999;
            for (j = 1; j <= n; j++)
            {
                if (a[now][j] || a[j][now])
                {
                    int dd = a[now][j] ? a[now][j] : a[j][now];
                    if (!k[j] && dd < d[j])
                    {
                        d[j] = dd;
                        p[j] = now;
                    }
                }
                if (!k[j] && d[j] < min)
                {
                    min = d[j];
                    next = j;
                }
            }
            now = next;
        }

        int maxd = -1;
        for (i = 1; i <= n; i++)
            if (p[i])
            {
                int dd = a[i][p[i]] ? a[i][p[i]] : a[p[i]][i];
                if (dd > maxd)
                    maxd = dd;
            }

        printf("%d\n%d\n", maxd, n - 1);
        for (i = 1; i <= n; i++)
            if (p[i])
            {
                if (a[p[i]][i])
                    printf("%d %d\n", p[i], i);
                else
                    printf("%d %d\n", i, p[i]);
            }

        for (i = 0; i <= n; i++)
            free(a[i]);
        free(a);
    }
    return 0;
}

又用kruskal算法实现了一遍，发现比prim简单，用了不相交集的路径压缩和按秩合并，名字挺唬人，算法导论的算法非常简洁明了，让人一目了然，照着实现了一遍。。不过时间界分析没看。。太复杂了，目前先熟悉算法，上代码

#include<stdio.h>
#include<stdlib.h>

struct VertexStruct
{
    int index;
    struct VertexStruct *parent;
    int rank;
};

typedef struct VertexStruct *Vertex;

struct Edge
{
    Vertex u;
    Vertex v;
    int d;
    int in_tree;
};

Vertex make_set(int index)
{
    Vertex v = malloc(sizeof(struct VertexStruct));
    v->index = index;
    v->parent = v;
    v->rank = 0;
    return v;
}

void link(Vertex x, Vertex y)
{
    if (x->rank > y->rank)
        y->parent = x;
    else
    {
        x->parent = y;
        if (x->rank == y->rank)
            y->rank++;
    }
}

Vertex find_set(Vertex x)
{
    if (x != x->parent)
        x->parent = find_set(x->parent);
    return x->parent;
}

void union_set(Vertex x, Vertex y)
{
    link(find_set(x), find_set(y));
}

int cmp_kruskal(const void *p1, const void *p2)
{
    struct Edge *e1 = (struct Edge *) p1;
    struct Edge *e2 = (struct Edge *) p2;
    return e1->d - e2->d;
}

int main()
{
    int n, m;
    while (scanf("%d %d", &n, &m) != EOF)
    {
        int i;
        Vertex *v_array = malloc(n * sizeof(Vertex));
        struct Edge *e_array = malloc(m * sizeof(struct Edge));
        for (i = 0; i < n; i++)
            v_array[i] = make_set(i + 1);

        for (i = 0; i < m; i++)
        {
            int a, b, c;
            scanf("%d %d %d", &a, &b, &c);
            e_array[i].u = v_array[a - 1];
            e_array[i].v = v_array[b - 1];
            e_array[i].d = c;
            e_array[i].in_tree = 0;
        }

        qsort(e_array, m, sizeof(struct Edge), cmp_kruskal);

        int max;
        for (i = 0; i < m; i++)
        {
            struct Edge *e = &e_array[i];
            if (find_set(e->u) != find_set(e->v))
            {
                e->in_tree = 1;
                union_set(e->u, e->v);
                max = e->d;
            }
        }

        printf("%d\n%d\n", max, n - 1);
        for (i = 0; i < m; i++)
        {
            struct Edge *e = &e_array[i];
            if (e->in_tree)
                printf("%d %d\n", e->u->index, e->v->index);
        }

        for (i = 0; i < n; i++)
            free(v_array[i]);
        free(v_array);
        free(e_array);
    }
    return 0;
}