[USACO24FEB] Milk Exchange G

来源

题目描述

Farmer John 的 N(11≤N≤5⋅10^5)头奶牛排成一圈。第 i 头奶牛有一个容量为整数 ai​(1≤ai​≤10^9)升的桶。所有桶初始时都是满的。

每一分钟,对于 1≤i<N,奶牛 ii 会将其桶中所有牛奶传递给奶牛 i+1,奶牛 N 将其牛奶传递给奶牛 1。所有交换同时发生(即,如果一头奶牛的桶是满的,送出 x 升牛奶同时收到 x 升,则她的牛奶量保持不变)。如果此时一头奶牛的牛奶量超过ai​,则多余的牛奶会损失。

在 1,2,…,N 的每一分钟后,所有奶牛总共还余下多少牛奶?

输入格式

输入的第一行包含 N。

第二行包含a1​,a2​,…,aN​。

输出格式

输出 N行,其中第 i行包含 i分钟后所有奶牛总共余下的牛奶量。

思路

        奶牛是按排成一圈的,常规套路可以把数组复制几遍方便处理。容易想到把最小的放到最左边,可以在右移的过程中把右边的给覆盖掉,在研究的时候可以更直观得看出来。

        下面是一个样例的示例图:

        

        在这里可以直观地看出来,每一个数字形成的图形是有规律的,大致是三角形或者是平行四边形。这里我门考虑每一个数字在每一行产生的贡献,比如第六的数字2,在第一行到第四行产生的贡献是2,4,6,8,在第四行到第五行是不变的,在第五行到第八行的贡献是8,6,4,2。其它的形状也可以用类似概括,可以发现这是一个递增的等差数列(公差为ai),一个不变的等差数列(公差为0),一个递减的等差数列(公差为-ai),对于一段区间,累加上一段等差数列,知道了首项和公差,我们可以用两次差分,前缀和实现。

比如:要实现的等差数列是a1,a1+d,a1+2d,a1+3d

           第一次要达到的是a1,d,d,d,d(做一次前缀和即可实现上面)

           这里就能明显地看出来这些同样的d可以用基础的差分前缀和实现。

        至于三个数列的起始点和终止点,可以用两次单调栈维护每个数字左右第一次小于它的数字。然后直接手推三个关系式子即可。

 add(1,min(i-l[i],r[i]-i),a[i],a[i]);
 add(min(i-l[i],r[i]-i)+1,max(i-l[i],r[i]-i),(min(i-l[i],r[i]-i))*a[i],0);
 add(max(i-l[i],r[i]-i)+1,r[i]-l[i]-1,(min(i-l[i],r[i]-i))*a[i]-a[i],-a[i]);

代码

#include<bits/stdc++.h>

using namespace std;
typedef long long ll;
#define int long long
const int N = 5e5 + 10;

