Problem:
C: Project Management / プロジェクト管理
あなたは凄腕のプロジェクトマネージャである． 今回は超大規模なプロジェクトのマネジメントを請け負った．
図1:
アローダイアグラム
これまでの勘と経験からなんとか
図1
のようなアローダイアグラムを作成した． 各ノードは作業の結合点を表している． また，Sはプロジェクトの開始状態，Tはプロジェクトの終了状態を表す結合点である． 例えば結合点P3において，作業Gは作業Cと作業Eが終了しなければ開始できない． プロジェクトの計画は完璧であり，全ての結合点は，そこから出て再びその結合点に戻る作業経路を持たない． また，全ての作業は前後に結合点を持っており， 開始状態と終了状態以外の結合点は必ず前後に作業を持っている．
しかし，今回のプロジェクトは作業数が多い．
アローダイアグラムにおいて，所要時間が最長となる経路(クリティカルパス)上の作業は， プロジェクトの時間制約に大きく影響する． そこであなたはアローダイアグラム上のクリティカルパスの所要日数を計算するプログラムを書くことにした． ちなみに，このクリティカリパスは必ずアローダイアグラム上に存在する．
Input
入力は次の形式で表される．
n
m
a
1
b
1
c
1
...
a
m
b
m
c
m
n
( 2 ≦
n
≦ 400 ) は結合点の数，
m
( 1 ≦
m
≦ 800 ) は作業の数を表す整数である． このとき，結合点 0 が開始状態の結合点を表し，結合点
n
- 1 が終了状態の結合点を表している．
a
i
,
b
i
,
c
i
は1つの空白で区切られた整数であり， 結合点
a
i
( 0 ≦
a
i
≦
n
- 2 ) から
b
i
( 1 ≦
b
i
≦
n
- 1 ) までの作業に
c
i
( 1 ≦
c
i
≦ 100 ) 日必要なことを表している．
a
i
と
b
i
は常に異なっている． また，同じ
a
i
,
b
i
の組みは2度以上現れないと考えて良い．
Output
クリティカルパスの所要日数を表す整数を1行出力せよ． 出力にはこれら以外の文字があってはならない．
Sample Input 1
7 9
0 1 10
0 2 3
1 3 4
1 4 7
2 3 7
2 5 9
3 4 2
4 6 1
5 6 7
Sample Output 1
19

Submitted solutions:

code_snippet: #include<iostream>
#include<algorithm>
using namespace std;
int main() {
	int data[400][400], n, m, a, b, c;
	cin >> n >> m;
	for (int i = 0; i < n; ++i)
		for (int j = 0; j < n; ++j) data[i][j] = -10000000;
	for (int i = 0; i < m; ++i) {
		cin >> a >> b >> c;
		data[a][b] = c;
	}
	for (int i = 0; i < n; ++i) {
		for (int j = 0; j < n; ++j) {
			for (int k = 0; k < n; ++k) {
				data[j][k] = max(data[j][k], data[j][i] + data[i][k]);
			}
		}
	}
	cout << data[0][n - 1] << endl;
	return 0;
}
accuracy: 1
time_ms: 40
memory_kb: 3712
final_rank: 11

code_snippet: #include <iostream>
#include <iomanip>
#include <cstdio>
#include <string>
#include <cstring>
#include <deque>
#include <list>
#include <queue>
#include <stack>
#include <vector>
#include <utility>
#include <algorithm>
#include <map>
#include <set>
#include <complex>
#include <cmath>
#include <limits>
#include <cfloat>
#include <climits>
#include <ctime>
#include <cassert>
#include <numeric>
#include <fstream>
#include <functional>
#include <bitset>
#define chmin(a, b) ((a)=min((a), (b)))
#define chmax(a, b) ((a)=max((a), (b)))
#define fs first
#define sc second
#define eb emplace_back
using namespace std;

typedef long long ll;
typedef pair<int, int> P;
typedef tuple<int, int, int> T;

const ll MOD=1e9+7;
const ll INF=1e18;
const double pi=acos(-1);
const double eps=1e-10;

int dx[]={1, 0, -1, 0};
int dy[]={0, -1, 0, 1};

const int MAX_N = 410;

vector<vector<int>> dist(MAX_N, vector<int>(MAX_N, 1e9));
int warshall_floyd(int n){
    for(int k=0; k<n; k++){
        for(int i=0; i<n; i++){
            for(int j=0; j<n; j++){
                dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
            }
        }
    }

    return dist[0][n-1];
}

