洛谷题目 P2680 运输计划

最新推荐文章于 2023-12-23 23:00:22 发布
最新推荐文章于 2023-12-23 23:00:22 发布
阅读量169 收藏
点赞数
分类专栏： C++ NOIP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/ljp946/article/details/117961777
版权

题目在这里：题目传送门
小编题外话：哎，这道题，做了三天，用了四五种方法，终于结束研究了。

首先，让我们来研究一下部分分吧！

一. 20分的解法：

我们可以枚举是哪一条边变成了“虫洞”，然后再通过搜索得到所有M条路的值，之后，就可以统计出答案了。

二话不说，直接上代码：

#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;
const int maxN=300100;
struct bian{
    int po,next,value;
}edge[maxN*2];
int n,m,ans=0x7fffffff,nans;
int head[maxN],tot;
int a[maxN],b[maxN],t[maxN];
int u[maxN],v[maxN];
int bf[maxN],qwq,dis[maxN];
bool book[maxN];

inline void insert(int x,int y,int z)
{
    edge[++tot].po=y;
    edge[tot].next=head[x];
    edge[tot].value=z;
    head[x]=tot;
}

void bfs(int x,int target,int u,int v)
{
    int st=1;
    bf[st]=x;
    dis[x]=0;
    book[x]=true;
    while(st<=qwq){
        int k=head[bf[st]];
        while(k!=0){
            int y=edge[k].po;
            if(book[y]==false){
                if((bf[st]==u&&y==v)||(bf[st]==v&&y==u))
                    dis[y]=dis[bf[st]];
                else
                    dis[y]=dis[bf[st]]+edge[k].value;
                bf[++qwq]=y;
                book[y]=true;
                if(y==target){
                    //cout<<qwq<<endl;
                    return;
                }
            }
            k=edge[k].next;
        }
        st++;
    }
}

int main()
{
    //freopen("transport.in","r",stdin);
    //freopen("transport.out","w",stdout);
    cin>>n>>m;
    for(int i=1;i<=n-1;++i){
        cin>>a[i]>>b[i]>>t[i];
        insert(a[i],b[i],t[i]);
        insert(b[i],a[i],t[i]);
    }
    for(int i=1;i<=m;++i)
        cin>>u[i]>>v[i];
    for(int i=1;i<=n-1;++i){
        nans=0;
        for(int j=1;j<=m;++j){
            memset(bf,0,sizeof(bf));
            memset(dis,0,sizeof(dis));
            memset(book,false,sizeof(book));
            qwq=1;
            bfs(u[j],v[j],a[i],b[i]);
            nans=max(nans,dis[v[j]]);
        }
        ans=min(ans,nans);
    }
    cout<<ans<<endl;
    return 0;
}

二. 50分的做法：

我们的思想还是一样的，看那一条边变成了虫洞，但是，我们实现的方法有所更新。我们统计一个lca表示所求两个点的最近公共祖先。我们在深搜的过程中可以很容易地统计出到根节点的距离，所以，a到b的距离就是dis[a]+dis[b]-dis[二者的LCA]*2

这很容易懂吧？附上代码：

#include<iostream>
#include<cstdlib>
#include<cstring>
#include<cstdio>
using namespace std;
const int maxN=300100;
struct bian{
    int po,next,value;
}edge[2*maxN];
int n,m;
int ans=0x7fffffff,nans;
int a[maxN],b[maxN],t[maxN];
int u[maxN],v[maxN];
int head[maxN],tot;
int dis[maxN],deep[maxN],lca[maxN],f[maxN][20];
bool book[maxN];

inline void insert(int x,int y,int z)
{
    edge[++tot].po=y;
    edge[tot].next=head[x];
    edge[tot].value=z;
    head[x]=tot;
}

inline void dfs(int x,int fa)
{
    for(int j=1;(1<<j)<=deep[x];++j){
        f[x][j]=f[f[x][j-1]][j-1];
    }
    int k=head[x];
    while(k!=0){
        int y=edge[k].po;
        if(y!=fa){
            int tim=edge[k].value;
            dis[y]=dis[x]+tim;
            deep[y]=deep[x]+1;
            f[y][0]=x;
            dfs(y,x);
        }
        k=edge[k].next;
    }
}

