#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio>

using namespace std;

const int N=100010;
int arr[N];//得到价格数组
int n;//一共n天
int main()
{
    cin>>n;
    int sum=0;//存储盈利多少
    for(int i=1;i<=n;i++){
        cin>>arr[i];
    }
    for(int i=1;i<=n;i++){
        if(arr[i+1]>arr[i])sum+=arr[i+1]-arr[i];//只要交易有得赚，就进行交易

    }
    cout<<sum;
    return 0;
}

-

#include<iostream>
#include<cstring>
#include<cstdio>
#include<queue>
#include<algorithm>

#define f first
#define s second

using namespace std;

typedef pair<int,int>PII;

const int N=2200;

char g[N][N];//存储地图
int d[N][N];//记录当前位置距离起点位置
int n,m;
int bfs(int sx,int sy)
 {
     queue<PII>q;
     q.push({sx,sy});
     memset(d,-1,sizeof d);
     d[sx][sy]=0;
     int dx[]={-1,0,1,0},dy[]={0,1,0,-1};

     while(q.size()){
         auto t=q.front();
         q.pop();
         for(int i=0;i<4;i++){
            int x=t.f+dx[i],y=t.s+dy[i];
            if(x>=0&&y>=0&&x<n&&y<m&&d[x][y]==-1&&g[x][y]!='#'){

                d[x][y]=d[t.f][t.s]+1;

                if(g[x][y]=='E') return d[x][y];
                 q.push({x,y});
            }
        }
     }
     return 0;
 }
 int main()
 {
     int t;//t个数据
     cin>>t;
     int x,y;
     while(t--){
         cin>>n>>m;
         for(int i=0;i<n;i++){
             cin>>g[i];
             for(int j=0;j<m;j++)
             {
                 if(g[i][j]=='S'){
                     x=i,y=j;
                 }

             }
         }
         if(!bfs(x,y))cout<<"oop!"<<endl;
         else cout<<bfs(x,y)<<endl;
     }
 }

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<queue>
using namespace std;
#define f first//定义宏
#define s second
typedef pair<int,int>PII; //简写，减少代码量

const int N=30;
int m,n;

char g[N][N];//存储地图
int bfs(int sx,int sy){
    queue<PII>q;//定义队列
    q.push({sx,sy});//插入起始位置，开始从这里遍历
    g[sx][sy]='#';//将起始位置标记为不可走，但是不写也没事，因为它的符号是'@'
    int res=1;//起始位置也算一个
    int dx[]={-1,0,1,0},dy[]={0,1,0,-1};//记录偏移量
    while(q.size())//队列是否不空。空则代表搜索完毕
    {
        auto t=q.front();//在弹出队头前提前将此处的位置保存下来
        //可以将弹出队头操作放到最后，然后删除t，直接用q.front()
        q.pop();//弹出队头，方便下一个位置开始遍历

        for(int i=0;i<4;i++){
            int x=t.f+dx[i],y=t.s+dy[i];//进行四个位置偏移
            if(x>=0&&y>=0&&x<n&&y<m&&g[x][y]=='.')//符合条件才可以进行
            {
                res++;//记录符合条件的数目
                g[x][y]='#';//将遍历过的标记为不能走

              q.push({x,y});//插入进队
            }
        }//q.pop();也可以放在这
    }return res;
}
int main()
{
    while(cin>>m>>n,m||n){
        int x,y;
        for(int i=0;i<n;i++){
            for(int l=0;l<m;l++){
                cin>>g[i][l];
                if(g[i][l]=='@'){
                    x=i;//记录起始位置
                    y=l;
                }
            }
        }

        cout<<bfs(x,y)<<endl;
        memset(g,'0',sizeof g);//清空数组，方便第二次使用
    }return 0;
}

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>

using namespace std;
const int N=110;
int n,m;
typedef pair<int ,int>PII;//宏定义
PII q[N*N];//模拟实现队列
int g[N][N];//存储地图
int d[N][N];//记录到起点的距离

