kanapka

#include <iostream>
#include <cassert>
#include <cstdlib>
#include <cstdio>
#include <cstdint>
#include <tuple>
#include <vector>
using namespace std;
#include "kanapka.h"
#include "message.h"


template <class F>
tuple<int64_t,int64_t,int64_t,int64_t> taste( uint64_t first, uint64_t last, F f )
{// maksymalny spadek, suma do pierwszego ekstremum skumulowanego, suma od pierwszego
 // ekstremum (z wyłączeniem) do drugiego, suma reszty

    if (first>=last) return make_tuple(0,0,0,0);

    int64_t suma=0;
    int64_t max_delta=0;
    int64_t maxx=0;
    int64_t minn=10000000000000000llu;
    bool is_max_last=true;  //pilnuje, co było ostatnie, maksimum czy minimum

    for (uint64_t i =first ; i<last; i++)
    {
        suma+=f(i);//GetTaste(i);
        if (maxx-suma > max_delta) max_delta = maxx-suma;
        if (suma>maxx) {
            maxx=suma;
            is_max_last=true;
        }
        if (suma<minn){
            minn=suma;
            is_max_last=false;
        }
    }
    int64_t a=maxx,b=minn;
    if (is_max_last) swap(a,b);
    return make_tuple(max_delta, a,b-a,suma-b );
}



int main()
{


    int N = NumberOfNodes();
    int node = MyNodeId();
    {
        uint64_t ii = (node*GetN())/N; // wyliczenie zakresu dla node'a #GetN()
        uint64_t jj = ((node+1)*GetN())/N;

        int64_t a,b,c,delta;
        tie(delta, a,b,c) = taste(ii,jj,  GetTaste ) ;

        PutLL(0, delta);
        PutLL(0, a);
        PutLL(0, b);
        PutLL(0, c);
        Send(0);
    }

    if (node==0)
    {
        int64_t maxdelta=0;
        vector <int64_t> tab;
        int64_t a,b,c,delta;
        for (int i=0;i<N;i++)
        {
             Receive(i);
             delta =GetLL(i);
             a     =GetLL(i);
             b     =GetLL(i);
             c     =GetLL(i);
             maxdelta = max(delta, maxdelta);
             tab.push_back(a);
             tab.push_back(b);
             tab.push_back(c);
        }
        tie(delta, a,b,c) = taste(0,tab.size(),  [&tab](uint64_t i) { return tab[i]; } ) ;
        cout<<a+b+c+max(delta,maxdelta)<<endl; //suma minus najgorsza podkanapka
    }
    return 0;
}