poj 3013 Big Christmas Tree

最新推荐文章于 2018-07-18 16:51:21 发布

转载最新推荐文章于 2018-07-18 16:51:21 发布 · 60 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/scau20110726/archive/2013/05/06/3063401.html

本文探讨了一道关于选择边构建一棵树的问题，通过分析得出利用最短路径算法求解最优解的方法。讨论了使用Dijkstra算法的不同实现方式及其性能表现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

最短路

题意：给n个点从1到n标号，下面一行是每个点的权，另外给出m条边，下面是每条边的信息，两个端点+权值，边是无向边。你的任务是选出一些边，使这个图变成一棵树。这棵树的花费是这样算的，1号固定为树根，树中每个双亲节点下面的边都有个单价（即边权），然后单价乘上这条边的下面所有的子孙后代的点权和（看sample2，只要除掉边 1 5 9 按照这个方法就能算出1210）

分析：把sample2用式子列一下就能发现，每个点的权都要乘上好几条边的权，是哪几条边呢，就是这个点回到点1的路径上的那些边

所以最后的树的花费可以写成 res = sum{ (点权) * (该点回到点1的路径的边权和) } ，这些点是2到n，1是不用算的

所以决定这条式子大小的，只有 (该点回到点1的路径的边权和) ，只要能让它最小即可。令到每个点回到点1的路径边权和最小是什么？就是最短路啊！

所以从点1运行一次最短路，就可以知道1到每个点的最短路（也就是每个点到点1的最短路，因为无向图）

但是要注意一个坑，没看清楚题意，超时了很多次，就是点数可能为0（太坑了），点数为0运行不了最短路一直卡在里面，所以特判一下，输出0，如果点数1同样也是0的，因为整个树不会有边

另外注意网上的各种说法

1.有人说dij过不了，是能过的

2.有人说dij要手写heap才能过，直接用STL的优先队列也是能过的

3.spfa能过

4.这题没试过用vector建图，建议不要，可能真的是过不了，毕竟点很多

这个是dij+stl优先队列

#include <cstdio>
#include <cstring>
#include <utility>
#include <queue>
#include <vector>
using namespace std;
const int N = 50010;
const __int64 INF = 10000000000;

int n,tot;
__int64 d[N];
int val[N];
int head[N];
bool done[N];
struct edge
{
    int u,v,w,next;
}e[2*N];
typedef pair<__int64,int>plli;
priority_queue<plli , vector<plli> , greater<plli> > q;


void add(int u ,int v , int w , int k)
{
    e[k].u = u; e[k].v = v; e[k].w = w;
    e[k].next = head[u]; head[u] = k++;
    u = u^v;  v = u^v;  u = u^v;
    e[k].u = u; e[k].v = v; e[k].w = w;
    e[k].next = head[u]; head[u] = k++;
}

__int64 Dij()
{
    int count = 0;
    __int64 res = 0;
    d[1] = 0;
    q.push(make_pair(d[1] , 1));
    while(!q.empty())
    {
        int u,v,w;
        plli x = q.top();
        q.pop();
        u = x.second;
        if(done[u]) continue;
        done[u] = true;
        count++;
        res += d[u] * val[u];
        for(int k=head[u]; k!=-1; k=e[k].next)
        {
            v = e[k].v;
            w = e[k].w;
            if(d[u] + w < d[v])
            {
                d[v] = d[u] + w;
                q.push(make_pair(d[v] , v));
            }
        }
    }
    if(count < n) return -1;
    else          return res;
    //熟悉heap+dij的本质，可以在dij过程中就统计出所有点的最短路和并乘上他们的权
    //不需要dij结束后去扫描一次所有点来计算，并且可以在dij过程判断是否能构成一棵树
}