int main(){
    int n, m; cin>>n>>m;

    for(int i=0; i<n; i++) dist[i][i] = 0;

    for(int i=0; i<m; i++){
        int a, b, c; cin>>a>>b>>c;
        dist[a][b] = -c;
    }

    cout << -warshall_floyd(n) << endl;
}
accuracy: 1
time_ms: 40
memory_kb: 3576
final_rank: 10

code_snippet: #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i,n) for(int (i)=0;(i)<(int)(n);++(i))
#define all(x) (x).begin(),(x).end()
#define pb push_back
#define fi first
#define se second
#define dbg(x) cout<<#x" = "<<((x))<<endl
template<class T,class U> ostream& operator<<(ostream& o, const pair<T,U> &p){o<<"("<<p.fi<<","<<p.se<<")";return o;}
template<class T> ostream& operator<<(ostream& o, const vector<T> &v){o<<"[";for(T t:v){o<<t<<",";}o<<"]";return o;}

int main(){
    int n,m;
    cin >>n >>m;

    vector<vector<int>> d(n, vector<int>(n,-19191919));
    rep(i,m){
        int a,b,c;
        cin >>a >>b >>c;
        d[a][b] = c;
    }

    rep(k,n)rep(i,n)rep(j,n) d[i][j] = max(d[i][j], d[i][k]+d[k][j]);
    cout << d[0][n-1] << endl;
    return 0;
}
accuracy: 1
time_ms: 50
memory_kb: 3416
final_rank: 12

code_snippet: #include<iostream>
using namespace std;

int main(){
    int n, m;
    cin >> n >> m;

    int d[400][400] = {};
    int a, b, c;

    for(int i = 0; i < m; i++){
        cin >> a >> b >> c;
        d[a][b] = c;
    }

    for(int k = 0; k < n; k++){
        for(int i = 0; i < n; i++){
            for(int j = 0; j < n; j++){
                if(d[i][k] == 0 || d[k][j] == 0)    continue;
                d[i][j] = max(d[i][j], d[i][k]+d[k][j]);
            }
        }
    }

    cout << d[0][n-1] << endl;

    return 0;
}
accuracy: 1
time_ms: 30
memory_kb: 3748
final_rank: 8

code_snippet: #include<iostream>
#include<algorithm>
#include<vector>
#include<string>
#include<queue>
#include<stack>
#include<set>
#include<cmath>
#include<iomanip>
#include<functional>
using namespace std;

int MOD = 1e9 + 7;

typedef long long ll;
typedef pair<int, int> P;

vector<vector<int>> d(410, vector<int>(410, MOD));

void warshall_floyd(int n) {
	for (int k = 0; k < n; k++) {
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < n; j++) {
				d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
				//cout << d[i][j] << endl;
			}
		}
	}
}

int main() {
	int n, m;
	cin >> n >> m;
	vector<int> a(m + 1), b(m + 1), c(m + 1);
	for (int i = 1; i <= m; i++) {
		cin >> a[i] >> b[i] >> c[i];
		d[a[i]][b[i]] = -c[i];
	}

	warshall_floyd(n);
		
	cout << abs(d[0][n - 1]) << endl;
}
accuracy: 1
time_ms: 60
memory_kb: 3568
final_rank: 14

code_snippet: #include <iostream>
#include <algorithm>

using namespace std;

const int MAX = 401;
const int INF = -9999999;
 
int main(){
    int n,m,a,b,c,g[MAX][MAX];
    fill(g[0],g[MAX],INF);
 
    cin >> n >> m;
    for(int i = 0 ; i < m ; i++){
	cin >> a >> b >> c;
	g[a][b] = c;
    }
 
    for(int k = 0 ; k < n ; k++){
	for(int i = 0 ; i < n ; i++){
	    for(int j = 0 ; j < n ; j++){
		g[i][j] = max(g[i][j],g[i][k]+g[k][j]);
	    }
	}
    }
    
    cout << g[0][n-1] << endl;
    return 0;
}
accuracy: 1
time_ms: 50
memory_kb: 3712
final_rank: 13

code_snippet: #include <bits/stdc++.h>

#define INF (1 << 25)

using namespace std;

int dp[401][401];

int main()
{
  int n, m;
  cin >> n >> m;
  for(int i = 0; i < 401; i++){
    for(int j = 0; j < 401; j++){
      if(i == j) dp[i][j] = 0;
      else dp[i][j] = -INF;
    }
  }
  for(int i = 0; i < m; i++){
    int a, b, c;
    cin >> a >> b >> c;
    dp[a][b] = c;
  }
  for(int k = 0; k < n; k++){
    for(int i = 0; i < n; i++){
      for(int j = 0; j < n; j++) dp[i][j] = max(dp[i][j], dp[i][k] + dp[k][j]);
    }
  }
  cout << dp[0][n-1] << endl;
  return 0;
}
accuracy: 1
time_ms: 70
memory_kb: 1792
final_rank: 6