int operate(int x,int y)
{
    if(y==0)
        return x;
    for(int i=19;i>=0;--i){
        if((1<<i)<=y){
            y-=(1<<i);
            x=f[x][i];
        }
    }
    return x;
}

inline int work(int x,int y)
{
    if(deep[x]<deep[y])
        y=operate(y,deep[y]-deep[x]);
    if(deep[x]>deep[y])
        x=operate(x,deep[x]-deep[y]);
    if(x==y)
        return x;
    for(int i=19;i>=0;--i){
        if(f[x][i]!=f[y][i]){
            x=f[x][i];
            y=f[y][i];
        }
    }
    return f[x][0];
}

int compd(int x,int y,int value)
{
    int res=dis[x];
    if(deep[y]>deep[x])
        return dis[x];
    if(operate(x,deep[x]-deep[y])==y)
        return dis[x]-value;
    return dis[x];
}
int main()
{
    //freopen("transport.in","r",stdin);
    //freopen("transport.out","w",stdout);
    cin>>n>>m;
    for(int i=1;i<=n-1;++i){
        cin>>a[i]>>b[i]>>t[i];
        insert(a[i],b[i],t[i]);
        insert(b[i],a[i],t[i]);
    }
    for(int i=1;i<=m;++i)
        cin>>u[i]>>v[i];
    dfs(1,0);
    for(int j=1;j<=m;++j)
        lca[j]=work(u[j],v[j]);
    for(int i=1;i<n;++i){
        int x=((deep[a[i]]>deep[b[i]])?a[i]:b[i]); 
        nans=0;
        for(int j=1;j<=m;++j){
            nans=max(nans,compd(u[j],x,t[i])+compd(v[j],x,t[i])-2*compd(lca[j],x,t[i]));
        }
        ans=min(ans,nans);
    }
    cout<<ans<<endl;
    return 0;
}

三. 80分的做法：

我们再来观察一下数据：发现2，57，1316这几个点第i条航线是连接第i个与第i+1个城市的，换一句话说，就是一条链。

对于大多数求最小值最大，或者说最大值最小的之类的问题，我们都可以用二分来解决（正解就是二分，这都是后话了）。

所以，我们可以二分最后的答案，然后看那些点的距离是超过这个值的，之后，我们用一个数组来维护表示最后K个最大的值的点的公共集合，这样子我们就可以很快的知道哪些点是这些边共有的了。再再这些共有的点之中找出一个最大值，看所有超过二分的值的边都减去，之后看符不符合条件就行了，最后得到的值即为答案。

附上代码：

#include<iostream>
#include<cstdlib>
#include<utility>
#include<cstring>
#include<cstdio>
using namespace std;
const int maxN=300100;
struct bian{
    int po,next,value;
}edge[2*maxN];
int n,m,nans,ans=0x7fffffff;
int a[maxN],b[maxN],t[maxN];
int miss[maxN][3],f[maxN][2],dis[maxN];
int map[maxN];
int head[maxN],tot;

void insert(int x,int y,int z)
{
    edge[++tot].po=y;
    edge[tot].next=head[x];
    edge[tot].value=z;
    head[x]=tot;
}

void dfs(int x,int fa)
{
    int k=head[x];
    while(k!=0){
        int y=edge[k].po;
        if(y!=fa){
            dis[y]=dis[x]+edge[k].value;
            dfs(y,x);
        }
        k=edge[k].next;
    }
}

void work()
{
    for(int i=1;i<=m;++i){
        int l=min(miss[i][0],miss[i][1]);
        int r=max(miss[i][0],miss[i][1]);
        miss[i][2]=dis[r]-dis[l];
    }
}

void qsort(int l,int r)
{
    if(l>=r)
        return;
    int k=miss[rand()%(r-l+1)+l][2];
    int i=l,j=r;
    while(i<=j){
        while(miss[i][2]<k)i++;
        while(miss[j][2]>k)j--;
        if(i<=j){
            swap(miss[i],miss[j]);
            i++;
            j--;
        }
    }
    qsort(l,j);
    qsort(i,r);
}

