团体程序设计天梯赛-练习集 L3-005. 垃圾箱分布 dijkstra 解题报告

L3-005. 垃圾箱分布

时间限制

200 ms

内存限制

65536 kB

代码长度限制

8000 B

判题程序

Standard

作者

陈越

大家倒垃圾的时候，都希望垃圾箱距离自己比较近，但是谁都不愿意守着垃圾箱住。所以垃圾箱的位置必须选在到所有居民点的最短距离最长的地方，同时还要保证每个居民点都在距离它一个不太远的范围内。

现给定一个居民区的地图，以及若干垃圾箱的候选地点，请你推荐最合适的地点。如果解不唯一，则输出到所有居民点的平均距离最短的那个解。如果这样的解还是不唯一，则输出编号最小的地点。

输入格式：

输入第一行给出4个正整数：N（<= 10³）是居民点的个数；M（<= 10）是垃圾箱候选地点的个数；K（<= 10⁴）是居民点和垃圾箱候选地点之间的道路的条数；D_S是居民点与垃圾箱之间不能超过的最大距离。所有的居民点从1到N编号，所有的垃圾箱候选地点从G1到GM编号。

随后K行，每行按下列格式描述一条道路：
P1 P2 Dist
其中P1和P2是道路两端点的编号，端点可以是居民点，也可以是垃圾箱候选点。Dist是道路的长度，是一个正整数。

输出格式：

首先在第一行输出最佳候选地点的编号。然后在第二行输出该地点到所有居民点的最小距离和平均距离。数字间以空格分隔，保留小数点后1位。如果解不存在，则输出“No Solution”。

输入样例1：

4 3 11 5
1 2 2
1 4 2
1 G1 4
1 G2 3
2 3 2
2 G2 1
3 4 2
3 G3 2
4 G1 3
G2 G1 1
G3 G2 2

输出样例1：

G1
2.0 3.3

输入样例2：

2 1 2 10
1 G1 9
2 G1 20

输出样例2：

No Solution

思路：将垃圾桶编号为1000+i，然后用dijkstra即可

普通的jijkstra：

#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
#define INF 0x3f3f3f3f

int mat[1100][1100], dis[1100];
int n, m, k, d, x, y, v;
///令g1-g10  为 1000 + i

void dijkstra(int s)
{
    int vis[1100] = {0};
    memset(dis, 0x3f, sizeof(dis));
    for(int i = 1; i <= n; i++)
        dis[i] = mat[s][i];
    for(int i = 1001; i <= 1000+m; i++)
        dis[i] = mat[s][i];
    vis[s] = 1;
    dis[s] = 0;
    while(true)
    {
        int k = -1, mixv = INF;
        for(int i = 1; i <= n; i++)
        {
            if(!vis[i] && mixv > dis[i])
            {
                k = i;
                mixv = dis[i];
            }
        }
        for(int i = 1001; i <= 1000 + m; i++)
        {
            if(!vis[i] && mixv > dis[i])
            {
                k = i;
                mixv = dis[i];
            }
        }
        if(k == -1) break;
        vis[k] = 1;
        for(int i = 1; i <= n; i++)
        {
            if(!vis[i] && (dis[i] > dis[k] + mat[k][i]))
            {
                dis[i] = dis[k] + mat[k][i];
            }
        }
        for(int i = 1001; i <= 1000 + m; i++)
        {
            if(!vis[i] && (dis[i] > dis[k] + mat[k][i]))
            {
                dis[i] = dis[k] + mat[k][i];
            }
        }
    }
}


int main()
{
    char sa[10], sb[10];
    memset(mat, 0x3f, sizeof(mat));
    scanf("%d%d%d%d", &n, &m, &k, &d);
    for(int i = 0; i < k; i++)
    {
        x = y = 0;
        scanf("%s %s %d", sa, sb, &v);
        if(sa[0] != 'G')
        {
            for(int j = 0; sa[j]; j++)
                x = x * 10 + sa[j] - '0';
        }
        else
        {
            for(int j = 1; sa[j]; j++)
                x = x * 10 + sa[j] - '0';
            x += 1000;
        }
        if(sb[0] != 'G')
        {
            for(int j = 0; sb[j]; j++)
                y = y * 10 + sb[j] - '0';
        }
        else
        {
            for(int j = 1; sb[j]; j++)
                y = y * 10 + sb[j] - '0';
            y += 1000;
        }
        mat[x][y] = mat[y][x] = v;
    }
    int mini, mind = 0, f, in = -1, sum = INF;
    for(int i = 1; i <= m; i++)
    {
        f = 0;
        dijkstra(1000 + i);
        int tsum = 0, tmd = INF;
        for(int j = 1; j <= n; j++)
        {
            int td = dis[j];
            if(td > d) {f = 1; break;}
            if(tmd > td) tmd = td;
            tsum += td;
        }
        if(!f)
        {
            if(mind < tmd)
            {
                mind = tmd;
                in = i;
                sum = tsum;
            }
            else if(mind == tmd && tsum < sum)
            {
                mind = tmd;
                in = i;
                sum = tsum;
            }
        }

    }
    if(in == -1)
    {
        printf("No Solution\n");
        return 0;
    }
    printf("G%d\n", in);
    printf("%.1lf %.1lf\n", mind * 1.0, sum * 1.0 / n);
    return 0;
}