code_snippet: #include <iostream>
#include <algorithm>
using namespace std;
int const INF = 1<<18;
int main() {
  int N, M; cin >> N >> M;
  int G[420][420]; fill(G[0], G[0]+410*410, -INF);
  for(int i=0; i<M; i++) {
    int a, b; cin >> a >> b; cin >> G[a][b];
  }
  for(int i=0; i<N; i++) G[i][i] = 0;
  for(int k=0; k<N; k++)
    for(int i=0; i<N; i++)
      for(int j=0; j<N; j++)
        G[i][j] = max(G[i][j], G[i][k]+G[k][j]);
  cout << G[0][N-1] << endl;
  return 0;
}
accuracy: 1
time_ms: 70
memory_kb: 1824
final_rank: 7

code_snippet: #include <iostream>
#include <cstring>

using namespace std;

int n, m;
int G[500][500];

int dp[500];

void solve() {
	memset(dp, 0, sizeof(dp));
	
	dp[0] = 0;
	for (int i = 0; i < m; i++) {
		for (int j = 0; j < n; j++) {
			for (int k = 0; k < n; k++) {
				if (G[j][k] >= 0) {
					dp[k] = max(dp[k], dp[j] + G[j][k]);
				}
			}
		}
	}
	cout << dp[n-1] << endl;
}

int main() {
	cin >> n >> m;
	
	memset(G, -1, sizeof(G));
	for (int i=0; i<m; i++) {
		int a, b, c; cin >> a >> b >> c;
		G[a][b] = c;
	}
	
	solve();
	
	return 0;
}
accuracy: 1
time_ms: 80
memory_kb: 2148
final_rank: 9

code_snippet: #include<iostream>

#define rep(i,n) for(int i=0;i<(n);i++)
#define max(a,b) a>b?a:b;
using namespace std;

int d[401][401];
const int INF = 100000000;

int main() {
    rep(i,400) rep(j,400) d[i][j]=-INF;
    rep(i,400) d[i][i]=0;
    int n,m;
    cin>>n>>m;
    rep(i,m) {
        int a,b,c;
        cin>>a>>b>>c;
        d[a][b]=c;
    }
    rep(k,n) rep(i,n) rep(j,n) d[i][j] = max(d[i][j],d[i][k]+d[k][j]);

    cout<<d[0][n-1]<<endl;
    
    return 0;
}
accuracy: 1
time_ms: 70
memory_kb: 1788
final_rank: 4

code_snippet: #include<iostream>
 
using namespace std;

#define NMAX 400
#define INF 1000000

int max(int a,int b) {return (a>b)?a:b;}

int main(){
 
	int n,m;
	int a,b,c;
	int dp[NMAX][NMAX];

	cin>>n>>m;

	for(int i=0;i<n;i++){
		for(int j=0;j<n;j++){
			if(i!=j) dp[i][j]=-1*INF;
			else dp[i][j]=0;
		}
	}

	for(int i=0;i<m;i++){
		cin>>a>>b>>c;
		dp[a][b]=c;
	}

	for(int k=0;k<n;k++){
		for(int i=0;i<n;i++){
			for(int j=0;j<n;j++){
				if(dp[i][k]!=INF*-1&&dp[k][j]!=INF*-1) dp[i][j]=max(dp[i][j],dp[i][k]+dp[k][j]);
			}
		}
	}

	cout<<dp[0][n-1]<<endl;

	return 0;
}
accuracy: 1
time_ms: 50
memory_kb: 1780
final_rank: 2

code_snippet: #include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <vector>
#include <string>
#include <map>
#include <queue>
#include <stack>
#include <algorithm>
 
#define rep(i,j) REP((i), 0, (j))
#define REP(i,j,k) for(int i=(j);(i)<(k);++i)
#define between(a,x,b) ((a)<=(x)&&(x)<=(b))
#define INF 1 << 28
 
using namespace std;
 
int n, m;
int cost[400][400];
 
int main(){
  scanf("%d%d", &n, &m);
  rep(i, n) rep(j, n) cost[i][j] = 0;
  int a, b, c;
  rep(i, m){
    scanf("%d%d%d", &a, &b, &c);
    cost[a][b]  = c;
  }
 
  rep(k, n) rep(i, n) rep(j, n)  if(cost[i][k] && cost[k][j]) // if(i != j && k != i && k != j)
    cost[i][j] = max(cost[i][j], cost[i][k] + cost[k][j]);
 
  /*  rep(i, n){
    rep(j, n) printf("%d ", cost[i][j]);
    puts("");
    }*/
 
  printf("%d\n", cost[0][n-1]);
  return 0;
}
accuracy: 1
time_ms: 50
memory_kb: 1652
final_rank: 1

