criyle/codenet-compile-errors huggingface dataset:
Language: C++

#include <iostream>
#include <string>
#include <algorithm>
#include <vector>

using namespace std;
static const int N = 100;


void solve(vector<int> &data)
{
	vector<vector<int>> dp(N + 1, vector<int>(N + 1, 0));

	int nums = data.size() - 1;
	for (int len = 2; len <= nums; ++len)
	{
		for (int l = 1; l <= nums - len + 1; ++l)
		{
			int r = l + len - 1;
			dp[l][r] = INT_MAX;
			for (int m = l; m <= r - 1; ++m)
			{
				cout << len << " " << l << " " << r << endl;
				dp[l][r] = min(dp[l][r], dp[l][m] + dp[m+1][r] + data[l - 1] * data[m] * data[r]);
			}
		}
	}

	cout << dp[1][nums] << endl;
}

int main()
{
	int num; cin >> num;
	vector<int> data(num + 1);
	for (int i = 1; i <= num; ++i)
		cin >> data[i-1] >> data[i];

	solve(data);
}

Compiler output:
a.cc: In function 'void solve(std::vector<int>&)':
a.cc:20:36: error: 'INT_MAX' was not declared in this scope
   20 |                         dp[l][r] = INT_MAX;
      |                                    ^~~~~~~
a.cc:5:1: note: 'INT_MAX' is defined in header '<climits>'; this is probably fixable by adding '#include <climits>'
    4 | #include <vector>
  +++ |+#include <climits>
    5 |
Language: C++

#include <iostream>
#include <string>
#include <algorithm>
#include <vector>

using namespace std;
static const int N = 100;


void solve(vector<int> &data)
{
	vector<vector<int> > dp(N + 1, vector<int>(N + 1, 0));

	int nums = data.size() - 1;
	for (int len = 2; len <= nums; ++len)
	{
		for (int l = 1; l <= nums - len + 1; ++l)
		{
			int r = l + len - 1;
			dp[l][r] = INT_MAX;
			for (int m = l; m <= r - 1; ++m)
			{
				cout << len << " " << l << " " << r << endl;
				dp[l][r] = min(dp[l][r], dp[l][m] + dp[m+1][r] + data[l - 1] * data[m] * data[r]);
			}
		}
	}

	cout << dp[1][nums] << endl;
}

int main()
{
	int num; cin >> num;
	vector<int> data(num + 1);
	for (int i = 1; i <= num; ++i)
		cin >> data[i-1] >> data[i];

	solve(data);
}

Compiler output:
a.cc: In function 'void solve(std::vector<int>&)':
a.cc:20:36: error: 'INT_MAX' was not declared in this scope
   20 |                         dp[l][r] = INT_MAX;
      |                                    ^~~~~~~
a.cc:5:1: note: 'INT_MAX' is defined in header '<climits>'; this is probably fixable by adding '#include <climits>'
    4 | #include <vector>
  +++ |+#include <climits>
    5 |
Language: C++

#include <algorithm>
#include <iostream>
#include <string>
using namespace std;
static const int MAX = 100;
#define INF (1 << 30);

int store[MAX][MAX] = {{}};

struct matrix {
  int row;
  int col;
};

int nMul(matrix x, matrix y) { return x.row * x.col * y.col; }

matrix mult(matrix x, matrix y) {
  matrix mat;
  mat.row = x.row;
  mat.col = y.col;
  return mat;
}