用优先队列优化的dijkstra，少了20多ms

#include <cstdio>
#include <cstring>
#include <iostream>
#include <queue>
using namespace std;
#define INF 0x3f3f3f3f

int mat[1100][1100], dis[1100];
int n, m, k, d, x, y, v;
///令g1-g10  为 1000 + i

struct hep
{
    int id, val;
    hep(){}
    hep(int _id, int _val):id(_id), val(_val) {}
    bool operator < (const hep& a) const
    {
        return val > a.val;
    }
}h;

void dijkstra(int s)
{
    priority_queue<hep> Q;
    int vis[1100] = {0};
    memset(dis, 0x3f, sizeof(dis));
    for(int i = 1; i <= n; i++)
    {
        dis[i] = mat[s][i];
        Q.push(hep(i, mat[s][i]));
    }

    for(int i = 1001; i <= 1000+m; i++)
    {
        dis[i] = mat[s][i];
        Q.push(hep(i, mat[s][i]));
    }
    vis[s] = 1;
    Q.push(hep(s, 0));
    while(!Q.empty())
    {
        int k = -1, mixv = INF;
        hep h = Q.top();
        Q.pop();
        k = h.id;
        if(k == -1) break;
        vis[k] = 1;
        for(int i = 1; i <= n; i++)
        {
            if(!vis[i] && (dis[i] > dis[k] + mat[k][i]))
            {
                dis[i] = dis[k] + mat[k][i];
                Q.push(hep(i, dis[i]));
            }
        }
        for(int i = 1001; i <= 1000 + m; i++)
        {
            if(!vis[i] && (dis[i] > dis[k] + mat[k][i]))
            {
                dis[i] = dis[k] + mat[k][i];
                Q.push(hep(i, dis[i]));
            }
        }
    }
}


int main()
{
    char sa[10], sb[10];
    memset(mat, 0x3f, sizeof(mat));
    scanf("%d%d%d%d", &n, &m, &k, &d);
    for(int i = 0; i < k; i++)
    {
        x = y = 0;
        scanf("%s %s %d", sa, sb, &v);
        if(sa[0] != 'G')
        {
            for(int j = 0; sa[j]; j++)
                x = x * 10 + sa[j] - '0';
        }
        else
        {
            for(int j = 1; sa[j]; j++)
                x = x * 10 + sa[j] - '0';
            x += 1000;
        }
        if(sb[0] != 'G')
        {
            for(int j = 0; sb[j]; j++)
                y = y * 10 + sb[j] - '0';
        }
        else
        {
            for(int j = 1; sb[j]; j++)
                y = y * 10 + sb[j] - '0';
            y += 1000;
        }
        mat[x][y] = mat[y][x] = v;
    }
    int mini, mind = 0, f, in = -1, sum = INF;
    for(int i = 1; i <= m; i++)
    {
        f = 0;
        dijkstra(1000 + i);
        int tsum = 0, tmd = INF;
        for(int j = 1; j <= n; j++)
        {
            int td = dis[j];
            if(td > d) {f = 1; break;}
            if(tmd > td) tmd = td;
            tsum += td;
        }
        if(!f)
        {
            if(mind < tmd)
            {
                mind = tmd;
                in = i;
                sum = tsum;
            }
            else if(mind == tmd && tsum < sum)
            {
                mind = tmd;
                in = i;
                sum = tsum;
            }
        }

    }
    if(in == -1)
    {
        printf("No Solution\n");
        return 0;
    }
    printf("G%d\n", in);
    printf("%.1lf %.1lf\n", mind * 1.0, sum * 1.0 / n);
    return 0;
}