CodeForces 786B Legacy

Time limit 2000 ms
Memory limit 262144 kB
Source Codeforces Round #406 (Div. 1)
Tags data structures graphs shortest paths *2600
Editorial Announcement (en) Tutorial (en)

解题思路

简直人类智慧。存在那种一个点和另外很多个点连边的情况，而且被给的很多个点的编号都是连续的，于是看题解后学到套上线段树。

是这样的：我们新建一些点，这些点和已有的n个点组成线段树一样的形状，而且边权均为0。因为加边有从一个点到一个区间、一个区间到一个点两种，所以需要两份这样的新点，一份的边从线段树的根指向叶子，另一份从叶子指向根。这样建好图以后，就读入操作。

• 操作一，加一条边。直接加就好。
• 操作二，一个点到一堆点。借助我们初始化时建的图，例如，假设这一堆点是\([1,n]\)所有点，那么我们就可以直接从那一个点连一条边到线段树的树根，这样就能极大地减少边的数量，因为根和下面的叶子之间的边权为0。我们可以像线段树区间更新那样递归下去找合适的节点进行加边。
• 操作三，一堆点到一个点。同理，使用另一棵从叶子到根的线段树树即可。

感觉不知所云，但没时间画图。这里有个有图的版本https://blog.csdn.net/GYH0730/article/details/82181680

还可以把我代码里那些注释掉的调试代码删了，把输出弄到这个画图的网页里面，看看图长啥样，便于理解。记得把1~n号点放在中间，n~5n号点放在上半部分，5n~9n号点放下半部分

源代码

#include<queue>
#include<cstdio>
#include<cstring>
 
const int N=1e5+5;
 
int n,q,s;
struct Edge{
    int nxt,to;
    long long w;
}e[N*50];//我没算，试过20倍不够用RE，100倍MLE，50倍可以AC
int head[N*10],cnt=1;
//代表线段树的点，x+n是根到叶子、x+5*n是叶子到根
//一开始脑抽了，就想着线段树4倍空间，于是叶子到根的部分用x+4n表示，忘了原本的点还有n个，一直wa7，，，
inline void add(int u,int v,long long w)
{
    e[cnt]={head[u],v,w};
    head[u]=cnt++;
}
 
void build(int x,int l,int r)
{
    if(l==r)
    {
        add(x+n,l,0);
        add(l,x+n*5,0);
        return;
    }
    int mid=l+r>>1;
    build(x<<1,l,mid);
    build(x<<1|1,mid+1,r);
    add(x+n,(x<<1)+n,0);
    add(x+n,(x<<1|1)+n,0);
    add((x<<1)+n*5,x+n*5,0);
    add((x<<1|1)+n*5,x+n*5,0);
}
 
void opt2(int x,int l,int r,int ql,int qr,int u,long long w)//点到区间，区间的线段树偏移量+n
{
    if(ql>r||qr<l) return;
    if(ql<=l&&r<=qr)
    {
        add(u,x+n,w);
        return;
    }
    int mid=l+r>>1;
    if(ql<=mid) opt2(x<<1,l,mid,ql,qr,u,w);
    if(qr>mid) opt2(x<<1|1,mid+1,r,ql,qr,u,w);
}
void opt3(int x,int l,int r,int ql,int qr,int v,long long w)//区间到点，区间的线段树偏移量+5n
{
    if(ql>r||qr<l) return;
    if(ql<=l&&r<=qr)
    {
        add(x+n*5,v,w);
        return;
    }
    int mid=l+r>>1;
    if(ql<=mid) opt3(x<<1,l,mid,ql,qr,v,w);
    if(qr>mid) opt3(x<<1|1,mid+1,r,ql,qr,v,w);
}
 
struct Heap{
    int u;
    long long w;
    bool operator < (const Heap & a)const{
        return w>a.w;
    }
}temp;
bool vis[N*10];
long long dis[N*10];
// int pre[N*10];
// void path(int i)
// {
//  if(i!=s)
//      path(pre[i]);
//  printf("%d ",i);
//  return;
// }
void dijkstra()
{
    memset(dis,0x7f,sizeof(dis));
    dis[s]=0;
    std::priority_queue<Heap> q;
    q.push({s,dis[s]});
    while(!q.empty())
    {
        temp=q.top();
        q.pop();
        int u=temp.u;
        if(vis[u]) continue;
        vis[u]=1;
        for(int i=head[u];i;i=e[i].nxt)
        {
            int v=e[i].to;
            if(temp.w+e[i].w<dis[v])
            {
                //pre[v]=u;
                dis[v]=temp.w+e[i].w;
                q.push({v,dis[v]});
            }
        }
    }
    for(int i=1;i<=n;i++)
    {
        //printf("%d: ",i);
        if(dis[i]==0x7f7f7f7f7f7f7f7f) printf("-1 ");
        else printf("%I64d ",dis[i]);//,path(i),puts("");
    }
}
 
/*void debug()
{
    for (int i = 1; i <= n * 10; i++)
    {
        for (int j = head[i]; j; j = e[j].nxt)
        {
            printf("%d %d %lld\n", i, e[j].to, e[j].w);
        }
    }
}*/
 
int main()
{
    scanf("%d%d%d",&n,&q,&s);
    build(1,1,n);
    //debug();
    while(q--)
    {
        int opt,l,r,v;
        long long w;
        scanf("%d",&opt);
        if(opt==1)
        {
            scanf("%d%d%I64d",&l,&v,&w);
            add(l,v,w);
        }
        else if(opt==2)
        {
            scanf("%d%d%d%I64d",&v,&l,&r,&w);
            opt2(1,1,n,l,r,v,w);
        }
        else
        {
            scanf("%d%d%d%I64d",&v,&l,&r,&w);
            opt3(1,1,n,l,r,v,w);
        }
    }
    //debug();
    dijkstra();
    return 0;
}

转载于:https://www.cnblogs.com/wawcac-blog/p/11270738.html