void prepare()
{
    f[m][0]=miss[m][0];
    f[m][1]=miss[m][1];
    for(int i=m-1;i>=1;--i){
        f[i][0]=max(f[i+1][0],miss[i][0]);
        f[i][1]=min(f[i+1][1],miss[i][1]);
    }
}

int dich(int l,int r,int target)
{
    while(l<=r){
        int mid=(l+r)/2;
        if(miss[mid][2]<=target)
            l=mid+1;
        else
            r=mid-1;
    }
    return l;
}

bool check(int x)
{
    int nans=0;
    int y=dich(1,m,x);
    if(y==m+1)
        return true;
    if(f[y][0]>f[y][1])
        return false; 
    for(int i=f[y][0];i<f[y][1];++i)
        nans=max(nans,map[i]);
    if(miss[m][2]-x<=nans)
        return true;
    else
        return false;
}

int erfen(int l,int r)
{
    while(l<=r){
        int mid=(l+r)/2;
        if(check(mid))
            r=mid-1;
        else
            l=mid+1;
    }
    return l;
}

int main()
{
    memset(map,127,sizeof(map));
    cin>>n>>m;
    for(int i=1;i<=n-1;++i){
        cin>>a[i]>>b[i]>>t[i];
        map[i]=t[i];
        insert(a[i],b[i],t[i]);
        insert(b[i],a[i],t[i]);
    }
    for(int i=1;i<=m;++i)
        cin>>miss[i][0]>>miss[i][1];
    dfs(1,0);
    work();
/*
    for(int i=1;i<=m;++i)
        cout<<miss[i][0]<<" "<<miss[i][1]<<" "<<miss[i][2]<<endl;
*/
    srand(10000000);
    qsort(1,m);
    prepare();
    ans=erfen(0,miss[m][2]);
    cout<<ans<<endl;
    return 0;
}

这是一个45分的程序，达到80分需要和上面合并在一起

四. 满分做法
由上面的做法其实也就是正解，但是，我们在求公共集合的时候以及求公共集合中的最大值会很麻烦。

首先，我们来研究一下怎么来求两个东西的公共集合，我们发现，其实这个集合每一个集合都可以分成两条边，miss[i][0]lca[i],lca[i]miss[i][1],然后原来求好的公共集合也是如此，所以，所求出来的新的集合也就是和这6个点有着密切的关系。

我们判断f[i+1][1],f[i+1][2]是否在(miss[i][0],miss[i][1],lca[i])构成的路上 ，判断miss[i][0],miss[i][1]是否在(f[i+1][1],f[i+1][2],f[i+1][3])构成的路上 ，以及LCA是否在这一条路上面，就行了（好吧，是有一点费解，在程序中再理解一下吧）

之后，求最大值也是比较简单的，求LCA的时候，我们用到了倍增，同样的，我们用一样的方式求出每一个2的次方倍的最大值出来，要用的时候就和LCA中的operate（程序中的）操作一样了。

其余的，其实都是一样的了，还有许许多多的细节，在程序中都体现出来了。

二话不说，双手附上代码：

#include<iostream>
#include<cstdlib>
#include<utility>
#include<cstring>
#include<cstdio>
using namespace std;
const int maxN=300100;
struct bian{
    int po,next,value;
}edge[maxN*2];
int n,m;
int head[maxN],tot;
int a[maxN],b[maxN],t[maxN],miss[maxN][4];
int dis[maxN],deep[maxN],f[maxN][4];
int fa[maxN][20],rmq[maxN][20],lca[maxN];
bool book[maxN];

inline void insert(int x,int y,int z)
{
    edge[++tot].po=y;
    edge[tot].next=head[x];
    edge[tot].value=z;
    head[x]=tot;
}

inline void dfs(int x,int father)
{
    int k=head[x];
    while(k!=0){
        int y=edge[k].po;
        if(y!=father){
            fa[y][0]=x;
            rmq[y][0]=edge[k].value;
            dis[y]=dis[x]+edge[k].value;
            deep[y]=deep[x]+1;
            dfs(y,x);
        }
        k=edge[k].next;
    }
}

inline int operate(int x,int y)
{
    if(y==0)
        return x;
    for(int i=19;i>=0;--i){
        if((1<<i)<=y){
            y-=(1<<i);
            x=fa[x][i];
        }
    }
    return x;
}