code_snippet: #include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <vector>
#include <string>
#include <map>
#include <queue>
#include <stack>
#include <algorithm>

#define rep(i,j) REP((i), 0, (j))
#define REP(i,j,k) for(int i=(j);(i)<(k);++i)
#define between(a,x,b) ((a)<=(x)&&(x)<=(b))
using namespace std;

int main(){
  int n, m, a, b, c, dp[401][401] = {};
  scanf("%d%d", &n, &m);
  rep(i, m){
    scanf("%d%d%d", &a, &b, &c);
    dp[a][b] = c;
  }
  rep(i, n-1) REP(j, 0, n) REP(k, 0, n-1) if(dp[i][k] > 0  && dp[k][j] > 0 && i != j && j != k && k != i)
    dp[i][j] = max(dp[i][j], dp[i][k] + dp[k][j]);
  /*  rep(i, n){
    rep(j, n) printf("%d ", dp[i][j]);
    puts("");
    }*/
  printf("%d\n", dp[0][n-1]);
  return 0;
}
accuracy: 0.2857142857142857
time_ms: 60
memory_kb: 1824
final_rank: 15

code_snippet: #include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <vector>
#include <string>
#include <map>
#include <queue>
#include <stack>
#include <algorithm>

#define rep(i,j) REP((i), 0, (j))
#define REP(i,j,k) for(int i=(j);(i)<(k);++i)
#define between(a,x,b) ((a)<=(x)&&(x)<=(b))
using namespace std;

int main(){
  int n, m, a, b, c, dp[401][401] = {};
  scanf("%d%d", &n, &m);
  rep(i, m){
    scanf("%d%d%d", &a, &b, &c);
    dp[a][b] = c;
  }
  rep(i, n-1) REP(j, 0, n) REP(k, 0, n-1) if(dp[i][k] > 0  && dp[k][j] > 0 && i != j)
    dp[i][j] = max(dp[i][j], dp[i][k] + dp[k][j]);
  /*  rep(i, n){
    rep(j, n) printf("%d ", dp[i][j]);
    puts("");
    }*/
  printf("%d\n", dp[0][n-1]);
  return 0;
}
accuracy: 0.2857142857142857
time_ms: 60
memory_kb: 1824
final_rank: 15

code_snippet: #include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <vector>
#include <string>
#include <map>
#include <queue>
#include <stack>
#include <algorithm>

#define rep(i,j) REP((i), 0, (j))
#define REP(i,j,k) for(int i=(j);(i)<(k);++i)
#define between(a,x,b) ((a)<=(x)&&(x)<=(b))
using namespace std;

int main(){
  int n, m, a, b, c, dp[401][401] = {};
  scanf("%d%d", &n, &m);
  rep(i, m){
    scanf("%d%d%d", &a, &b, &c);
    dp[a][b] = c;
  }
  rep(i, n-1) REP(j, 0, n) REP(k, 0, n-1) if(dp[i][k] > 0  && dp[k][j] > 0)
    dp[i][j] = max(dp[i][j], dp[i][k] + dp[k][j]);
  /*  rep(i, n){
    rep(j, n) printf("%d ", dp[i][j]);
    puts("");
    }*/
  printf("%d\n", dp[0][n-1]);
  return 0;
}
accuracy: 0.2857142857142857
time_ms: 60
memory_kb: 1824
final_rank: 15

code_snippet: #include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <vector>
#include <string>
#include <map>
#include <queue>
#include <stack>
#include <algorithm>

#define rep(i,j) REP((i), 0, (j))
#define REP(i,j,k) for(int i=(j);(i)<(k);++i)
#define between(a,x,b) ((a)<=(x)&&(x)<=(b))
using namespace std;

int main(){
  int n, m, a, b, c, dp[401][401] = {};
  scanf("%d%d", &n, &m);
  rep(i, m){
    scanf("%d%d%d", &a, &b, &c);
    dp[a][b] = c;
    //    dp[b][a] = -1;
  }
  rep(i, n) REP(j, 0, n) REP(k, 0, n) if(dp[i][k] > 0  && dp[k][j] > 0)
    dp[i][j] = max(dp[i][j], dp[i][k] + dp[k][j]);
  /*  rep(i, n){
    rep(j, n) printf("%d ", dp[i][j]);
    puts("");
    }*/
  printf("%d\n", dp[0][n-1]);
  return 0;
}
accuracy: 0.2857142857142857
time_ms: 60
memory_kb: 1824
final_rank: 15