int main() {
  matrix mat[MAX];
  int n;
  cin >> n;
  for (int i = 0; i < n; i++) {
    cin >> mat[i].row;
    cin >> mat[i].col;
  }

  int mcm[MAX][MAX] = {0};
  i         k         j
  for (int j = 1; j < n; j++) {
    for (int i = j-1; i >= 0; i--) {
      int minimum = INF;
      for (int k = i; k < j; k++) {
        int joint = nMul(mult(mat[i], mat[k]), mult(mat[k+1], mat[j]));
        int tmp = mcm[i][k] + mcm[k+1][j] + joint;
        minimum = min(minimum, tmp);
      }
      mcm[i][j] = minimum;
    }
  }

  cout << mcm[0][n-1] << endl;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:34:3: error: 'i' was not declared in this scope
   34 |   i         k         j
      |   ^
a.cc:35:19: error: 'j' was not declared in this scope
   35 |   for (int j = 1; j < n; j++) {
      |                   ^
Language: C++

#include <iostream>
#include <algorithm>
using namespace std;
??
static const int N = 100;
??
int main(){
????????int n, p[N+1], m[N+1][N+1];
????????cin >> n;
????????for (int i=1; i<=n; i++){
????????????????cin >> p[i-1] >> p[i];
????????}
??
????????for (int i=1; i<=n; i++) m[i][i] = 0;
????????for (int l=2; l <= n; l++){
????????????????for (int i=1; i<=n-l+1; i++){
????????????????????????int j = i + l - 1;
????????????????????????m[i][j] = 1 << 21;
????????????????????????for (int k = i; k<= j - 1; k++){
????????????????????????????????m[i][j] = min(m[i][j], m[i][k]+m[k+1][j]+p[i-1]*p[k]*p[j]);
????????????????????????}
????????????????}
????????}
????????cout << m[1][n] << "\n";
????????return 0;
}

Compiler output:
a.cc:4:1: error: expected unqualified-id before '?' token
    4 | ??
      | ^
a.cc:6:1: error: expected unqualified-id before '?' token
    6 | ??
      | ^
Language: C++

const int MAX_SIZE = 101;

int dp[MAX_SIZE][MAX_SIZE];

int solve(int p[], int begin,int end) {
	if (dp[begin][end] != -1)return dp[begin][end];
	if (begin >= end - 1)return 0;
	int res = -1;
	for (int i = begin + 1; i < end; i++) {
		int temp = solve(p, begin, i) + solve(p, i, end) + (p[begin] * p[i] * p[end]);
		if (res != -1) {
			res = min(temp, res);
		}
		else {
			res = temp;
		}
	}
	return dp[begin][end] = res;
}

int main() {
	int N;
	int p[MAX_SIZE + 1];

	cin >> N;
	for (int i = 0; i < N; i++) {
		cin >> p[i] >> p[i + 1];
	}

	for (int i = 0; i < MAX_SIZE; i++) {
		for (int j = 0; j < MAX_SIZE; j++) {
			dp[i][j] = -1;
		}
	}

	cout << solve(p, 0, N) << endl;
	return 0;
}

Compiler output:
a.cc: In function 'int solve(int*, int, int)':
a.cc:12:31: error: 'min' was not declared in this scope
   12 |                         res = min(temp, res);
      |                               ^~~
a.cc: In function 'int main()':
a.cc:25:9: error: 'cin' was not declared in this scope
   25 |         cin >> N;
      |         ^~~
a.cc:36:9: error: 'cout' was not declared in this scope
   36 |         cout << solve(p, 0, N) << endl;
      |         ^~~~
a.cc:36:35: error: 'endl' was not declared in this scope
   36 |         cout << solve(p, 0, N) << endl;
      |                                   ^~~~
Language: C++

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

static const int N = 100;

int main() {
	int n, p[N + 1], m[N + 1][N + 1];
	cin >> n;
	for (int i = 1; i <= n; i++) {
		cin >> p[i - 1] >> p[i];
	}
	for (int i = 1; i <= n; i++) m[i][i] = 0;
	for (int i = 2; i <= n; i++) {
		for (int i = 1; i <= n - l + 1; i++) {
			int j = i + l - 1;
			m[i][j] = (1 << 21);
			for (int k = i; k <= j - 1; k++) {
				m[i][j] = min(m[i][j], m[i][j] + m[k + 1][j] + p[i - 1] * p[k] * p[j]);
			}
		}
	}
	cout << m[1][n] << endl;

	return 0;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:15:42: error: 'l' was not declared in this scope
   15 |                 for (int i = 1; i <= n - l + 1; i++) {
      |                                          ^
Language: C++

#include<iostream>
#include<algorithm>
using namespace std;
static const int N=100;
int main(){
  int n,p[N+1],m[N+1][N+1];
  cin >> n;
  for(i=1;i<=n;i++){
    cin >> p[i-1] >> p[i];
  }
  for(int i=1;i<=n;i++) m[i][i]=0;
  for(int l=2;l<=n;l++){
    for(int i=1;i<=n-l+1;i++){
      int j=i+l-1;
      m[i][j]=(1<<21);
	for(int k=i;k<=j-1;k++){
	  m[i][j]=min(m[i][j],m[i][k]+m[i][k]+m[k+1][j]+p[i-1]*p[k]*p[j]);
        }
    }
  }
  cout << m[1][n] << endl;
  return 0;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:8:7: error: 'i' was not declared in this scope
    8 |   for(i=1;i<=n;i++){
      |       ^
Language: C++

#include <bits/stdc++.h>
using namespace std;

int N = 100;

int main(){
  int i,j,k,l;
  int n,p[N+1],m[N+1];
  cin >> n;
  for(i = 1; i <= n; i++){
    cin >> p[i-1];
    cin >> p[i];
  }
  for(i = 1; i <= n; i++){
    m[i][i] = 0;
  }
  for(j = 2; j <= n; j++){
    for(i = 1; i <= n-j+1;i++){
      k = i+j-1;
      m[i][k] = (1 << 21);
      for(l = i; l <= j-1; l++){
        m[i][k] =min(m[i][k],m[i][l]+m[i][l]+m[k+1][i-1]*p[k]p[j]);
      }
    }
  }
cout << m[1][n] << endl;
return 0;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:15:9: error: invalid types 'int[int]' for array subscript
   15 |     m[i][i] = 0;
      |         ^
a.cc:20:11: error: invalid types 'int[int]' for array subscript
   20 |       m[i][k] = (1 << 21);
      |           ^
a.cc:22:13: error: invalid types 'int[int]' for array subscript
   22 |         m[i][k] =min(m[i][k],m[i][l]+m[i][l]+m[k+1][i-1]*p[k]p[j]);
      |             ^
a.cc:22:26: error: invalid types 'int[int]' for array subscript
   22 |         m[i][k] =min(m[i][k],m[i][l]+m[i][l]+m[k+1][i-1]*p[k]p[j]);
      |                          ^
a.cc:22:34: error: invalid types 'int[int]' for array subscript
   22 |         m[i][k] =min(m[i][k],m[i][l]+m[i][l]+m[k+1][i-1]*p[k]p[j]);
      |                                  ^
a.cc:22:42: error: invalid types 'int[int]' for array subscript
   22 |         m[i][k] =min(m[i][k],m[i][l]+m[i][l]+m[k+1][i-1]*p[k]p[j]);
      |                                          ^
a.cc:22:52: error: invalid types 'int[int]' for array subscript
   22 |         m[i][k] =min(m[i][k],m[i][l]+m[i][l]+m[k+1][i-1]*p[k]p[j]);
      |                                                    ^
a.cc:26:13: error: invalid types 'int[int]' for array subscript
   26 | cout << m[1][n] << endl;
      |             ^
Language: C++

//#include <bits/stdc++.h>
#include <iostream>
#include <algorithm>

using namespace std;
static const int N = 100;

int main(){
  //int i,j,k,l;
  int n,p[N+1],m[N+1][N+1];
  cin >> n;
  for(int i = 1; i <= n; i++){
    cin >> p[i-1];
    cin >> p[i];
  }
  for(int i = 1; i <= n; i++){
    m[i][i] = 0;
  }
  for(int l = 2; l <= n; l++){
    for(int i = 1; i <= n-l+1;i++){
      int j = i+l-1;
      m[i][j] = INFINITY;
      for(int k = i; k <= j-1; k++){
        m[i][j] =min(m[i][j],m[i][k]+m[k+1][j]+p[i-1]*p[k]*p[j]);
      }
    }
  }
  cout << m[1][n] << endl;
  return 0;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:22:17: error: 'INFINITY' was not declared in this scope
   22 |       m[i][j] = INFINITY;
      |                 ^~~~~~~~
Language: C++

#include <stdio.h>
#include <limits.h>
 
#define MAX 100
 
int A[MAX],B[MAX][MAX],n;
    
main(){
  int i,r,c;
 
  scanf("%d",&n);
 
  for(i=0; i<n; i++)
    {
      scanf("%d %d",&r,&c);
      A[i]=r;
      A[i+1]=c;
    }
 
  MatrixChain();
 
  return 0;
}

void MatrixChain()
{
 
  int i,j,k,l,cost;
 
  for(i=1; i<=n; i++)
    {
      B[i][i]=0;
    }
 
  for(l=2; l<=n; l++)
    {
      for(i=1; i<=n-l+1; i++)
    {
      j=i+l-1;
      B[i][j]=INT_MAX;
 
      for(k=i; k<=j-1; k++)
        {
          cost=B[i][k]+B[k+1][j]+A[i-1]*A[k]*A[j];
          if(cost < B[i][j])
        {
          B[i][j]=cost;
        }
        }
    }
    }
  printf("%d\n",B[1][n]);
}

Compiler output:
a.cc:8:1: warning: ISO C++ forbids declaration of 'main' with no type [-Wreturn-type]
    8 | main(){
      | ^~~~
a.cc: In function 'int main()':
a.cc:20:3: error: 'MatrixChain' was not declared in this scope
   20 |   MatrixChain();
      |   ^~~~~~~~~~~
Language: C++

#include <bits.stdc++.h>
#define MAX 100
using namespace std;

int M[MAX][MAX];
int P[MAX][MAX];
int main(){
  int n;
  cin >> n;
  for(i = 1; i <= n; i++){
    cin >> P[i-1] >> P[i];
  }
  Ans = matrixChainMultiplication();
  return 0;
}


int matrixChainMultiplication(){
  for(i = 1; i < =n; i++){
    M[i][i] = 0;
  }
  for(l = 2; l <= n; l++){
    for(i = 1; i <= n-l+1; i++){
      j = i+l-1;
    }
    M[i][j] = INFINITY;
  }
  for(k = i; k <= j-1;k++){
    M[i][j] = min(M[i][j], M[i][k]+M[k+1][j]+P[i-1]*P[k]*P[j]);
  }
  return M[i][j];
}

Compiler output:
a.cc:1:10: fatal error: bits.stdc++.h: No such file or directory
    1 | #include <bits.stdc++.h>
      |          ^~~~~~~~~~~~~~~
compilation terminated.
Language: C++

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

int main(){
	int n, p[101],m[101][101];
	cin>>n;
	for(int i=1;i<=n;i++){
		cin>>p[i-1]>>p[i]
		}
		
	for(int i=1 ; i<=101 ; i++){
		m[i][i] = 0
	}
	
	for(int l=2;l<=n;l++){
		for(int i=1;i<n-l+1;i++){
			int j=i+l-1;
			m[i][j] = (1<<21);
			for(int k=i;k<j;k++){
				m[i][j] = min(m[i][j],m[i][k]+m[k+1][j]+p[i-1]*p[k]*p[j]]);
			}
		}
	}
	
	cout<<m[l][n]<<endl;
	return 0;
	
}

Compiler output:
a.cc: In function 'int main()':
a.cc:9:34: error: expected ';' before '}' token
    9 |                 cin>>p[i-1]>>p[i]
      |                                  ^
      |                                  ;
   10 |                 }
      |                 ~                 
a.cc:13:28: error: expected ';' before '}' token
   13 |                 m[i][i] = 0
      |                            ^
      |                            ;
   14 |         }
      |         ~                   
a.cc:21:89: error: expected ')' before ']' token
   21 |                                 m[i][j] = min(m[i][j],m[i][k]+m[k+1][j]+p[i-1]*p[k]*p[j]]);
      |                                              ~                                          ^
      |                                                                                         )
a.cc:26:17: error: 'l' was not declared in this scope
   26 |         cout<<m[l][n]<<endl;
      |                 ^
Language: C++

#include<cstdio>
#include<algorithm>
using namespace std;
static const int N=100;
int main(){
  int n,p[N+1],m[N+1][N+1];
  scanf("%d",n);;
  for(int i=1;i<=n;i++)
    cin >> p[i-1] >> p[i];
  for(int i=1;i<=n;i++)m[i][i]=0;
  for(int l=2;l<=n;l++){
    for(int i=1;i<=n-1+1;i++){
      int j=i+l-1;
      m[i][j]=(1<<21);
      for(int k=i;k<=j-1;k++){
	m[i][j]=min(m[i][j],m[i][k]+m[k+1][j]+p[i-1]*p[k]*p[j]);
      }
    }
  }
  printf("%d\n",m[1][n]);
  return 0;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:9:5: error: 'cin' was not declared in this scope
    9 |     cin >> p[i-1] >> p[i];
      |     ^~~
a.cc:3:1: note: 'std::cin' is defined in header '<iostream>'; this is probably fixable by adding '#include <iostream>'
    2 | #include<algorithm>
  +++ |+#include <iostream>
    3 | using namespace std;
Language: C++

#include<cstdio>
#include<algorithm>
static const int N=100;
int main(){
  int n,p[N+1],m[N+1][N+1];
  scanf("%d",n);;
  for(int i=1;i<=n;i++)
    scanf("%d%d",&p[i-1], &p[i]);
  for(int i=1;i<=n;i++)m[i][i]=0;
  for(int l=2;l<=n;l++){
    for(int i=1;i<=n-1+1;i++){
      int j=i+l-1;
      m[i][j]=(1<<21);
      for(int k=i;k<=j-1;k++){
	m[i][j]=min(m[i][j],m[i][k]+m[k+1][j]+p[i-1]*p[k]*p[j]);
      }
    }
  }
  printf("%d\n",m[1][n]);
  return 0;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:15:17: error: 'min' was not declared in this scope; did you mean 'std::min'?
   15 |         m[i][j]=min(m[i][j],m[i][k]+m[k+1][j]+p[i-1]*p[k]*p[j]);
      |                 ^~~
      |                 std::min
In file included from /usr/include/c++/14/algorithm:61,
                 from a.cc:2:
/usr/include/c++/14/bits/stl_algo.h:5696:5: note: 'std::min' declared here
 5696 |     min(initializer_list<_Tp> __l, _Compare __comp)
      |     ^~~
Language: C++

if __name__ == '__main__':
    N = input()


    m = [[0] * (N+1) for i in range(N+1)]

    p = [0] * N

    for i in range (N):
        p[i],dummy  = map(int, raw_input().split())
        
    p.append(dummy)

    for l in range (2, N+1):
        for i in range(1, N - l + 2):
            j = i + l - 1
            m[i][j] = float("inf")
            for k in range(i, j):
                m[i][j] = min(m[i][j], m[i][k] + m[k+1][j] + p[i-1] * p[k] * p[j])

print "", m[1][N]

Compiler output:
a.cc:1:16: warning: multi-character literal with 8 characters exceeds 'int' size of 4 bytes
    1 | if __name__ == '__main__':
      |                ^~~~~~~~~~
a.cc:1:1: error: expected unqualified-id before 'if'
    1 | if __name__ == '__main__':
      | ^~
Language: C++

#include<algorithm>
#include<iostream>
#include<cstdlib>
#include<cstring>
#include<cstdio>
#include<vector>
#include<queue>
#include<stack>
#include<cmath>
#include<list>
#include<map>
#include<set>
using namespace std;

typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int,int> PII;
typedef long long LL;

#define d(x)  cout<<#x<<" = "<<(x)<<endl;
#define ALL(a)  (a).begin(),(a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define MP make_pair
#define SZ(a) int((a).size())
#define EACH(i,c) for(typeof((c).begin()) i=(c).begin(); i!=(c).end(); ++i)
#define REACH(i,c) for(typeof((c).rbegin()) i=(c).rbegin(); i!=(c).rend(); ++i)
#define EXIST(s,e) ((s).find(e)!=(s).end())
#define SORT(c,n) sort(c,c+n)
#define VSORT(c) sort((c).begin(),(c).end())
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n)  FOR(i,0,n)
#define DFOR(i,b,a) for(int i=(b)-1;i>=(a);--i)
#define DREP(i,n) DFOR(i,n,0)
#define INF 2000000000

const double EPS = 1e-10;
const double PI  = acos(-1.0);
////////////////////////////////////////////////

Compiler output:
/usr/bin/ld: /usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu/Scrt1.o: in function `_start':
(.text+0x17): undefined reference to `main'
collect2: error: ld returned 1 exit status
Language: C++

#include<iostream>
#include<algorithm>

#define INF(1 << 21)

using namespace std;

int main {

    int i, j, k, l, n, p[101], m[101][101];

    cin >> n;

    for (i = 1; i <= n; i++) {
        cin >> p[i - 1] >> p[i];
    }

    for (i = 1; i<= n; i++) {
        m[i][i] = 0;
    }

    for (l = 2; l <= n; l++) {
        for (i = 1; i <= n - l+ 1; i++) {
            j = i + l - 1;
            m[i][j] = INF;

            for (k = i; k <=j - 1; k++) {
                m[i][j] = min (m[i][j], m[i][k] + m[k + 1][j] + p[i - 1] * p[k] * p[j]);
            }
        }
    }

    cout << m[1][n] << endl;

    return 0;

}

Compiler output:
a.cc:4:13: error: expected parameter name, found "1"
    4 | #define INF(1 << 21)
      |             ^
a.cc:8:5: error: cannot declare '::main' to be a global variable
    8 | int main {
      |     ^~~~
a.cc:10:5: error: expected primary-expression before 'int'
   10 |     int i, j, k, l, n, p[101], m[101][101];
      |     ^~~
a.cc:10:5: error: expected '}' before 'int'
a.cc:8:10: note: to match this '{'
    8 | int main {
      |          ^
a.cc:12:5: error: 'cin' does not name a type
   12 |     cin >> n;
      |     ^~~
a.cc:14:5: error: expected unqualified-id before 'for'
   14 |     for (i = 1; i <= n; i++) {
      |     ^~~
a.cc:14:17: error: 'i' does not name a type
   14 |     for (i = 1; i <= n; i++) {
      |                 ^
a.cc:14:25: error: 'i' does not name a type
   14 |     for (i = 1; i <= n; i++) {
      |                         ^
a.cc:18:5: error: expected unqualified-id before 'for'
   18 |     for (i = 1; i<= n; i++) {
      |     ^~~
a.cc:18:17: error: 'i' does not name a type
   18 |     for (i = 1; i<= n; i++) {
      |                 ^
a.cc:18:24: error: 'i' does not name a type
   18 |     for (i = 1; i<= n; i++) {
      |                        ^
a.cc:22:5: error: expected unqualified-id before 'for'
   22 |     for (l = 2; l <= n; l++) {
      |     ^~~
a.cc:22:17: error: 'l' does not name a type
   22 |     for (l = 2; l <= n; l++) {
      |                 ^
a.cc:22:25: error: 'l' does not name a type
   22 |     for (l = 2; l <= n; l++) {
      |                         ^
a.cc:33:5: error: 'cout' does not name a type
   33 |     cout << m[1][n] << endl;
      |     ^~~~
a.cc:35:5: error: expected unqualified-id before 'return'
   35 |     return 0;
      |     ^~~~~~
a.cc:37:1: error: expected declaration before '}' token
   37 | }
      | ^
Language: C++

#include<iostream>
#include<algorithm>

using namespace std;

int main {

    int i, j, k, l, n, p[101], m[101][101];

    cin >> n;

    for (i = 1; i <= n; i++) {
        cin >> p[i - 1] >> p[i];
    }

    for (i = 1; i<= n; i++) {
        m[i][i] = 0;
    }

    for (l = 2; l <= n; l++) {
        for (i = 1; i <= n - l+ 1; i++) {
            j = i + l - 1;
            m[i][j] = (1 << 21);

            for (k = i; k <=j - 1; k++) {
                m[i][j] = min (m[i][j], m[i][k] + m[k + 1][j] + p[i - 1] * p[k] * p[j]);
            }
        }
    }

    cout << m[1][n] << endl;

    return 0;

}

Compiler output:
a.cc:6:5: error: cannot declare '::main' to be a global variable
    6 | int main {
      |     ^~~~
a.cc:8:5: error: expected primary-expression before 'int'
    8 |     int i, j, k, l, n, p[101], m[101][101];
      |     ^~~
a.cc:8:5: error: expected '}' before 'int'
a.cc:6:10: note: to match this '{'
    6 | int main {
      |          ^
a.cc:10:5: error: 'cin' does not name a type
   10 |     cin >> n;
      |     ^~~
a.cc:12:5: error: expected unqualified-id before 'for'
   12 |     for (i = 1; i <= n; i++) {
      |     ^~~
a.cc:12:17: error: 'i' does not name a type
   12 |     for (i = 1; i <= n; i++) {
      |                 ^
a.cc:12:25: error: 'i' does not name a type
   12 |     for (i = 1; i <= n; i++) {
      |                         ^
a.cc:16:5: error: expected unqualified-id before 'for'
   16 |     for (i = 1; i<= n; i++) {
      |     ^~~
a.cc:16:17: error: 'i' does not name a type
   16 |     for (i = 1; i<= n; i++) {
      |                 ^
a.cc:16:24: error: 'i' does not name a type
   16 |     for (i = 1; i<= n; i++) {
      |                        ^
a.cc:20:5: error: expected unqualified-id before 'for'
   20 |     for (l = 2; l <= n; l++) {
      |     ^~~
a.cc:20:17: error: 'l' does not name a type
   20 |     for (l = 2; l <= n; l++) {
      |                 ^
a.cc:20:25: error: 'l' does not name a type
   20 |     for (l = 2; l <= n; l++) {
      |                         ^
a.cc:31:5: error: 'cout' does not name a type
   31 |     cout << m[1][n] << endl;
      |     ^~~~
a.cc:33:5: error: expected unqualified-id before 'return'
   33 |     return 0;
      |     ^~~~~~
a.cc:35:1: error: expected declaration before '}' token
   35 | }
      | ^
Language: C++

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

static const int N = 100;

int main()  {
	int n, p[N + 1], m[N + 1][N + 1];
	cin >> n;
	for (int i = 1; i <= n; i++)	{
		cin >> p[i - 1] >> p[i];
	}
	
	for (int i = 1; i <= n; i++)
		m[i][i] = 0;
	for (int l = 2; l <= n; l++)	{
		for (int i = 1; i <= n - l + 1; i++)	{
			int j = i + l - 1;
			m[i][j] =  (1 << 21);
			for (int k = i; k <= j - 1; k++)	{
				m[i][j] = min(m[i][j], m[i][k] + m[k + 1][j] + p[i - 1] * p[]k] * p[j]);
			}
		}
	}
	
	cout << m[i][n] << endl;
	
	return 0;
}			

Compiler output:
a.cc: In function 'int main()':
a.cc:21:93: error: expected primary-expression before ']' token
   21 |                                 m[i][j] = min(m[i][j], m[i][k] + m[k + 1][j] + p[i - 1] * p[]k] * p[j]);
      |                                                                                             ^
a.cc:26:19: error: 'i' was not declared in this scope
   26 |         cout << m[i][n] << endl;
      |                   ^
Language: C++

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

static const int N = 100;

int main()  {
	int n, p[N + 1], m[N + 1][N + 1];
	cin >> n;
	for (int i = 1; i <= n; i++)	{
		cin >> p[i - 1] >> p[i];
	}
	
	for (int i = 1; i <= n; i++)
		m[i][i] = 0;
	for (int l = 2; l <= n; l++)	{
		for (int i = 1; i <= n - l + 1; i++)	{
			int j = i + l - 1;
			m[i][j] =  (1 << 21);
			for (int k = i; k <= j - 1; k++)	{
				m[i][j] = min(m[i][j], m[i][k] + m[k + 1][j] + p[i - 1] * p[k] * p[j]);
			}
		}
	}
	
	cout << m[i][n] << endl;
	
	return 0;
}			

Compiler output:
a.cc: In function 'int main()':
a.cc:26:19: error: 'i' was not declared in this scope
   26 |         cout << m[i][n] << endl;
      |                   ^
Language: C++

#include <stdlib.h>
#include <stdio.h>

int MCM(int n){


int main(){

int i,n,m[100];

scanf("%d",&n);
for(i=0;i<n;i++){
    scanf("%d %d",&m[i],&m[i+1]);
   }
printf("%d\n",MCM(n));
return 0;
}

Compiler output:
a.cc: In function 'int MCM(int)':
a.cc:7:9: warning: empty parentheses were disambiguated as a function declaration [-Wvexing-parse]
    7 | int main(){
      |         ^~
a.cc:7:9: note: remove parentheses to default-initialize a variable
    7 | int main(){
      |         ^~
      |         --
a.cc:7:9: note: or replace parentheses with braces to value-initialize a variable
a.cc:7:11: error: a function-definition is not allowed here before '{' token
    7 | int main(){
      |           ^
a.cc:17:2: error: expected '}' at end of input
   17 | }
      |  ^
a.cc:4:15: note: to match this '{'
    4 | int MCM(int n){
      |               ^
a.cc:17:2: warning: no return statement in function returning non-void [-Wreturn-type]
   17 | }
      |  ^
Language: C++

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

static const int N = 100;

int main(){
  int n,p[N + 1], m[N + 1][N + 1];
  cin >> p[i - 1] >> p[i];
 }

 for(int i = 1;i <=n; i++)m[i][i] = 0;
 for(int l = 2;l <=n; l++){
    for(int i = 1; i <= n - l + 1; i++){
    int j = i + l - 1;
    m[i][j] = (1 << 21);
    for(int k = i; k <= j - 1; k++){
    m[i][j] = min(m[i][j],m[i][k] + m[k + 1][j] + p[i - 1]*p[k]*p[j]);
    }
  }
}
   cout << m[1][n] << endl;

   return0;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:9:12: error: 'i' was not declared in this scope
    9 |   cin >> p[i - 1] >> p[i];
      |            ^
a.cc: At global scope:
a.cc:12:2: error: expected unqualified-id before 'for'
   12 |  for(int i = 1;i <=n; i++)m[i][i] = 0;
      |  ^~~
a.cc:12:16: error: 'i' does not name a type
   12 |  for(int i = 1;i <=n; i++)m[i][i] = 0;
      |                ^
a.cc:12:23: error: 'i' does not name a type
   12 |  for(int i = 1;i <=n; i++)m[i][i] = 0;
      |                       ^
a.cc:13:2: error: expected unqualified-id before 'for'
   13 |  for(int l = 2;l <=n; l++){
      |  ^~~
a.cc:13:16: error: 'l' does not name a type
   13 |  for(int l = 2;l <=n; l++){
      |                ^
a.cc:13:23: error: 'l' does not name a type
   13 |  for(int l = 2;l <=n; l++){
      |                       ^
a.cc:22:4: error: 'cout' does not name a type
   22 |    cout << m[1][n] << endl;
      |    ^~~~
a.cc:24:4: error: 'return0' does not name a type
   24 |    return0;
      |    ^~~~~~~
a.cc:25:1: error: expected declaration before '}' token
   25 | }
      | ^
Language: C++

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

static const int N = 100;

int main(){
  int n,p[N + 1], m[N + 1][N + 1];
  cin >> n;
  for(int i = 1; i <=n; i++){
  cin >> p[i - 1] >> p[i];
 }

 for(int i = 1;i <=n; i++)m[i][i] = 0;
 for(int l = 2;l <=n; l++){
    for(int i = 1; i <= n - l + 1; i++){
    int j = i + l - 1;
    m[i][j] = (1 << 21);
    for(int k = i; k <= j - 1; k++){
    m[i][j] = min(m[i][j],m[i][k] + m[k + 1][j] + p[i - 1]*p[k]*p[j]);
    }
  }
}
   cout << m[1][n] << endl;

   return0;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:26:4: error: 'return0' was not declared in this scope
   26 |    return0;
      |    ^~~~~~~
Language: C++

#include <stdio.h>

int main(void)
{
 int i,j,k,l,n,m,a[100],b[100][100];

 scanf("%d",&n);

 for(i=0;i<n;i++){
   scanf("%d %d",&a[i],&m);
 }

 a[n]=m;

 for(i=1;i<=n;i++){
   b[i][i]=0;
 }

 for(i=2;i<=n;i++){
  for(j=1;j<=n-i+1;j++){

    l=j+i-1;

    b[j][l]=1000000;

    for(k=j;k<=l-1;k++){

      m=b[j][k]+b[k+1][l]+a[j-1]*a[k]*a[l];

      if(b[j][l]<m){
        b[j][l]=m;
    }
  }
 }

 printf("%d\n",b[1][n]);

 return 0;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:39:2: error: expected '}' at end of input
   39 | }
      |  ^
a.cc:4:1: note: to match this '{'
    4 | {
      | ^
Language: C++

#include <iostream>
#include<climits>
using namespace std;
int m[100][100];

int MCM(int p[],int n) {
	for (int i = 0; i <= n; i++)
		m[i][i] = 0;
	for (int l = 2; l <= n; l++) {
		for (int i = 1; i <= n - l + 1; i++) {
			int j = i + l - 1;
			m[i][j] = INT_MAX;
			for (int k = i; k <= j; k++) {
				int q = m[i][k] + m[k + 1][j] + p[i - 1] * p[k] * p[j];
				if (m[i][j] > q) {
					m[i][j] = q;
				}

			}
		}

	}
	return m[1][n];
}

int main() {
	int n, p[200];
	cin >> n;
	for (int i = 0; i < n; i++) {
		cin >> p[i] >> p[i + 1];
	}
	cout << MCM(p, n) << endl;
	return 0;
}


int main() {
	int n, p[200];
	cin >> n;
	for (int i = 0; i < n; i++) {
		cin >> p[2*i] >> p[2*i + 1];
	}
	cout << MCM(p, n) << endl;
	return 0;
}

Compiler output:
a.cc:37:5: error: redefinition of 'int main()'
   37 | int main() {
      |     ^~~~
a.cc:26:5: note: 'int main()' previously defined here
   26 | int main() {
      |     ^~~~
Language: C++

#include <iostream>
using namespace std;

int n, p = 0, min = 101, mini;
int v[101];

int main()
{
	cin >> n;

	for (int i = 0; i < n; i++) {
		cin >> v[i] >> v[i + 1];
		if (min > v[i]) {
			min = v[i];
			mini = i;
		}
	}

	for (int j = 0; j < n; j++)
		p += v[j] * v[j + 1];
	p += v[0] * v[n];

	if (mini == 0)
		p -= v[0] * v[1];
	else if (mini == n)
		p -= v[n - 1] * v[n];
	else
		p -= v[mini] * (v[mini + 1] + v[mini - 1]);

	p *= v[mini];

	cout << p << endl;

	return 0;
}


Compiler output:
a.cc: In function 'int main()':
a.cc:13:21: error: reference to 'min' is ambiguous
   13 |                 if (min > v[i]) {
      |                     ^~~
In file included from /usr/include/c++/14/string:51,
                 from /usr/include/c++/14/bits/locale_classes.h:40,
                 from /usr/include/c++/14/bits/ios_base.h:41,
                 from /usr/include/c++/14/ios:44,
                 from /usr/include/c++/14/ostream:40,
                 from /usr/include/c++/14/iostream:41,
                 from a.cc:1:
/usr/include/c++/14/bits/stl_algobase.h:281:5: note: candidates are: 'template<class _Tp, class _Compare> constexpr const _Tp& std::min(const _Tp&, const _Tp&, _Compare)'
  281 |     min(const _Tp& __a, const _Tp& __b, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:233:5: note:                 'template<class _Tp> constexpr const _Tp& std::min(const _Tp&, const _Tp&)'
  233 |     min(const _Tp& __a, const _Tp& __b)
      |     ^~~
a.cc:4:15: note:                 'int min'
    4 | int n, p = 0, min = 101, mini;
      |               ^~~
a.cc:14:25: error: reference to 'min' is ambiguous
   14 |                         min = v[i];
      |                         ^~~
/usr/include/c++/14/bits/stl_algobase.h:281:5: note: candidates are: 'template<class _Tp, class _Compare> constexpr const _Tp& std::min(const _Tp&, const _Tp&, _Compare)'
  281 |     min(const _Tp& __a, const _Tp& __b, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:233:5: note:                 'template<class _Tp> constexpr const _Tp& std::min(const _Tp&, const _Tp&)'
  233 |     min(const _Tp& __a, const _Tp& __b)
      |     ^~~
a.cc:4:15: note:                 'int min'
    4 | int n, p = 0, min = 101, mini;
      |               ^~~
Language: C++

#include <iostream>
using namespace std;

int n, a[100], v[101];
long sum, m = 1000000000;
bool f[100], g[100];

void permsum(int p) {
	if (p == n - 1) {
		sum = 0;
		memset(g, 0, 100);
		for (int i = 0; i < n - 1; i++) {
			g[a[i]] = 1;
			int u = 1, w = 1;
			while (g[a[i] - u])
				u++;
			while (g[a[i] + w])
				w++;
			sum += v[a[i] - u] * v[a[i]] * v[a[i] + w];			
		}
		if (m > sum)
			m = sum;
	}
	else {
		for (int j = 0; j < n - 1; j++) {
			if (!f[j]) {
				a[p] = j + 1;
				f[j] = 1;
				permsum(p + 1);
				f[j] = 0;
			}
		}
	}
}

int main()
{
	cin >> n;

	for (int i = 0; i < n; i++)
		cin >> v[i] >> v[i + 1];

	permsum(0);

	cout << m << endl;

	return 0;
}


Compiler output:
a.cc: In function 'void permsum(int)':
a.cc:11:17: error: 'memset' was not declared in this scope
   11 |                 memset(g, 0, 100);
      |                 ^~~~~~
a.cc:2:1: note: 'memset' is defined in header '<cstring>'; this is probably fixable by adding '#include <cstring>'
    1 | #include <iostream>
  +++ |+#include <cstring>
    2 | using namespace std;
Language: C++


#include <stdio.h>
#include <stdlib.h>

int *r, *c;

int main() {
  int n, i;

  scanf("%d", &n);

  r = (int *) malloc(sizeof(int)*n);
  c = (int *) malloc(sizeof(int)*n);

  for(i = 0; i < n; i++) {
    scanf("%d %d", &r[i], &c[i]);
  }

  printf("%d\n", cost(0, n-1));

  free(r);
  free(c);

  return 0;
}

int cost(int a, int b) {
  if (a == b) {
    return 0;
  } else {
    int total, minTotal = 1000000, m;

    for(m = a; m < b; m++) {
      total = cost(a, m) + cost(m+1, b) + r[a]*c[m]*c[b];
      if (total < minTotal)
        minTotal = total;
    }

    return minTotal;
  }
}




Compiler output:
a.cc: In function 'int main()':
a.cc:19:18: error: 'cost' was not declared in this scope; did you mean 'const'?
   19 |   printf("%d\n", cost(0, n-1));
      |                  ^~~~
      |                  const
Language: C++

#include<bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef pair<ll,ll> pii;
typedef pair<ll,pii> iii;

const ll oo = 0x3f3f3f3f;

int N, M, a[MAX][MAX];

int R(vector<int> h){

    int rec = 0;

    stack<int> st;

    vector<int> l(M, 0);

    for(int I = 0; I < M;++I){

        while(!st.empty() && h[st.top()] >= h[I])
            st.pop();
        if(st.empty()){
            l[I] = 0;
        }
        else l[I] = st.top() + 1;

        st.push(I);
    }

    while(!st.empty())
        st.pop();

    vector<int> r(M, 0);

    for(int I = M - 1;I >= 0;--I){

        while(!st.empty() && h[st.top()] >= h[I])
            st.pop();
        if(st.empty()){
            r[I] = M-1;
        }
        else r[I] = st.top() - 1;

        st.push(I);
    }

    for(int I = 0;I < M;++I){
        rec = max(rec, (r[I] - l[I] + 1)*h[I]);
    }

    return rec;
}

int main()
{
    ios_base :: sync_with_stdio(0);
    cin.tie(0);

    cin >> N >> M;

    vector<int> h(M, 0);

    for(int I = 0;I < N;++I){
        for(int K = 0;K < M;++K) {
            cin >> a[I][K];
            if (a[I][K])
                a[I][K] = 0;
            else a[I][K] = 1;
        }
        if(!I){
            for(int K = 0;K < M;++K)
                h[K] = a[I][K];
        }
    }

    int solve = R(h);

    for(int I = 1;I < N;++I){

        for(int K = 0;K < M;++K) {

            if (a[I][K])
                a[I][K] += a[I - 1][K];
        }

        for(int K = 0;K < M;++K)
            h[K] = a[I][K];

        solve = max(solve, R(h));
    }

    cout << solve << endl;
}


Compiler output:
a.cc:11:13: error: 'MAX' was not declared in this scope
   11 | int N, M, a[MAX][MAX];
      |             ^~~
a.cc:11:18: error: 'MAX' was not declared in this scope
   11 | int N, M, a[MAX][MAX];
      |                  ^~~
a.cc: In function 'int main()':
a.cc:68:20: error: 'a' was not declared in this scope
   68 |             cin >> a[I][K];
      |                    ^
a.cc:75:24: error: 'a' was not declared in this scope
   75 |                 h[K] = a[I][K];
      |                        ^
a.cc:85:17: error: 'a' was not declared in this scope
   85 |             if (a[I][K])
      |                 ^
a.cc:90:20: error: 'a' was not declared in this scope
   90 |             h[K] = a[I][K];
      |                    ^
Language: C++

#include <bits/stdc++.h>
#define r(i,n) for(int i=0;i<n;i++)
using namespace std;
int dp[111][111],n,L[111],R[111];

int dfs(int l,int r){
	if(dp[l][r]!=-1)return dp[l][r];
	int res=1e9;
	for(int i=l;i<r;i++){
		res=min(res,dfs(l,i)+dfs(i+1,r)+L[l]*R[i]*R[r]);
	}
	return dp[l][r]=res;
}

signed main(){
	memset(dp,-1,sizeof(dp));
	r(i,111)dp[i][j]=0;
	cin>>n;
	r(i,n)cin>>L[i]>>R[i];
	cout<<dfs(0,n-1)<<endl;
}


Compiler output:
a.cc: In function 'int main()':
a.cc:17:23: error: 'j' was not declared in this scope
   17 |         r(i,111)dp[i][j]=0;
      |                       ^
Language: C++

#include <iostream>
#include <algorithm>
#include <cstdint>

using namespace std;

static const int N = 100;
static int m[N + 1][N + 1] = {}, p[N + 1] = {};

static inline void matrixChainMultiplication(int n) {
  for (int l = 2; l <= n; l++) {
    for (int i = 1; i <= n - l + 1; i++) {
      int j = i + l - 1;
      m[i][j] = INT_MAX;
      for (int k = i; k <= j - 1; k++) {
        m[i][j] = min(m[i][j], m[i][k] + m[k + 1][j] + p[i - 1] * p[k] * p[j]); 
      }
    }
  }
}

int main() {
  int n;
  cin >> n;
  
  for (int i = 1; i <= n; i++) {
    cin >> p[i - 1] >> p[i];
  }

  matrixChainMultiplication(n);
  
  cout << m[1][n] << endl;

  return 0;
}



Compiler output:
a.cc: In function 'void matrixChainMultiplication(int)':
a.cc:14:17: error: 'INT_MAX' was not declared in this scope
   14 |       m[i][j] = INT_MAX;
      |                 ^~~~~~~
a.cc:4:1: note: 'INT_MAX' is defined in header '<climits>'; this is probably fixable by adding '#include <climits>'
    3 | #include <cstdint>
  +++ |+#include <climits>
    4 |
Language: C++

#include<iostream>
#include<algorithm>

using namespace std;

static const int N = 100;

int main() {
  int n, p[N + 1], m[N + 1][N + 1];

  cin >> n;
  for (int n = 1; i <= n; i++) {
    cin >> p[i - 1] >> p[i];
  }

  for (int i = 1; i <= n; i++) {
    m[i][i] = 0;
  }
  for (int l = 2; l <= n; l++) {
    for (i = 1; i <= n; n - l + 1; i++) {
      int j = i + l - 1;
      m[i][j] = (1 << 21);
      for(int k = i; k <= j - 1; k++) {
        m[i][j] = min(m[i, j], m[i][k] + m[k + 1][j] + p[i - 1] * p[k] * p[j])
      }
    }
  }

  cout << m[1][n] << endl;

  return 0;
}


Compiler output:
a.cc: In function 'int main()':
a.cc:12:19: error: 'i' was not declared in this scope
   12 |   for (int n = 1; i <= n; i++) {
      |                   ^
a.cc:20:10: error: 'i' was not declared in this scope
   20 |     for (i = 1; i <= n; n - l + 1; i++) {
      |          ^
a.cc:20:34: error: expected ')' before ';' token
   20 |     for (i = 1; i <= n; n - l + 1; i++) {
      |         ~                        ^
      |                                  )
a.cc:20:36: error: 'i' was not declared in this scope
   20 |     for (i = 1; i <= n; n - l + 1; i++) {
      |                                    ^
Language: C++


#include<iostream>
#include<algorithm>

using namespace std;

static const int N = 100;

int main() {
  int n, p[N + 1], m[N + 1][N + 1];

  cin >> n;
  for (int i = 1; i <= n; i++) {
    cin >> p[i - 1] >> p[i];
  }

  for (int i = 1; i <= n; i++) {
    m[i][i] = 0;
  }
  for (int l = 2; l <= n; l++) {
    for (i = 1; i <= n; n - l + 1; i++) {
      int j = i + l - 1;
      m[i][j] = (1 << 21);
      for(int k = i; k <= j - 1; k++) {
        m[i][j] = min(m[i, j], m[i][k] + m[k + 1][j] + p[i - 1] * p[k] * p[j])
      }
    }
  }

  cout << m[1][n] << endl;

  return 0;
}




Compiler output:
a.cc: In function 'int main()':
a.cc:21:10: error: 'i' was not declared in this scope
   21 |     for (i = 1; i <= n; n - l + 1; i++) {
      |          ^
a.cc:21:34: error: expected ')' before ';' token
   21 |     for (i = 1; i <= n; n - l + 1; i++) {
      |         ~                        ^
      |                                  )
a.cc:21:36: error: 'i' was not declared in this scope
   21 |     for (i = 1; i <= n; n - l + 1; i++) {
      |                                    ^
Language: C++

#include<iostream>
#include<algorithm>

using namespace std;

static const int N = 100;

int main() {
  int n, p[N + 1], m[N + 1][N + 1];

  cin >> n;
  for (int i = 1; i <= n; i++) {
    cin >> p[i - 1] >> p[i];
  }

  for (int i = 1; i <= n; i++) {
    m[i][i] = 0;
  }
  for (int l = 2; l <= n; l++) {
    for (int i = 1; i <= n - l + 1; i++) {
      int j = i + l - 1;
      m[i][j] = (1 << 21);
      for(int k = i; k <= j - 1; k++) {
        m[i][j] = min(m[i, j], m[i][k] + m[k + 1][j] + p[i - 1] * p[k] * p[j])
      }
    }
  }

  cout << m[1][n] << endl;

  return 0;
}



Compiler output:
a.cc: In function 'int main()':
a.cc:24:22: error: no matching function for call to 'min(int [101], int)'
   24 |         m[i][j] = min(m[i, j], m[i][k] + m[k + 1][j] + p[i - 1] * p[k] * p[j])
      |                   ~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In file included from /usr/include/c++/14/string:51,
                 from /usr/include/c++/14/bits/locale_classes.h:40,
                 from /usr/include/c++/14/bits/ios_base.h:41,
                 from /usr/include/c++/14/ios:44,
                 from /usr/include/c++/14/ostream:40,
                 from /usr/include/c++/14/iostream:41,
                 from a.cc:1:
/usr/include/c++/14/bits/stl_algobase.h:233:5: note: candidate: 'template<class _Tp> constexpr const _Tp& std::min(const _Tp&, const _Tp&)'
  233 |     min(const _Tp& __a, const _Tp& __b)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:233:5: note:   template argument deduction/substitution failed:
a.cc:24:22: note:   deduced conflicting types for parameter 'const _Tp' ('int [101]' and 'int')
   24 |         m[i][j] = min(m[i, j], m[i][k] + m[k + 1][j] + p[i - 1] * p[k] * p[j])
      |                   ~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algobase.h:281:5: note: candidate: 'template<class _Tp, class _Compare> constexpr const _Tp& std::min(const _Tp&, const _Tp&, _Compare)'
  281 |     min(const _Tp& __a, const _Tp& __b, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:281:5: note:   candidate expects 3 arguments, 2 provided
In file included from /usr/include/c++/14/algorithm:61,
                 from a.cc:2:
/usr/include/c++/14/bits/stl_algo.h:5686:5: note: candidate: 'template<class _Tp> constexpr _Tp std::min(initializer_list<_Tp>)'
 5686 |     min(initializer_list<_Tp> __l)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5686:5: note:   candidate expects 1 argument, 2 provided
/usr/include/c++/14/bits/stl_algo.h:5696:5: note: candidate: 'template<class _Tp, class _Compare> constexpr _Tp std::min(initializer_list<_Tp>, _Compare)'
 5696 |     min(initializer_list<_Tp> __l, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5696:5: note:   template argument deduction/substitution failed:
a.cc:24:22: note:   mismatched types 'std::initializer_list<_Tp>' and 'int*'
   24 |         m[i][j] = min(m[i, j], m[i][k] + m[k + 1][j] + p[i - 1] * p[k] * p[j])
      |                   ~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Language: C++

#include<iostream>
#include<algorithm>

using namespace std;

static const int N = 100;

int main() {
  int n, p[N + 1], m[N + 1][N + 1];

  cin >> n;
  for (int i = 1; i <= n; i++) {
    cin >> p[i - 1] >> p[i];
  }

  for (int i = 1; i <= n; i++) {
    m[i][i] = 0;
  }
  for (int l = 2; l <= n; l++) {
    for (int i = 1; i <= n - l + 1; i++) {
      int j = i + l - 1;
      m[i][j] = (1 << 21);
      for(int k = i; k <= j - 1; k++) {
        m[i][j] = min(m[i, j], m[i][k] + m[k + 1][j] + p[i - 1] * p[k] * p[j]);
      }
    }
  }

  cout << m[1][n] << endl;

  return 0;
}


Compiler output:
a.cc: In function 'int main()':
a.cc:24:22: error: no matching function for call to 'min(int [101], int)'
   24 |         m[i][j] = min(m[i, j], m[i][k] + m[k + 1][j] + p[i - 1] * p[k] * p[j]);
      |                   ~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In file included from /usr/include/c++/14/string:51,
                 from /usr/include/c++/14/bits/locale_classes.h:40,
                 from /usr/include/c++/14/bits/ios_base.h:41,
                 from /usr/include/c++/14/ios:44,
                 from /usr/include/c++/14/ostream:40,
                 from /usr/include/c++/14/iostream:41,
                 from a.cc:1:
/usr/include/c++/14/bits/stl_algobase.h:233:5: note: candidate: 'template<class _Tp> constexpr const _Tp& std::min(const _Tp&, const _Tp&)'
  233 |     min(const _Tp& __a, const _Tp& __b)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:233:5: note:   template argument deduction/substitution failed:
a.cc:24:22: note:   deduced conflicting types for parameter 'const _Tp' ('int [101]' and 'int')
   24 |         m[i][j] = min(m[i, j], m[i][k] + m[k + 1][j] + p[i - 1] * p[k] * p[j]);
      |                   ~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algobase.h:281:5: note: candidate: 'template<class _Tp, class _Compare> constexpr const _Tp& std::min(const _Tp&, const _Tp&, _Compare)'
  281 |     min(const _Tp& __a, const _Tp& __b, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:281:5: note:   candidate expects 3 arguments, 2 provided
In file included from /usr/include/c++/14/algorithm:61,
                 from a.cc:2:
/usr/include/c++/14/bits/stl_algo.h:5686:5: note: candidate: 'template<class _Tp> constexpr _Tp std::min(initializer_list<_Tp>)'
 5686 |     min(initializer_list<_Tp> __l)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5686:5: note:   candidate expects 1 argument, 2 provided
/usr/include/c++/14/bits/stl_algo.h:5696:5: note: candidate: 'template<class _Tp, class _Compare> constexpr _Tp std::min(initializer_list<_Tp>, _Compare)'
 5696 |     min(initializer_list<_Tp> __l, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5696:5: note:   template argument deduction/substitution failed:
a.cc:24:22: note:   mismatched types 'std::initializer_list<_Tp>' and 'int*'
   24 |         m[i][j] = min(m[i, j], m[i][k] + m[k + 1][j] + p[i - 1] * p[k] * p[j]);
      |                   ~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Language: C++

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

static const int N=100;

int main() {
    int n, p[N+1], m[N+1][N+1];
    cin >> n;
    for (int i=1; i<=n; i++) {
        cin >> p[i-1] >> p[i];
    }
    
    for (int i=0; i<=n; i++) m[i][i] = 0;
    for (int l=2; l<=n; l++) {
        int j = i+l-1;
        m[i][j] = (1 << 21);
        for (int k=i; k<=j-1; k++) {
            m[i][j] = min(m[i][j], m[i][k] + m[k+1][j] + p[i-1]*p[k]*p[j]);
        }
    }
    
    cout << m[1][n] << endl;
    
    return 0;
}


Compiler output:
a.cc: In function 'int main()':
a.cc:16:17: error: 'i' was not declared in this scope
   16 |         int j = i+l-1;
      |                 ^
Language: C++

#include <iostream>
using namespace std;

int N ;
int a[101][101];
int m[101][2];

int main() {
    cin >> N;
    for (int i = 1; i <= N; ++i) {
        cin >> m[i][0] >> m[i][1];
    }

    for (int j = 1; j <= N; ++j) {
        a[j][j] = 0;
    }

    for (int k = 1; k < N; ++k) {
        for (int l = 1; l <= N- k ; ++l) {
            int j = l + k;
            int mn = INT_MAX;
            for (int p = l; p <= j-1 ; ++p) {
                mn = min(mn, a[l][p] + a[p+1][j] + m[l][0] * m[p][1] * m[j][1]);
            }
            a[l][j] = mn;
        }
    }
    cout << a[1][N] << endl;

    return 0;
}



Compiler output:
a.cc: In function 'int main()':
a.cc:21:22: error: 'INT_MAX' was not declared in this scope
   21 |             int mn = INT_MAX;
      |                      ^~~~~~~
a.cc:2:1: note: 'INT_MAX' is defined in header '<climits>'; this is probably fixable by adding '#include <climits>'
    1 | #include <iostream>
  +++ |+#include <climits>
    2 | using namespace std;
Language: C++

#include <iostream>
#include <numeric_limits>
using namespace std;

int N ;
int a[101][101];
int m[101][2];

int main() {
    cin >> N;
    for (int i = 1; i <= N; ++i) {
        cin >> m[i][0] >> m[i][1];
    }

    for (int j = 1; j <= N; ++j) {
        a[j][j] = 0;
    }

    for (int k = 1; k < N; ++k) {
        for (int l = 1; l <= N- k ; ++l) {
            int j = l + k;
            int mn = INT_MAX;
            for (int p = l; p <= j-1 ; ++p) {
                mn = min(mn, a[l][p] + a[p+1][j] + m[l][0] * m[p][1] * m[j][1]);
            }
            a[l][j] = mn;
        }
    }
    cout << a[1][N] << endl;

    return 0;
}



Compiler output:
a.cc:2:10: fatal error: numeric_limits: No such file or directory
    2 | #include <numeric_limits>
      |          ^~~~~~~~~~~~~~~~
compilation terminated.
Language: C++

#include "stdafx.h"
#include<iostream>
#include<vector>
using namespace std;

vector<vector<int> > cost,best;
vector<int> A;

void compute(int s,int e){
	int minc = 0;
	int mink = -1;
	for(int k=s+1;k<=e;++k){
		if (cost[s][k-1] < 0){
			compute(s,k-1);
		}
		if (cost[k][e] < 0) {
			compute(k,e);
		}
		int c = cost[s][k-1] + A[s]*A[k]*A[e+1] + cost[k][e];
		if (mink < 0 || c < minc) {
			minc = c;
			mink = k;
		}
	}
	cost[s][e] = minc;
	best[s][e] = mink;
}

int main(){
	int n;
	cin >> n;
	A.resize(n+1);
	for(int i=0;i<n;++i) {
		int r,c;
		cin >> r >> c;
		if (i==0){
			A[0] = r;
		}
		if (A[i] != r){ cout << "error";exit(0);}
		A[i+1] = c;
	}
	cost.resize(n);
	best.resize(n);
	for(int i=0;i<n;++i){
		cost[i].resize(n);
		best[i].resize(n);
		for(unsigned j=0;j<cost[i].size();++j){
			cost[i][j] = -1;
			best[i][j] = -1;
		}
		cost[i][i]=0;
		best[i][i]=i;
	}
	compute(0,n-1);
	cout << cost[0][n-1] << std::endl;
}

Compiler output:
a.cc:1:10: fatal error: stdafx.h: No such file or directory
    1 | #include "stdafx.h"
      |          ^~~~~~~~~~
compilation terminated.