int bfs(){
    int hh=1,tt=1;
    q[1]={1,1};//从(1,1)开始遍历
    int dx[]={-1,0,1,0},dy[]={0,1,0,-1};
    memset(d,-1,sizeof d);
    d[1][1]=0;//从（1，1）开始，距离为0
    while(hh<=tt){
        auto t=q[hh];//接收第一个出来的坐标
        hh++;//向后移一位，弹出队头；
        for(int i=0;i<4;i++){
            int x=t.first+dx[i],y=t.second+dy[i];//记录偏移量
            if(x>0&&y>0&&x<=n&&y<=m&&d[x][y]==-1&&g[x][y]==0){//判断此方位是否符合
                d[x][y]=d[t.first][t.second]+1;//符合的话，此方位距离加1
                tt++;
                q[tt]={x,y};//将此方位的坐标插入队列，即为下一次开始的坐标

            }
        }
    }
    return d[n][m];//输出终点距起点的距离
}

int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++){
        for(int x=1;x<=m;x++){
            scanf("%d",&g[i][x]);
        }
    }
    cout<<bfs()<<endl;
    return 0;
}

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<limits.h>

using namespace std;

int n,m;
const int N=1000010;
int c[N];
struct node{
    int l,r;
    int mx;
}tr[N*4];
void pushup(int u)
{
    tr[u].mx=max(tr[u<<1].mx,tr[u<<1|1].mx);//将数值大的儿子赋值给父亲节点
}
void build(int u,int l,int r)
{
    if(l==r)tr[u]={l,r,c[l]};
    else
    {
        tr[u]={l,r};
        int mid=l+r>>1;

        build(u<<1,l,mid);//递归左儿子
        build(u<<1|1,mid+1,r);//递归右儿子
        pushup(u);
    }
}
int research(int u,int l,int r)
{
    if(l<=tr[u].l&&r>=tr[u].r)return tr[u].mx;
    int mx=INT_MIN;
    int mid=tr[u].l+tr[u].r>>1;
    if(l<=mid)mx=max(mx,research(u<<1,l,r));
    if(r>mid)mx=max(mx,research(u<<1|1,l,r));
    return mx;
}
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&c[i]);
    }
    int x,y;
    build(1,1,n);
    while(m--)
    {
        scanf("%d%d",&x,&y);
        printf("%d\n",research(1,x,y));
    }
    return 0;
}

树状数组

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>

using namespace std;

const int N = 100010;
int a[N],c[N];//a是原数组,c是新数组
int n, m;
int lobit(int x)
{
    return x & -x;
}
void add(int x, int y)
{
    for (int i = x; i <= n; i += lobit(i))//求出y总讲的c数组
        c[i] += y;
}
int sum(int x)//求前缀和数组
{
    int rest = 0;
    for (int i = x;i;i -= lobit(i))
    {
        rest += c[i];//动态的过程，不用另开数组

    }
    return rest;
}
int main()
{
    scanf("%d%d", &n, &m);
    for (int i = 1;i <= n;i++)
    {
        scanf("%d", &a[i]);//得到原数组
        add(i,a[i]);//将原数组加给c数组
    }
    while (m--)
    {
        int k, l, r;
        scanf("%d%d%d",&k,&l,&r);

        if (k == 0) printf("%d\n",sum(r) - sum(l - 1));//动态求区间和
        else add(l,r);//加上那个数

    }return 0;
}

线段树

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio>
using namespace std;

const int N=100010;
int n,m;
int c[N];
struct node{
    int l,r;
    int sum;
}tr[N*4];
void pushup(int u)
{
    tr[u].sum=tr[u<<1].sum+tr[u<<1|1].sum;
}
void build(int u,int l,int r)
{
    if(l==r)tr[u]={l,r,c[l]};
    else
    {
        int mid=l+r>>1;
        tr[u]={l,r};
        build(u<<1,l,mid);
        build(u<<1|1,mid+1,r);
        pushup(u);
    }
}
int research(int u,int l,int r)
{
    if(l<=tr[u].l&&r>=tr[u].r)return tr[u].sum;
    int sum=0;
    int mid=tr[u].r+tr[u].l>>1;
    if(l<=mid)sum+=research(u<<1,l,r);
    if(r>mid)sum+=research(u<<1|1,l,r);
    return sum;

}
void revise(int u,int l,int r)
{
    if(tr[u].l==tr[u].r)tr[u].sum+=r;
    else
    {
        int mid=tr[u].l+tr[u].r>>1;
        if(l<=mid)revise(u<<1,l,r);
        else revise(u<<1|1,l,r);
        pushup(u);
    }
}