int p[N*2],s[N*2],a[N*3],l[N*3],r[N*3],q[N*3],cnt;
inline void add(int l1,int r1,int x,int y){ //维护二阶差分
    if(r1<l1){
        return;
    }
    p[l1]+=x;
    p[r1+1]-=y*(r1-l1)+x;
    s[l1+1]+=y;
    s[r1+1]-=y;
}
void solve(){
    int n;
    cin>>n;
    for(int i=1;i<=n;i++){
        cin>>a[i];
        a[i+n*2]=a[i];
        a[i+n]=a[i];
        r[i]=3*n+1;
    }
    for(int i=1;i<=n*3;i++){
        while(cnt&&a[q[cnt]]>=a[i]){
            cnt--;
        }
        l[i]=q[cnt];
        q[++cnt]=i;
    }
    cnt=0;
    for(int i=n*3;i>=1;i--){
        while(cnt&&a[q[cnt]]>a[i]){
            cnt--;
        }
        if(cnt){
            r[i]=q[cnt];
        }
        q[++cnt]=i;
    }
    for(int i=1;i<=n;i++){
        l[i]=max(l[i+n],i)-n;
        r[i]=min(r[i+n],i+2*n)-n;
        add(1,min(i-l[i],r[i]-i),a[i],a[i]);
        add(min(i-l[i],r[i]-i)+1,max(i-l[i],r[i]-i),(min(i-l[i],r[i]-i))*a[i],0);
        add(max(i-l[i],r[i]-i)+1,r[i]-l[i]-1,(min(i-l[i],r[i]-i))*a[i]-a[i],-a[i]);
    }
    for(int i=1;i<=n;i++){
        s[i]+=s[i-1];
        p[i]+=s[i];
    }
    for(int i=2;i<=n;i++){
        p[i]+=p[i-1];
        cout<<p[i]<<'\n';
    }
    cout<<p[n];
}
signed main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int T = 1;
//    cin>>T;
    while (T--)solve();
    return 0;
}

  • 4
    点赞
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
### 回答1: 题目描述 有N头奶牛,它们在M个牛棚之间相互转移。每个牛棚里有一些奶牛,每分钟可以容纳一头奶牛。一头奶牛从一个牛棚走到另一个牛棚需要一分钟的时间。现在,这些奶牛要开一个牛派对,它们要在同一时间到达同一个牛棚,所以它们需要在某个牛棚等待一段时间。你需要计算最小的等待时间,使得所有奶牛都能够在同一时间到达同一个牛棚。 输入格式 第一行包含三个整数N,M,X。 接下来M行,每行包含三个整数a,b,t,表示牛棚a和牛棚b之间有一条双向边,需要t分钟才能通过。 输出格式 输出一个整数,表示最小等待时间。 数据范围 1≤N≤500 1≤M≤10000 1≤X≤N 1≤a,b≤N 1≤t≤1000 输入样例#1 3 3 1 1 2 5 2 3 5 1 3 10 输出样例#1 5 输入样例#2 4 5 4 1 2 10 2 3 10 3 4 10 4 1 10 1 3 20 输出样例#2 30 算法1 (最短路) $O(N^3)$ Dijkstra算法 Dijkstra(迪杰斯特拉)算法是由荷兰计算机科学家狄克斯特拉于1956年发明的,因此又叫狄克斯特拉算法。 Dijkstra算法是一种贪心算法,用于求解一个节点到其他所有节点的最短路径。它的主要特点是以起始点为中心向外层层扩展(广度优先搜索思想),直到扩展到终点为止。 具体做法是:设立一个数组dis来保存源点到各个顶点的最短距离和一个数组book[i]来记录一个顶点是否已经在队列中。 初始时,原点s的路径权重被赋为0 (dis[s] = 0)。若对于顶点s存在能直接到达的边(s,m),则把dis[m]设为w(s, m),同时把所有其他(s不能直接到达的)顶点的路径长度设为无穷大。初始时,所有顶点并不属于任何已知最短路径所包含的顶点集合,因此都被标记为未知最短路径长度。当算法结束时,dis[v]中存储的便是源点s到顶点v的最短路径,或者如果从s无法到达v,则值为INF。 Dijkstra算法流程: 算法流程: 1. 将所有顶点分为两部分:已知最短路的顶点集合P和未知最短路的顶点集合Q。 2. 初始时,顶点集合P中只有源点s一个元素,以源点s为起点向外扩展。 3. 每次从顶点集合Q中选取一个顶点u(u的dist最小),并加入到顶点集合P中,同时以u为中心进行扩展。 4. 重复步骤3,直到顶点集合Q为空或者终点被加入到顶点集合P中。 5. 算法结束,最短路径保存在dis数组中。 时间复杂度 Dijkstra算法的时间复杂度为O(N^2)。由于N较小,因此可以通过本题。 参考文献 Dijkstra算法讲解 C++ 代码 算法2 (最短路) $O(N^2)$ Floyd算法 Floyd算法又称为插点法,是一种利用动态规划的思想寻找给定的加权图中多源点之间最短路径的算法,与Dijkstra算法类似。该算法名称以创始人之一、1978年图灵奖获得者、斯坦福大学计算机科学系教授罗伯特·弗洛伊德命名。 Floyd算法的基本思想 设G=(V,E)是一个带权有向图,其邻接矩阵为W。V={v1,v2,……,vn},W[1:n,1:n],则该图的Floyd算法可描述如下: 时间复杂度 Floyd算法的时间复杂度为O(N^3)。由于N较小,因此可以通过本题。 参考文献 Floyd算法讲解 C++ 代码 算法3 (最短路) $O(N^2)$ Bellman-Ford算法 Bellman-Ford算法是一种单源最短路径算法,可以处理负权边,但不能处理负权回路。 Bellman-Ford算法的基本思想 对于图中的任意一条边(u, v),Bellman-Ford算法会对每一条边进行一次松弛操作(Relax),并且这些操作是按照顺序进行的:当算法进行第i次松弛操作时,它只会改变长度为i+1的路径上的顶点的值。因此,当算法执行完第n-1次松弛操作后,路径长度最长不超过n-1,此时所有最短路径都已经求出。 时间复杂度 Bellman-Ford算法的时间复杂度为O(N*M)。由于N和M的范围较小,因此可以通过本题。 参考文献 Bellman-Ford算法讲解 C++ 代码 ### 回答2: Usaco 2007 Feb的问题是关于Cow Party的。这个问题中,农夫约翰有N头奶牛,它们之间通过一些路径相互连接,并且每个路径都有一个长度。约翰想要在某个时间将它的所有奶牛聚集在一起举办一个派对,现在他想知道所有奶牛从各自的位置到达聚会地点所需的最短时间。 为了解决这个问题,我们可以使用Dijkstra算法。我们首先需要创建一个节点集合,包含所有的奶牛和派对地点,并且初始化每个节点的最短时间为无穷大。接下来,我们选取一个起点节点--聚会地点,并将它的最短时间设置为0。然后我们开始遍历所有的节点,每次选择一个最短时间未确定的节点,并更新它的邻居节点的最短时间。我们重复这个过程,直到所有节点的最短时间都确定。 在更新节点的最短时间时,我们需要根据节点之间的路径长度来更新。我们检查从当前节点到邻居节点的路径长度加上当前节点的最短时间是否小于邻居节点目前的最短时间。如果是,则更新邻居节点的最短时间为新的最短时间。 最后,我们可以得到所有奶牛到达聚会地点所需的最短时间。我们找到所有奶牛起始位置的最长最短时间,即为我们的答案。 通过使用Dijkstra算法,我们可以解决这个问题并得到最优解。因此,Usaco 2007 Feb的Cow Party问题可以通过这种方法解决。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

心刍

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值