洛谷 P1841 [JSOI2007]重要的城市 解题报告

P1841 [JSOI2007]重要的城市

题目描述

参加jsoi冬令营的同学最近发现，由于南航校内修路截断了原来通向计算中心的路，导致去的路程比原先增加了近一公里。而食堂门前施工虽然也截断了原来通向计算中心的路，却没有使路程增加，因为可以找到同样长度的路作替代。其实，问题的关键在于，路截断的地方是交通要点。

同样的情况也出现在城市间的交通中。某些城市如果出了问题，可能会引起其他很多城市的交通不便。另一些城市则影响不到别的城市的交通。jsoi冬令营的同学发现这是一个有趣的问题，于是决定研究这个问题。

他们认为这样的城市是重要的：如果一个城市c被破坏后，存在两个不同的城市a和b（a, b均不等于c），a到b的最短距离增长了（或不通），则城市c是重要的。

jsoi冬令营的同学面对着一张教练组交给他们的城市间交通图，他们希望能找出所有重要的城市。现在就请你来解决这个问题。

输入输出格式

输入格式：

第一行两个整数N,M,N为城市数，M为道路数

接下来M行，每行三个整数，表示两个城市之间的无向边，以及之间的路的长度

输出格式：

一行，按递增次序输出若干的数，表示重要的城市。

说明

30%的数据： \(N\le 20\)；

60%的数据： \(N\le 100\)；

100%的数据： \(N\le 200,M\le \frac{N\times (N-1)}{2},0<c\le 10000\)。c即路的长度。

保证不出现重边和自环

如果没有点的话需要输出一行

“No important cities.”

去掉引号

---

这个题很神奇

先说说普遍的\(O(N^3)\)的做法。

一个点\(i\)称为重要点的要求：存在一对点\((u,v)\)，这对点的所有最短路都经过这个点\(i\)

考虑floyd松弛的过程，如果点\(i\)松弛成功\((u,v)\)，说明\(i\)至少在前\(i\)个点松弛过后的最短路上，我们先把它存起来，没错只存它（其实用bitset把所有的点存下来复杂度也是可行的而且跑到飞快），如果没松弛成功且刚好相等，那这个点被开除重要点了，不满足唯一性，踢掉。

其实说起来很不清楚，但我们大致可以感性理解。

关于为什么这样不会漏点，因为之前的点已经存了。比如说1-4被3松弛，存下\(point[1][4]=3\)，而1-4最短路上其实有1,2,3,4这几个点，不过我们已经在1,3时存下了2，因此这样其实会有重复，所以我们最后统计时去个重。

Code:

#include <cstdio>
#include <cstring>
#include <algorithm>
const int N=202;
int g[N][N],n,m,point[N][N],ans[N*N],cnt;
int main()
{
    scanf("%d%d",&n,&m);
    memset(g,0x3f,sizeof(g));
    for(int u,v,w,i=1;i<=m;i++)
    {
        scanf("%d%d%d",&u,&v,&w);
        g[u][v]=g[v][u]=w;
    }
    for(int k=1;k<=n;k++)
    {
        for(int i=1;i<=n;i++)
        {
            if(i==k) continue;
            for(int j=1;j<=n;j++)
            {
                if(j==i||j==k) continue;
                if(g[i][j]>g[i][k]+g[k][j])
                {
                    g[i][j]=g[i][k]+g[k][j];
                    point[i][j]=k;
                }
                else if(g[i][j]==g[i][k]+g[k][j])
                    point[i][j]=0;
            }
        }
    }
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
            if(point[i][j])
                ans[++cnt]=point[i][j];
    if(!cnt) printf("No important cities.\n");
    std::sort(ans+1,ans+1+cnt);
    cnt=std::unique(ans+1,ans+1+cnt)-(ans+1);
    for(int i=1;i<=cnt;i++)
        printf("%d ",ans[i]);
    return 0;
}

---

再提供一个比较好理解的\(O(n^3logn)\)的分治算法

在Floyd松弛的过程中，其实哪个点先松弛哪个点后松弛是无所谓的哈

而我们最后拆点走其实就是只有一个点不松弛和所有点都松弛情况的一个对比，看各点的最短路情况有没有改变

对未松弛点集\([l,r]\)

我们可以先松弛其中的一半\([l,mid]\)，然后去另一半处理子问题，处理完了还原左区间，松弛右区间，再去左边处理问题

这样当区间大小为1时，就只是那个点没有参与松弛，我们对比一下即可

而对每个相同大小的区间构成的集合，它们实际上总共用了每个点松弛了一次，为\(O(N^3)\)（还原是\(O(N^2)\)的，算做常数）

一共有\(logn\)种大小的区间，所以总复杂度为\(O(N^3logn)\)

Code:

#include <cstdio>
#include <cstring>
int min(int x,int y){return x<y?x:y;}
const int N=202;
int g[N][N],n,m,flag,ans[N],d[N][N];
void divide(int l,int r)
{
    if(l==r)
    {
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
                if(i!=j&&g[i][j]<d[i][j])
                {
                    ans[l]=1;
                    flag=1;
                    return;
                }
        return;
    }
    int tmp[N][N];
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
            tmp[i][j]=d[i][j];
    int mid=l+r>>1;
    for(int k=l;k<=mid;k++)
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
                d[i][j]=min(d[i][j],d[i][k]+d[k][j]);
    divide(mid+1,r);
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
            d[i][j]=tmp[i][j];
    for(int k=mid+1;k<=r;k++)
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
                d[i][j]=min(d[i][j],d[i][k]+d[k][j]);
    divide(l,mid);
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
            d[i][j]=tmp[i][j];
}
int main()
{
    scanf("%d%d",&n,&m);
    memset(g,0x3f,sizeof(g));
    memset(d,0x3f,sizeof(d));
    for(int u,v,w,i=1;i<=m;i++)
    {
        scanf("%d%d%d",&u,&v,&w);
        d[u][v]=d[v][u]=g[u][v]=g[v][u]=w;
    }
    for(int k=1;k<=n;k++)
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
                g[i][j]=min(g[i][j],g[i][k]+g[k][j]);
    divide(1,n);
    if(!flag) printf("No important cities.\n");
    for(int i=1;i<=n;i++)
        if(ans[i])
            printf("%d ",i);
    return 0;
}

---

2018.8.4