inline int work(int x,int y)
{
    if(deep[x]<deep[y])
        y=operate(y,deep[y]-deep[x]);
    if(deep[x]>deep[y])
        x=operate(x,deep[x]-deep[y]);
    if(x==y)
        return x;
    for(int i=19;i>=0;--i){
        if(fa[x][i]!=fa[y][i]){
            x=fa[x][i];
            y=fa[y][i];
        }
    }
    return fa[x][0];
}

void prepare()
{
    for(int i=1;i<=19;++i){
        for(int j=1;j<=n;++j){
            fa[j][i]=fa[fa[j][i-1]][i-1];
            rmq[j][i]=max(rmq[j][i-1],rmq[fa[j][i-1]][i-1]);
        }
    }
    for(int i=1;i<=m;++i)
        miss[i][2]=work(miss[i][0],miss[i][1]);
    for(int i=1;i<=m;++i)
        miss[i][3]=dis[miss[i][0]]+dis[miss[i][1]]-dis[miss[i][2]]*2;

}

void qsort(int l,int r)
{
    if(l>=r)
        return;
    int k=miss[rand()%(r-l+1)+l][3];
    int i=l,j=r;
    while(i<=j){
        while(miss[i][3]<k)i++;
        while(miss[j][3]>k)j--;
        if(i<=j){
            swap(miss[i],miss[j]);
            i++;
            j--;
        }
    }
    qsort(l,j);
    qsort(i,r);
}

inline bool judge(int x,int y,int z)
{
    if(deep[x]>deep[y]||deep[x]<deep[z])
        return false;
    int p=operate(y,deep[y]-deep[x]);
    return p==x; 
}

void store(int x,int p)
{
    bool ok=true;
    for(int i=1;i<=f[p][0];++i){
        if(f[p][i]==x){
            ok=false;
            break;
        }
    }   
    if(ok){
        f[p][0]++;
        f[p][f[p][0]]=x;
    }
}

void otherway(int x,int y)
{
    for(int i=0;i<=2;++i){
        for(int j=1;j<=3;++j){
            int now=work(miss[x][i],f[y][j]);
            if((judge(now,miss[x][0],miss[x][2])||judge(now,miss[x][1],miss[x][2]))&&(judge(now,f[y][1],f[y][3])||judge(now,f[y][2],f[y][3]))){
                store(now,x);
            }
        }
    }
}

void ahead()
{
    f[m][0]=3;
    f[m][1]=miss[m][0];
    f[m][2]=miss[m][1];
    f[m][3]=miss[m][2];
    for(int i=m-1;i>=1;--i){
        f[i][0]=0;
        //判断f[i+1][1],f[i+1][2]是否在(miss[i][0],miss[i][1],lca[i])构成的路上 
        /*for(int j=1;j<=3;++j){
            if(judge(f[i+1][j],miss[i][0],miss[i][2])||judge(f[i+1][j],miss[i][1],miss[i][2])){
                store(f[i+1][j],i);
            }
        }
        //判断miss[i][0],miss[i][1]是否在(f[i+1][1],f[i+1][2],f[i+1][3])构成的路上 
        for(int j=0;j<=2;++j){
            if(judge(miss[i][j],f[i+1][1],f[i+1][3])||judge(miss[i][j],f[i+1][2],f[i+1][3])){
                store(miss[i][j],i);
            }
        }*/ 
        otherway(i,i+1);
        if(f[i][0]==3){
            if(deep[f[i][1]]<deep[f[i][3]]){
                swap(f[i][1],f[i][3]);
            }
            if(deep[f[i][2]]<deep[f[i][3]]){
                swap(f[i][2],f[i][3]);
            }
            continue;
        }
        if(f[i][0]<2)
            break;
        f[i][3]=work(f[i][1],f[i][2]);
    }
}

int dich(int l,int r,int target)
{
    while(l<=r){
        int mid=(l+r)/2;
        if(miss[mid][3]<=target)
            l=mid+1;
        else
            r=mid-1;
    }
    return l;
}

int operate2(int x,int y)
{
    int ans=0;
    for(int i=19;i>=0;--i){
        if((1<<i)<=y){
            y-=(1<<i);
            ans=max(ans,rmq[x][i]);
            x=fa[x][i];
        }
    }
    return ans;
}