int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&n,&tot);
        for(int i=1; i<=n; i++)
            scanf("%d",&val[i]);

        while(!q.empty()) q.pop();
        for(int i=1; i<=n; i++)
        {
            head[i] = -1;
            d[i] = INF;
            done[i] = false;
        }

        for(int i=1; i<=2*tot; i+=2)
        {
            int u,v,w;
            scanf("%d%d%d",&u,&v,&w);
            add(u,v,w,i);
        }
        if(n == 0 || n == 1) //注意这个坑，会超时，出现n=0点的时候
        {
            printf("0\n");
            continue;
        }
        __int64 res = Dij();
        if(res != -1) printf("%I64d\n",res);
        else          printf("No Answer\n");
    }
    return 0;
}

2.dij+手写heap，复习嘛，复习嘛，又很久没手写过heap了，手写的只比STL快了20ms

#include <cstdio>
#include <cstring>
#include <utility>
using namespace std;
const int N = 50010;
const __int64 INF = 10000000000;

int n,tot;
__int64 d[N];
__int64 val[N];
int head[N];
bool done[N];
struct edge
{
    int u,v,next;
    __int64 w;
}e[2*N];
typedef pair<__int64,int>plli;

plli heap[2*N];
int num;


void add(int u ,int v , __int64 w , int k)
{
    e[k].u = u; e[k].v = v; e[k].w = w;
    e[k].next = head[u]; head[u] = k++;
    u = u^v;  v = u^v;  u = u^v;
    e[k].u = u; e[k].v = v; e[k].w = w;
    e[k].next = head[u]; head[u] = k++;
}

int cmp(plli x , plli y)
{//x的最短路径估计值小，则返回1，否则返回0
    return x.first < y.first;
}

plli top()
{
    return heap[1];
}

void push(plli x)
{
    int par,son;
    plli temp = x;
    heap[++num] = x;
    for(son = num , par=son/2; son > 1; son=par , par = son/2)
    {
        if(cmp(temp , heap[par])) //儿子更小，向上移动
            heap[son] = heap[par]; //父亲滑下来覆盖儿子
        else break; //终于儿子已经比父亲大了，那么不用再比较了
    }
    heap[son] = temp;
}

void pop()
{
    int son,par;
    plli temp;
    heap[1] = heap[num--];
    temp = heap[1];
    for(par=1 , son=par*2; son<=num; par=son , son=par*2)
    {
        if(son < num && cmp(heap[son+1] , heap[son]))
            son++;
        if(cmp(temp , heap[son]))
            break;
        heap[par] = heap[son];
    }
    heap[par] = temp;
}

__int64 Dij()
{
    int count = 0;
    __int64 res = 0;
    d[1] = 0;
    push(make_pair(d[1] , 1));
    while(num>0)
    {
        int u,v;
        __int64 w;
        plli x = top();
        pop();
        u = x.second;
        if(done[u]) continue;
        done[u] = true;
        count++;
        res += d[u] * val[u];
        for(int k=head[u]; k!=-1; k=e[k].next)
        {
            v = e[k].v;
            w = e[k].w;
            if(d[u] + w < d[v])
            {
                d[v] = d[u] + w;
                push(make_pair(d[v] , v));
            }
        }
    }
    if(count < n) return -1;
    else          return res;
}

int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&n,&tot);
        for(int i=1; i<=n; i++)
            scanf("%I64d",&val[i]);
        if(n == 0 || n == 1)
        {
            printf("0\n");
            continue;
        }
        num = 0;
        for(int i=1; i<=n; i++)
        {
            head[i] = -1;
            d[i] = INF;
            done[i] = false;
        }

        for(int i=1; i<=2*tot; i+=2)
        {
            int u,v;
            __int64 w;
            scanf("%d%d%I64d",&u,&v,&w);
            add(u,v,w,i);
        }
        __int64 res = Dij();
        if(res != -1) printf("%I64d\n",res);
        else          printf("No Answer\n");
    }
    return 0;
}

转载于:https://www.cnblogs.com/scau20110726/archive/2013/05/06/3063401.html