[20191004机房测试] ZGY的早餐

ZGY 每天早上要从宿舍走路到机房,顺便从学校小卖部购买早饭,当然机智的 ZGY 一定会走最短路
学校的路可以看成一无向联通张图,图上有 n 个点,m 条边,每一个点都有一个唯一的编号 1~n
每一条边有一个边权,表示两个点之间的距离,ZGY 的宿舍在 S 点,机房在 T点,而小卖部在 H 点
现在 ZGY 想知道从宿舍经过小卖部到达机房的最短距离
不过因为在这个世界上有 Q个 ZGY,所以你必须回答 Q 个问题

很棒的数据分治题
读入里面说了会读入测试点编号……
其实是很明显的暗示了……

一半的数据保证是连通图,1 ≤ n ≤ 200,1 ≤ Q ≤ 10^5
这么小的n,直接Floyd跑一遍就好了,相当于Floyd的板子题

另一半的数据保证图连通,无环,1 ≤ n ≤ 10^5,1 ≤ Q ≤ 10^5
联通图无环……那不就是一棵树吗!
dfs预处理出到根节点的距离和LCA,每次询问输出就好

代码:

#include<bits/stdc++.h>
#define ll long long
#define inf 1000000000000000000
using namespace std;

int t,n,m,u,v,w;
int q,S,H,T;

struct Edge
{
    int next,to,dis;
}edge[1000005];
int cnt=0,head[100005];

inline void add_edge(int from,int to,int dis)
{
    edge[++cnt].next=head[from];
    edge[cnt].to=to;
    edge[cnt].dis=dis;
    head[from]=cnt;
}

template<class T>inline void read(T &res)
{
    char c;T flag=1;
    while((c=getchar())<'0'||c>'9')if(c=='-')flag=-1;res=c-'0';
    while((c=getchar())>='0'&&c<='9')res=res*10+c-'0';res*=flag;
}

ll dis[205][205];
void Floyd()
{
    for(register int k=1;k<=n;++k)
        for(register int i=1;i<=n;++i)
            for(register int j=1;j<=n;++j)
                dis[i][j]=min(dis[i][j],dis[i][k]+dis[k][j]);
}

ll dep[100005];
ll ldep[100005];
int anc[400005][25];
void dfs(int u,int fa)
{
    anc[u][0]=fa;
    for(int i=1;i<=20;i++) anc[u][i]=anc[anc[u][i-1]][i-1];
    for(register int i=head[u];i;i=edge[i].next)
    {
        int v=edge[i].to;
        if(v==fa) continue;
        if(dep[v]>dep[u]+edge[i].dis)
        {
            dep[v]=dep[u]+edge[i].dis;
            ldep[v]=ldep[u]+1;
            dfs(v,u);
        }
    }
}

int LCA(int x,int y)
{
    if(ldep[x]<ldep[y]) swap(x,y);
    int deltaDep=ldep[x]-ldep[y];
    for(int i=0;deltaDep;deltaDep>>=1,i++)
        if(deltaDep&1) x=anc[x][i];
    if(x==y) return x;
    for(int i=20;anc[x][0]!=anc[y][0];i--)
    {
        if(anc[x][i]!=anc[y][i])
        {
            x=anc[x][i];
            y=anc[y][i];
        }
    }
    return anc[x][0];
}

ll Dis(int u,int v) {return dep[u]+dep[v]-2LL*dep[LCA(u,v)];}

int main()
{
    freopen("mindis.in","r",stdin);
    freopen("mindis.out","w",stdout);
    read(t);read(n);read(m);
    if(1<=t&&t<=5)
    {
        for(register int i=1;i<=n;++i)
            for(register int j=1;j<=n;++j)
                if(i!=j) dis[i][j]=inf;
        for(register int i=1;i<=m;++i)
        {
            read(u);read(v);read(w);
            dis[u][v]=dis[v][u]=w;
        }
        Floyd();
        read(q);
        while(q--)
        {
            read(S);read(H);read(T);
            printf("%lld\n",dis[S][H]+dis[H][T]);
        }
    }
    else if(6<=t&&t<=10)
    {
        for(register int i=1;i<=m;++i)
        {
            read(u);read(v);read(w);
            add_edge(u,v,w);
            add_edge(v,u,w);
        }
        for(register int i=1;i<=n;++i) dep[i]=ldep[i]=inf;
        dep[1]=0;
        ldep[1]=1;
        dfs(1,0);
        read(q);
        while(q--)
        {
            read(S);read(H);read(T);
            printf("%lld\n",Dis(S,H)+Dis(H,T));
        }
    }
    return 0;
}

原文地址:https://www.cnblogs.com/tqr06/p/11622898.html

时间: 2024-10-03 07:08:31

[20191004机房测试] ZGY的早餐的相关文章

[20191004机房测试] 三角