int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
    scanf("%d",&c[i]);
    build(1,1,n);
    int k,a,b;
    while(m--)
    {
        scanf("%d%d%d",&k,&a,&b);
       if(!k)cout<<research(1,a,b)<<endl;
       else revise(1,a,b);
    }
    return 0;
}

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>

using namespace std;
const int N=100010;
int n,m;
int a[N],c[N];
int lowbit(int x)
{
    return x&-x;
}
void add(int x,int y)
{
    for(int i=x;i<=n;i+=lowbit(i))
    {
        c[i]+=y;
    }
}
 int  sum(int x)
 {
     int rest=0;
     for(int i=x;i;i-=lowbit(i))
     {
         rest+=c[i];
     }
     return rest;
 }
int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        cin>>a[i];
        add(i,a[i]);
    }
    while(m--)
    {
        int k,u,b;
        cin>>k>>u>>b;
        if(k==0)cout<<sum(b)-sum(u-1)<<endl;
        else add(u,b);
    }
    return 0;
}

import java.util.Scanner;
import java.util.Arrays;

public class Main {

    static final int N = 100010;
    static int[] score = new int[N]; // 店铺的优先级
    static int[] last = new int[N]; // 上一次有订单的时刻
    static boolean[] st = new boolean[N]; // 表示店铺是否处于优先缓存中
    static PII[] order = new PII[N]; // 订单

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt(), m = sc.nextInt(), T = sc.nextInt();
        for (int i = 0; i < m; i++) order[i] = new PII(sc.nextInt(), sc.nextInt());
        Arrays.sort(order, 0, m);

        for (int i = 0; i < m;) { // 循环为了找到相同订单
            int j = i;
            while (j < m && order[j].ts == order[i].ts && order[j].id == order[i].id) j++;
            int t = order[i].ts, id = order[i].id;
            int cnt = j - i; // 同批订单的数量
            i = j;

            // 处理t时刻之前的信息
            score[id] -= t - last[id] - 1; // 中间没有订单的数量
            if (score[id] < 0) score[id] = 0;
            if (score[id] <= 3) st[id] = false; // 移出优先缓存

            // 处理t时刻的信息
            score[id] += cnt * 2; // 加上优先级
            if (score[id] > 5) st[id] = true; // 置于优先缓存

            last[id] = t;
        }

        for (int i = 1; i <= n; i++) {
            if (last[i] < T) {
                score[i] -= T - last[i]; // 此时不用-1，因为T时刻没有订单
                if (score[i] <= 3) st[i] = false;
            }
        }

        int res = 0;
        for (int i = 1; i <= n; i++) if (st[i]) res++;

        System.out.println(res);
    }

    static class PII implements Comparable<PII> {
        int ts;
        int id;

        public PII(int ts, int id) {
            this.ts = ts;
            this.id = id;
        }

        @Override
        public int compareTo(PII o) {
            if(this.ts > o.ts)  return 1;
            if(this.ts == o.ts) {
                if (this.id > o.id) return 1;
                return -1;
            }
            return -1;
        }
    }
}

#include<bits/stdc++.h>
using namespace std;
int getTime(void)
{
    int h1,m1,s1,h2,m2,s2,d=0;
    scanf("%d:%d:%d %d:%d:%d (+%d)",&h1,&m1,&s1,&h2,&m2,&s2,&d);
    int time=d*24*3600+h2*3600+m2*60+s2-(h1*3600+m1*60+s1);
    return time;
}
int main()
{
    int t;
    scanf("%d",&t);
    for(int i = 0; i < t; i++)
    {
        int time1=getTime();
        int time2=getTime();
        int t=(time1+time2)/2;
        printf("%02d:%02d:%02d\n", t/3600, t/60%60, t%60);
    }
    return 0;
}