Language: C++

#include "bits/stdc++.h"
#define rep(i,n) for (int i=0; i<(n); ++i)
using namespace std;
using ll =long long;
using P =pair<int,int>;

int main(){
    ll n,m,p;
    cin >> n >> m >> p;
    vector <vector <vector<ll>>> ma(n);

    ll a,b,c;
    ll minmin=-1001001001001001;

    rep(i,m){
        cin >> a >> b >> c;
        --a;
        --b;
        ma[a].push_back({b,c});
    }

    vector <ll> ka(n,minmin),ka2(n,minmin);
    vector <int> bad(n,0);
    queue <ll> q;
    queue <vector <ll>> mi,mik;
    int qq;
    vector <ll> miq;
    queue <ll> tq;
    int l,l2;
    ll tqq;
    queue <ll> mo,kara;
    ll moq;
    queue <ll> qbad;
    ll qqbad;
    int qqq=0;

    /*rep(i,n){
        if(bad[i]==-1){
            continue;
        }
        else{
        ka=ka2;
        q.push(i);
        mi.push(ka);
        tq.push(0);
        mo.push(0);
        while(q.size()!=0){
            qq=q.front();
            q.pop();
            ka=mi.front();
            mi.pop();
            tqq=tq.front();
            tq.pop();
            moq=mo.front();
            mo.pop();
            l=ma[qq].size();
            qbad.push(qq);
            ka[qq]=1;
            rep(j,l){
                if(ka[ma[qq][j][0]]==0){
                    q.push(ma[qq][j][0]);
                    mi.push(ka);
                    tq.push(tqq+1);
                    mo.push(moq+ma[qq][j][1]);
                }
                if(ma[qq][j][0]==i){
                    if((moq+ma[qq][j][1])>p*(tqq+1)){
                        bad[i]=-1;
                        l2=qbad.size();
                        rep(i2,l2){
                            qqbad=qbad.front();
                            qbad.pop();
                            bad[qqbad]=-1;
                        }
                        qqq=1;
                        break;
                    }
                }
            }
            if(qqq==1){
                qqq=0;
                q=kara;
                mi=mik;
                tq=kara;
                mo=kara;
                break;

            }

                   }
        }
    }*/

    /*rep(i,n){
        cout << bad[i] << endl;
    }*/

    ll ans=0;
    if(bad[0]==-1 or bad[n-1]==-1){
        ans=-1;
    }

    int goal=0;

    vector <ll> answ(n,minmin);

    if(ans==0){
        ka=ka2;
        q.push(0);
        mi.push(ka);
        tq.push(0);
        mo.push(0);
        while(q.size()!=0){
            qq=q.front();
            //cout << qq << endl;
            q.pop();
            ka=mi.front();
            mi.pop();
            tqq=tq.front();
            tq.pop();
            moq=mo.front();
            mo.pop();
            if(bad[qq]==1){
                continue;
            }
            else if(answ[qq]>=(moq-tqq*q)){
                continue;
            }
            else{
                answ[qq]=moq-tqq*q;
            l=ma[qq].size();
            ka[qq]=moq-tqq*p;
            //ka[qq]=1;
            
            rep(j,l){
                if((moq+ma[qq][j][1])>ka[ma[qq][j][0]] and ka[ma[qq][j][0]]!=minmin){
                    bad[ma[qq][j][0]]=1;
                }
                /*else if(ma[qq][j][0]==(n-1)){
                    ans=max(ans,moq+ma[qq][j][1]-p*(tqq+1));
                    goal=1;
                }*/
                else if(ka[ma[qq][j][0]]==minmin and bad[ma[qq][j][0]]==0){
                    q.push(ma[qq][j][0]);
                    mi.push(ka);
                    tq.push(tqq+1);
                    mo.push(moq+ma[qq][j][1]);
                }
                
            }

                   }
        }

            /*rep(i,n){
                cout << bad[i] << endl;
            }*/
    }


























    ka=ka2;
        q.push(0);
        mi.push(ka);
        tq.push(0);
        mo.push(0);
        while(q.size()!=0){
            qq=q.front();
            //cout << qq << endl;
            q.pop();
            ka=mi.front();
            mi.pop();
            tqq=tq.front();
            tq.pop();
            moq=mo.front();
            mo.pop();
            l=ma[qq].size();
            ka[qq]=moq-tqq*p;
            //ka[qq]=1;
            
            rep(j,l){
                /*if((moq+ma[qq][j][1])>ka[ma[qq][j][0]] and ka[ma[qq][j][0]]!=minmin){
                    bad[ma[qq][j][0]]=1;
                }*/
                if(ma[qq][j][0]==(n-1)){
                    ans=max(ans,moq+ma[qq][j][1]-p*(tqq+1));
                    goal=1;
                }
                else if(ka[ma[qq][j][0]]==minmin and bad[ma[qq][j][0]]==0){
                    q.push(ma[qq][j][0]);
                    mi.push(ka);
                    tq.push(tqq+1);
                    mo.push(moq+ma[qq][j][1]);
                }
                
            }

                   }

                    if(bad[0]==1 or bad[n-1]==1){
                        ans=-1;
                    }
                   if(goal==1){
                       
                       cout << ans << endl;
                   }
                   else{
                       cout << -1 << endl;
                   }

            
    
    

    return 0;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:126:39: error: no match for 'operator*' (operand types are 'll' {aka 'long long int'} and 'std::queue<long long int>')
  126 |             else if(answ[qq]>=(moq-tqq*q)){
      |                                    ~~~^~
      |                                    |   |
      |                                    |   std::queue<long long int>
      |                                    ll {aka long long int}
In file included from /usr/include/c++/14/ccomplex:39,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:127,
                 from a.cc:1:
/usr/include/c++/14/complex:400:5: note: candidate: 'template<class _Tp> std::complex<_Tp> std::operator*(const complex<_Tp>&, const complex<_Tp>&)'
  400 |     operator*(const complex<_Tp>& __x, const complex<_Tp>& __y)
      |     ^~~~~~~~
/usr/include/c++/14/complex:400:5: note:   template argument deduction/substitution failed:
a.cc:126:40: note:   mismatched types 'const std::complex<_Tp>' and 'll' {aka 'long long int'}
  126 |             else if(answ[qq]>=(moq-tqq*q)){
      |                                        ^
/usr/include/c++/14/complex:409:5: note: candidate: 'template<class _Tp> std::complex<_Tp> std::operator*(const complex<_Tp>&, const _Tp&)'
  409 |     operator*(const complex<_Tp>& __x, const _Tp& __y)
      |     ^~~~~~~~
/usr/include/c++/14/complex:409:5: note:   template argument deduction/substitution failed:
a.cc:126:40: note:   mismatched types 'const std::complex<_Tp>' and 'll' {aka 'long long int'}
  126 |             else if(answ[qq]>=(moq-tqq*q)){
      |                                        ^
/usr/include/c++/14/complex:418:5: note: candidate: 'template<class _Tp> std::complex<_Tp> std::operator*(const _Tp&, const complex<_Tp>&)'
  418 |     operator*(const _Tp& __x, const complex<_Tp>& __y)
      |     ^~~~~~~~
/usr/include/c++/14/complex:418:5: note:   template argument deduction/substitution failed:
a.cc:126:40: note:   'std::queue<long long int>' is not derived from 'const std::complex<_Tp>'
  126 |             else if(answ[qq]>=(moq-tqq*q)){
      |                                        ^
In file included from /usr/include/c++/14/valarray:605,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:166:
/usr/include/c++/14/bits/valarray_after.h:407:5: note: candidate: 'template<class _Dom1, class _Dom2> std::_Expr<std::__detail::_BinClos<std::__multiplies, std::_Expr, std::_Expr, _Dom1, _Dom2>, typename std::__fun<std::__multiplies, typename _Dom1::value_type>::result_type> std::operator*(const _Expr<_Dom1, typename _Dom1::value_type>&, const _Expr<_Dom2, typename _Dom2::value_type>&)'
  407 |     _DEFINE_EXPR_BINARY_OPERATOR(*, struct std::__multiplies)
      |     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/valarray_after.h:407:5: note:   template argument deduction/substitution failed:
a.cc:126:40: note:   mismatched types 'const std::_Expr<_Dom1, typename _Dom1::value_type>' and 'll' {aka 'long long int'}
  126 |             else if(answ[qq]>=(moq-tqq*q)){
      |                                        ^
/usr/include/c++/14/bits/valarray_after.h:407:5: note: candidate: 'template<class _Dom> std::_Expr<std::__detail::_BinClos<std::__multiplies, std::_Expr, std::_Constant, _Dom, typename _Dom::value_type>, typename std::__fun<std::__multiplies, typename _Dom1::value_type>::result_type> std::operator*(const _Expr<_Dom1, typename _Dom1::value_type>&, const typename _Dom::value_type&)'
  407 |     _DEFINE_EXPR_BINARY_OPERATOR(*, struct std::__multiplies)
      |     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/valarray_after.h:407:5: note:   template argument deduction/substitution failed:
a.cc:126:40: note:   mismatched types 'const std::_Expr<_Dom1, typename _Dom1::value_type>' and 'll' {aka 'long long int'}
  126 |             else if(answ[qq]>=(moq-tqq*q)){
      |                                        ^
/usr/include/c++/14/bits/valarray_after.h:407:5: note: candidate: 'template<class _Dom> std::_Expr<std::__detail::_BinClos<std::__multiplies, std::_Constant, std::_Expr, typename _Dom::value_type, _Dom>, typename std::__fun<std::__multiplies, typename _Dom1::value_type>::result_type> std::operator*(const typename _Dom::value_type&, const _Expr<_Dom1, typename _Dom1::value_type>&)'
  407 |     _DEFINE_EXPR_BINARY_OPERATOR(*, struct std::__multiplies)
      |     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/valarray_after.h:407:5: note:   template argument deduction/substitution failed:
a.cc:126:40: note:   'std::queue<long long int>' is not derived from 'const std::_Expr<_Dom1, typename _Dom1::value_type>'
  126 |             else if(answ[qq]>=(moq-tqq*q)){
      |                                        ^
/usr/include/c++/14/bits/valarray_after.h:407:5: note: candidate: 'template<class _Dom> std::_Expr<std::__detail::_BinClos<std::__multiplies, std::_Expr, std::_ValArray, _Dom, typename _Dom::value_type>, typename std::__fun<std::__multiplies, typename _Dom1::value_type>::result_type> std::operator*(const _Expr<_Dom1, typename _Dom1::value_type>&, const valarray<typename _Dom::value_type>&)'
  407 |     _DEFINE_EXPR_BINARY_OPERATOR(*, struct std::__multiplies)
      |     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/valarray_after.h:407:5: note:   template argument deduction/substitution failed:
a.cc:126:40: note:   mismatched types 'const std::_Expr<_Dom1, typename _Dom1::value_type>' and 'll' {aka 'long long int'}
  126 |             else if(answ[qq]>=(moq-tqq*q)){
      |                                        ^
/usr/include/c++/14/bits/valarray_after.h:407:5: note: candidate: 'template<class _Dom> std::_Expr<std::__detail::_BinClos<std::__multiplies, std::_ValArray, std::_Expr, typename _Dom::value_type, _Dom>, typename std::__fun<std::__multiplies, typename _Dom1::value_type>::result_type> std::operator*(const valarray<typename _Dom::value_type>&, const _Expr<_Dom1, typename _Dom1::value_type>&)'
  407 |     _DEFINE_EXPR_BINARY_OPERATOR(*, struct std::__multiplies)
      |     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/valarray_after.h:407:5: note:   template argument deduction/substitution failed:
a.cc:126:40: note:   'std::queue<long long int>' is not derived from 'const std::_Expr<_Dom1, typename _Dom1::value_type>'
  126 |             else if(answ[qq]>=(moq-tqq*q)){
      |                                        ^
/usr/include/c++/14/valarray:1198:1: note: candidate: 'template<class _Tp> std::_Expr<std::__detail::_BinClos<std::__multiplies, std::_ValArray, std::_ValArray, _Tp, _Tp>, typename std::__fun<std::__multiplies, _Tp>::result_type> std::operator*(const valarray<_Tp>&, const valarray<_Tp>&)'
 1198 | _DEFINE_BINARY_OPERATOR(*, __multiplies)
      | ^~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/valarray:1198:1: note:   template argument deduction/substitution failed:
a.cc:126:40: note:   mismatched types 'const std::valarray<_Tp>' and 'll' {aka 'long long int'}
  126 |             else if(answ[qq]>=(moq-tqq*q)){
      |                                        ^
/usr/include/c++/14/valarray:1198:1: note: candidate: 'template<class _Tp> std::_Expr<std::__detail::_BinClos<std::__multiplies, std::_ValArray, std::_Constant, _Tp, _Tp>, typename std::__fun<std::__multiplies, _Tp>::result_type> std::operator*(const valarray<_Tp>&, const typename valarray<_Tp>::value_type&)'
 1198 | _DEFINE_BINARY_OPERATOR(*, __multiplies)
      | ^~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/valarray:1198:1: note:   template argument deduction/substitution failed:
a.cc:126:40: note:   mismatched types 'const std::valarray<_Tp>' and 'll' {aka 'long long int'}
  126 |             else if(answ[qq]>=(moq-tqq*q)){
      |                                        ^
/usr/include/c++/14/valarray:1198:1: note: candidate: 'template<class _Tp> std::_Expr<std::__detail::_BinClos<std::__multiplies, std::_Constant, std::_ValArray, _Tp, _Tp>, typename std::__fun<std::__multiplies, _Tp>::result_type> std::operator*(const typename valarray<_Tp>::value_type&, const valarray<_Tp>&)'
 1198 | _DEFINE_BINARY_OPERATOR(*, __multiplies)
      | ^~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/valarray:1198:1: note:   template argument deduction/substitution failed:
a.cc:126:40: note:   'std::queue<long long int>' is not derived from 'const std::valarray<_Tp>'
  126 |             else if(answ[qq]>=(moq-tqq*q)){
      |                                        ^
a.cc:130:33: error: no match for 'operator*' (operand types are 'll' {aka 'long long int'} and 'std::queue<long long int>')
  130 |                 answ[qq]=moq-tqq*q;
      |                              ~~~^~
      |                              |   |
      |                              |   std::queue<long long int>
      |                              ll {aka long long int}
/usr/include/c++/14/complex:400:5: note: candidate: 'template<class _Tp> std::complex<_Tp> std::operator*(const complex<_Tp>&, const complex<_Tp>&)'
  400 |     operator*(const complex<_Tp>& __x, const complex<_Tp>& __y)
      |     ^~~~~~~~
/usr/include/c++/14/complex:400:5: note:   template argument deduction/substitution failed:
a.cc:130:34: note:   mismatched types 'const std::complex<_Tp>' and 'll' {aka 'long long int'}
  130 |                 answ[qq]=moq-tqq*q;
      |                                  ^
/usr/include/c++/14/complex:409:5: note: candidate: 'template<class _Tp> std::complex<_Tp> std::operator*(const complex<_Tp>&, const _Tp&)'
  409 |     operator*(const complex<_Tp>& __x, const _Tp& __y)
      |     ^~~~~~~~
/usr/include/c++/14/complex:409:5: note:   template argument deduction/substitution failed:
a.cc:130:34: note:   mismatched types 'const std::complex<_Tp>' and 'll' {aka 'long long int'}
  130 |                 answ[qq]=moq-tqq*q;
      |                                  ^
/usr/include/c++/14/complex:418:5: note: candidate: 'template<class _Tp> std::complex<_Tp> std::operator*(const _Tp&, const complex<_Tp>&)'
  418 |     operator*(const _Tp& __x, const complex<_Tp>& __y)
      |     ^~~~~~~~
/usr/include/c++/14/complex:418:5: note:   template argument deduction/substitution failed:
a.cc:130:34: note:   'std::queue<long long int>' is not