code_snippet: #include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <vector>
#include <string>
#include <map>
#include <queue>
#include <stack>
#include <algorithm>

#define rep(i,j) REP((i), 0, (j))
#define REP(i,j,k) for(int i=(j);(i)<(k);++i)
#define between(a,x,b) ((a)<=(x)&&(x)<=(b))
using namespace std;

int main(){
  int n, m, a, b, c, dp[401][401] = {};
  scanf("%d%d", &n, &m);
  rep(i, m){
    scanf("%d%d%d", &a, &b, &c);
    dp[a][b] = c;
    dp[b][a] = -1;
  }
  rep(i, n-1) REP(j, 0, n) REP(k, 0, n) if(dp[i][j] != -1 && dp[i][k] > 0  && dp[k][j] > 0)
    dp[i][j] = max(dp[i][j], dp[i][k] + dp[k][j]);
  /*  rep(i, n){
    rep(j, n) printf("%d ", dp[i][j]);
    puts("");
    }*/
  printf("%d\n", dp[0][n-1]);
  return 0;
}
accuracy: 0.2857142857142857
time_ms: 80
memory_kb: 1824
final_rank: 19

code_snippet: #include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <vector>
#include <string>
#include <map>
#include <queue>
#include <stack>
#include <algorithm>

#define rep(i,j) REP((i), 0, (j))
#define REP(i,j,k) for(int i=(j);(i)<(k);++i)
#define between(a,x,b) ((a)<=(x)&&(x)<=(b))
using namespace std;

int main(){
  int n, m, a, b, c, dp[401][401] = {};
  scanf("%d%d", &n, &m);
  rep(i, m){
    scanf("%d%d%d", &a, &b, &c);
    dp[a][b] = c;
    dp[b][a] = -1;
  }
  rep(i, n) REP(j, i, n) REP(k, i, j) if(dp[i][j] != -1 && dp[i][k] > 0  && dp[k][j] > 0)
    dp[i][j] = max(dp[i][j], dp[i][k] + dp[k][j]);
  /*  rep(i, n){
    rep(j, n) printf("%d ", dp[i][j]);
    puts("");
    }*/
  printf("%d\n", dp[0][n-1]);
  return 0;
}
accuracy: 0.09523809523809523
time_ms: 20
memory_kb: 1824
final_rank: 20

code_snippet: #include <iostream>
#include <cstdio>
#include <cmath>
#include <vector>
#include <map>
#include <stack>
#include <queue>
#include <algorithm>
#include <set>

#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define REP(i,j) FOR(i,0,j)
#define mp std::make_pair

typedef long long ll;
typedef unsigned long long ull;
typedef std::pair<int,int> P;
typedef std::pair<int,P> State;

const int INF = 1001001001;

// S N E W(南北東西)
const int dx[8] = {0, 0, 1, -1, 1, 1, -1, -1}, dy[8] = {1, -1, 0, 0, 1, -1, 1, -1};

int N, M;
int d[400][400];

int main(){
    std::cin >> N >> M;
    
    REP(i, 400){
        REP(j, 400){
            if(i == j){d[i][j] = 0;}
            else{d[i][j] = -INF;}
        }
    }

    REP(i, M){
        int from, to, cost;
        std::cin >> from >> to >> cost;

        d[from][to] = cost;
    }

    REP(k, N){
        REP(i, N){
            REP(j, N){
                d[i][j] = std::max(d[i][j], d[i][k] + d[k][j]);
            }
        }
    }

    std::cout << d[0][N-1] << std::endl;
}
accuracy: 1
time_ms: 70
memory_kb: 1784
final_rank: 3

code_snippet: #include <iostream>
#include <algorithm>
using namespace std;
const int MAX = 401;
const int INF = -9999999;

int main(){
  int n,m,a,b,c,g[MAX][MAX];
  fill(g[0],g[MAX],INF);

  cin >> n >> m;
  for(int i = 0 ; i < m ; i++){
    cin >> a >> b >> c;
    g[a][b] = c;
  }

  for(int k = 0 ; k < n ; k++)
    for(int i = 0 ; i < n ; i++)
      for(int j = 0 ; j < n ; j++)
	g[i][j] = max(g[i][j],g[i][k]+g[k][j]);

  cout << g[0][n-1] << endl;

  return 0;
}
accuracy: 1
time_ms: 70
memory_kb: 1788
final_rank: 4