int findmax(int x,int y)
{
    if(x==y)
        return 0;
    int ans=operate2(x,deep[x]-deep[y]);
    //cout<<x<<" "<<y<<" "<<ans<<endl;
    return ans;
}

bool check(int x)
{
    int nans=0;
    int y=dich(1,m,x);
    //cout<<x<<" "<<y<<endl;
    if(y==m+1)
        return true;
    if(f[y][0]<2)
        return false;
    nans=max(findmax(f[y][1],f[y][3]),findmax(f[y][2],f[y][3]));

    if(miss[m][3]-x<=nans)
        return true;
    else
        return false;
}

int erfen(int l,int r)
{
    while(l<=r){
        int mid=(l+r)/2;
        if(check(mid))
            r=mid-1;
        else
            l=mid+1;
    }
    return l;
}

int main()
{
    //freopen("testdata.in","r",stdin);
    //freopen("transport1.out","w",stdout);
    cin>>n>>m;
    for(int i=1;i<=n-1;++i){
        cin>>a[i]>>b[i]>>t[i];
        insert(a[i],b[i],t[i]);
        insert(b[i],a[i],t[i]);
    }
    for(int i=1;i<=m;++i)
        cin>>miss[i][0]>>miss[i][1];
    dfs(1,0);
    prepare();
    srand(100000000);
    qsort(1,m);
    ahead();
    //for(int i=m;i>=1;--i)
    //  cout<<f[i][0]<<" "<<f[i][1]<<" "<<f[i][2]<<" "<<f[i][3]<<endl;
    int ans=erfen(0,miss[m][3]);
    cout<<ans<<endl;
    return 0;
}

呼，终于解决了一道难题，其实每一种方法都有自己的巧妙之处，在考场上，我们要根据数据大小类型来判断如何写部分分。这道题的最终答案，其实其余的地方都没有什么考验技术的地方（当然，除了求出公共的集合这一块地方有点麻烦，其余的都还好）。