有一个 n 层的数字三角形 每次可以从第 i 层的第 j 个走到第 i + 1 层的第 j 个或是第 j +1 个,直到走到第 n 层 从第 1 层走到第 n 层的一种方案成为一条路径,路径的权值为路径上点权值之和 求权值前 k 大的路径(存在多个正确答案) 20分做法: 枚举二进制串,暴力枚举所有走法 复杂度:\(\Theta(2^n)\) 60分做法: 对每个点开一个堆,维护从下往上的前k大值,由于只和下一层有关,可以滚动 复杂度:\(\Theta(n^3\log{(n)})\) 100分做

[20191004机房测试] C++锦标赛

有一个比赛已经有 n 个人参加,并且互相之间已经进行了比赛 每一个人都有一个得分用于最后排名 你作为第 n + 1 个参赛者,需要与之前的每一个人打一场比赛,初始得分为 0 对于每场比赛,有两个人参加,不会存在平局,胜者得分增加 1,败者得分不变 最后按照得分从高到低来排名,假设有人与你最终得分相同 那么如果那个人曾经输给了你就会排在你后面,否则会排在你的前面 如果你赢了某个人,就需要消耗相应的 RP 值 现在你可以决定赢那些人,求最少需要消耗多少 RP 值才能到前k名 50分做法:还是枚举二进

机房测试3:ZGY的早餐(Floyd+倍增)

题目: 分析: 由数据范围可知:前五个点是Floyd,后五个点是一颗树,两两点之间的路径是唯一的,只需要求lca即可. Floyd注意实现细节: 1.初始化时要把dis[i][i]赋成0 2.只有1个dis数组 倍增注意: 统计答案的时候要先统计在跳fa!! #include<bits/stdc++.h> using namespace std; #define ll long long #define N 1005 #define nn 100005 #define M 250005 #de

Host1Plus主机商8个机房测试IP体验

Host1Plus商家也算是比较老的海外主机商(英国),当初进入中国市场也是比较早的,记得那时候支持支付宝的海外主机商尤其的深受用户喜欢.因为我 们大部分网友.站长最多有一个支付宝,很少有双币信用卡或者贝宝支付美元的能力.不过后来几年,HOST1PLUS商家逐渐的落寞,主要原因在于其他商家 的出现,以及他们本身营销能力和产品的策略. 尤其是提供的虚拟主机和VPS主机,价格和方案不是太符合中国用户的口味,配置比较低,而且机房较 少.不过商家应该意识到这一点,在最近2年改动挺大的,今天公司业务正好有

机房测试9.22

题解之前 中秋只有一天假! build 以为并查集水题,发现有历史版本,于是可持久化并查集一波(爆0了) 其实有简单点的做法:用二元组记录每一次变化的siz和fa,二分查询即可. 我还在肝可持久并查集,所以就没有代码了. #include<iostream> #include<cstdio> #include<cstring> #include<algorithm> #include<vector> using namespace std; co

机房测试9.23

题解之前 今天还行啊. Set 肯定要取模. 开始还在想vector这种操作,后来一个dalao发现一定有解,然后有发现一定有一种答案是连续的一段区间,于是就切掉了. 看了题解才发现我们只是运气好. 前缀和如果有n取值,就选%n=0的那一个,不然至多只剩n-1个取值,然而又有n个前缀和. 所以必然有两个相等,输出这之间的下标即可. #include<cstdio> #include<cctype> #include<cstring> #define FN "s

机房测试10.6

砖块 很简单的水题,写起来也很简单. 模拟写的很短,是否也是码力的体现? #include<cstdio> #include<cstring> #include<map> #define FN "block" int mp[1105][1105],dao,ans; char s[105]; int x,y,dx[4]={0,0,-1,1},dy[4]={1,-1,0,0}; std::map<char,int> m; void init(

[机房测试]数字谜题

小 X 同学有很强的计算能力,现在他正在玩一个游戏. 现在有一个正整数 x,每次操作他会将当前的数变为这个数写成二进制后 1 的个数 小 X 不断的进行操作,直到这个数变成 1 为止 由于小 X 的计算能力很强,他现在给出一 n 他想知道有多少不超过 n 的正整数会在 k 次操作后变成 1 由于答案可能很大,请对 1000000007 取模 因为数据范围是\(2^{1000}\),所以一次操作后最多就只有1000个1了 因此直接暴力处理出1~1000所有数变为1的操作次数,把次数为 \(k-1\

机房测试1:string(线段树)

题目: 分析: 暴力:每一次对区间暴力排序. 优化:如果可以知道一个区间中有哪种字符,这些字符分别有多少个,就可以直接按字典序枚举,将它们快速地插入区间中了. 题中有一个重要信息:只有小写字母,即只有26种字符. 第一种方法: 可以用一个线段树来维护,每个节点储存26个字符在这个区间中的对应情况.每次修改,就query统计出所求区间每一种字符的个数. 然后再区间修改,具体见代码. #include<bits/stdc++.h> using namespace std; #define mid