【ybtoj 4.5 倍增问题课堂过关】【洛谷P2680】E.运输计划【树上差分】
ssllyr
08-14 134
题目链接：gmoj，洛谷 分析 最大值最小，可以二分。 二分答案，然后判断的时候把所有大于midmidmid值的路径记录下来，找出被所有这样路径覆盖的最长的道路。 如果没有这样的道路 false；如果这样的道路被减去之后依然大于mid false ，找出被所有路径覆盖的道路。 在树中将所有路径起、始权值+1，LCA权值-2，从所有叶节点往上累加，最终权值为路径数的点到其父亲的边为所求边 dis[i]dis[i]dis[i]表示i到根的距离；t[i]t[i]t[i]表示iii这个点通往父亲的边，目的是记录..
洛谷 P4015 运输问题（费用流）
qq_38232157的博客
11-12 331
最小费用最大流
洛谷 P2680 运输计划
苦鬼·。
07-17 489
题目背景 公元 2044 年,人类进入了宇宙纪元。 题目描述 L 国有 n 个星球,还有 n-1 条双向航道,每条航道建立在两个星球之间,这 n-1 条航道连通了 L 国的所有星球。 小 P 掌管一家物流公司,该公司有很多个运输计划,每个运输计划形如:有一艘物 流飞船需要从 ui 号星球沿最快的宇航路径飞行到 vi 号星球去。显然,飞船驶过一条航道 是需要时间的,对于航道 j,任意飞船驶过
洛谷P2680 运输计划(LCA+树上差分+二分)
最新发布
m0_74176921的博客
12-23 141
对于每条路径加上相同数，我们利用差分，设差分数组为sum[x](表示的是1到x),那么要把x,y的路径都加上1,就相当于把x到lca(x,y)加上1和lca(x，y)到y之一段加上1，于是sum[x]++,sum[y]++,但是sum表示的是由于是根节点到x，于是我们刚刚多加了两次从根节点到lca(x,y),于是最后还需sum[lca(x,y)]-2。d(x,y)=dis[x]-dis[lca(x,y)]+dis[y]-dis[lca(x,y)],求LCA的方式有很多，这里采用的是倍增的方式。
P2680 运输计划
weixin_30752699的博客
10-01 80
http://www.luogu.org/problem/show?pid=2680#sub 题目背景 公元 2044 年,人类进入了宇宙纪元。 题目描述 L 国有 n 个星球,还有 n-1 条双向航道,每条航道建立在两个星球之间,这 n-1 条航道连通了 L 国的所有星球。 小 P 掌管一家物流公司,该公司有很多个运输计划,每个运输计划形如:有一艘物 流飞船需要从 ui 号星球沿最快...
Luogu P2680 运输计划
YYHS_WSF的博客
09-20 319
题目描述 公元20442044 年，人类进入了宇宙纪元。 L 国有 nn 个星球，还有 n-1n−1 条双向航道，每条航道建立在两个星球之间，这 n-1n−1 条航道连通了 LL 国的所有星球。 小 P 掌管一家物流公司， 该公司有很多个运输计划，每个运输计划形如：有一艘物流飞船需要从 u_iui​ 号星球沿最快的宇航路径飞行到 v_ivi​ 号星球去。显然，飞船驶过一条航道是需要时间的，对...
P2680 运输计划（树上差分+lca+二分）
starlet_kiss的博客
09-04 225
题目背景 公元 20442044 年,人类进入了宇宙纪元。 题目描述 公元20442044 年，人类进入了宇宙纪元。 L 国有 nn 个星球，还有 n-1n−1 条双向航道，每条航道建立在两个星球之间，这 n-1n−1 条航道连通了 LL 国的所有星球。 小 P 掌管一家物流公司， 该公司有很多个运输计划，每个运输计划形如：有一艘物流飞船需要从 u_iu i ​ 号星球沿最快的宇航路径飞行到 ...
洛谷 P3128 [USACO15DEC] Max Flow P
qq_17807067的博客
11-16 217
洛谷 P3128 [USACO15DEC] Max Flow P，树上差分+倍增LCA
最小费用最大流（洛谷-P3381）.rar
09-16
洛谷-P3381 是一个在线编程竞赛平台上的题目，挑战者需要编写程序解决这个问题。 最小费用最大流问题可以看作是对最大流问题的扩展，最大流问题的目标是在给定的有向图中找到从源点到汇点的最大流量，而最小费用...
洛谷 P4552 [Poetize6] IncDec Sequence
qq_17807067的博客
11-22 1263
洛谷 P4552 [Poetize6] IncDec Sequence，差分+思维。 洛谷 P3258 [JLOI2014] 松鼠的新家，树上差分+思维
洛谷P2680:运输计划（倍增、二分、树上差分）
BUG_Creater_jie的博客
06-14 278
传送门 文章目录题目描述解析问题代码 题目描述 解析 求最大值的最小值 容易想到二分 然后。。。就没有然后了。。。 看了题解 学会了一个新技能：树上差分 （其实学长之前好像讲过。。。） 一般的，对于一条A到B的路径，如果要将其全部加上一个值w。我们可以把AB两点的前缀加w，再把它们的lca及lca的父亲减去w，最后统计时用dfs统计，每个点的价值就是其本身及子树的前缀值之和 画个图就能很直观的看出来，请读者自行动笔探究~~（绝对不是我懒）~~ lca可以用许多算法优化到log，这样时间复杂度就很优秀啦 本
题解 P2680 【运输计划】
wangyiyang2的博客
03-09 159
题解- P2680 运输计划 题目意思 就是在一棵树中使得一条边的边权为000，使得mmm条航线的最长链最短。 SolSolSol 一道古代题，也是一道套路题。 要求最长链最短我们显然能够想到二分答案。但是关键在于如何判断答案是正确的。 我们在这里设二分的答案为midmidmid，mmm条航线的长度为did_idi​。如果di≤midd_i \leq middi​≤mid显然不需要考虑，剩...
洛谷 2680 运输计划
ToheartZhang的博客
08-24 392
//二分+倍增LCA+树上前缀和 //尽力缩小二分范围，能多拿分就多拿分 //掌握树上前缀和的初始化和区间修改 //读入优化 //二分答案，然后找出超出mid的计划，记录他们的公共重边，这里用树上前缀和找前缀和exc==超出计划数 的最大的边，删掉后再判断是否<=mid。 #include<bits/stdc++.h> using namespace std; const int inf = 0
洛谷P2680 运输计划——题解
CleverLarry的博客
09-25 288
题目传送门 题目大意： 有一颗n个节点的树和m条路径，你可以将树上任一条边的长度变为0，求所有路径中最长的一条的最小值。 思考过程： 这是典型的求最大值最小可以为多少的问题，我们考虑二分答案。 然后我们考虑如何检验当前答案是否可行。显然，长度小于当前答案的路径都是可行的，问题转化为如何判断长度大于当前答案的路径是否可行。因为我们要删掉一条边使得这些路径长度都变小，所以我们肯定要删掉这些路径的交，...
洛谷 P2680 运输计划 树链剖分+最近公共祖先
liangzihao1的博客
08-03 336
题目背景 公元2044年，人类进入了宇宙纪元。 题目描述 公元2044年，人类进入了宇宙纪元。 LLL国有nnn个星球，还有n−1n−1n−1条双向航道，每条航道建立在两个球之间，这n−1n−1n−1条航道连通了LLL国的所有星球。 小PPP掌管一家物流公司，该公司有很多个运输计划，每个运输计划形如：有一艘物流飞船需要从uiuiu_i号星球沿最快的宇航路径飞行到viviv_i号星球去。显...
【NOIP2015】洛谷2680 运输计划【解法一】
YHaX的博客
10-28 1483
二分答案+LCA
洛谷——P2680 运输计划
agcozdwdfvds08078的博客
07-17 110
https://www.luogu.org/problem/show?pid=2680 题目背景 公元 2044 年,人类进入了宇宙纪元。 题目描述 L 国有 n 个星球,还有 n-1 条双向航道,每条航道建立在两个星球之间,这 n-1 条航道连通了 L 国的所有星球。 小 P 掌管一家物流公司,该公司有很多个运输计划,每个运输计划形如:有一艘物 流飞船需要从 ui 号星球沿...
洛谷P2680 运输计划
蒟蒻的博客
10-23 332
题目背景 公元 2044 年,人类进入了宇宙纪元。 题目描述 L 国有 n 个星球,还有 n-1 条双向航道,每条航道建立在两个星球之间,这 n-1 条航道连通了 L 国的所有星球。 小 P 掌管一家物流公司,该公司有很多个运输计划,每个运输计划形如:有一艘物 流飞船需要从 ui 号星球沿最快的宇航路径飞行到 vi 号星球去。显然,飞船驶过一条航道 是需要时间的,对于
运输计划
weixin_30528371的博客
08-18 120
【题目描述】 L国有n个星球，还有n-1条双向航道，每条航道建立在两个星球之间，这n-1条航道连通了L国的所有星球。 小P掌管一家物流公司，该公司有很多个运输计划，每个运输计划形如：有一艘物流飞船需要从ui号星球沿最快的宇航路径飞行到vi号星球去。显然，飞船驶过一条航道是需要时间的，对于航道j，任意飞船驶过它所花费的时间为tj，并且任意两艘飞船之间不会产生任何干扰。 为了鼓励科技创新，L国国...
用C语言编写一个洛谷题目p2822的答案
06-10
对于洛谷题目p2822，需要编写一个程序，输入一个正整数n，然后输出n的阶乘。 以下是用C语言编写的程序： ``` #include <stdio.h> int main() { int n, i; long long factorial = 1; printf("请输入一个正整数n："); scanf("%d", &n); for(i = 1; i <= n; i++) { factorial *= i; } printf("%d的阶乘为%lld", n, factorial); return 0; } ``` 这个程序中，首先定义了变量n、i和factorial。其中，n用于存储输入的正整数，i用于循环计数，factorial用于计算阶乘。 然后，程序输出提示信息，要求用户输入一个正整数n。接着，程序使用scanf函数读取用户输入的n。 接下来，程序使用for循环计算n的阶乘。循环从1开始，一直执行到n，每次将i乘以factorial。最后，程序输出n的阶乘。 需要注意的是，n的阶乘可能非常大，如果使用int类型存储，可能会出现溢出。因此，可以使用long long类型来存储阶乘。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值