Language: C++

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

const int V = 205;

bool bfs(ll rGraph[V][V], int s, int t, int parent[]) 
{ 
    // Create a visited array and mark all vertices as not visited 
    bool visited[V]; 
    memset(visited, 0, sizeof(visited)); 
  
    // Create a queue, enqueue source vertex and mark source vertex 
    // as visited 
    queue <int> q; 
    q.push(s); 
    visited[s] = true; 
    parent[s] = -1; 
  
    // Standard BFS Loop 
    while (!q.empty()) 
    { 
        int u = q.front(); 
        q.pop(); 
  
        for (int v=0; v<V; v++) 
        { 
            if (visited[v]==false && rGraph[u][v] > 0) 
            { 
                q.push(v); 
                parent[v] = u; 
                visited[v] = true; 
            } 
        } 
    } 
  
    // If we reached sink in BFS starting from source, then return 
    // true, else false 
    return (visited[t] == true); 
} 
  
// Returns the maximum flow from s to t in the given graph 
ll fordFulkerson(ll graph[V][V], int s, int t) 
{ 
    int u, v; 
  
    // Create a residual graph and fill the residual graph with 
    // given capacities in the original graph as residual capacities 
    // in residual graph 
    ll rGraph[V][V]; // Residual graph where rGraph[i][j] indicates  
                     // residual capacity of edge from i to j (if there 
                     // is an edge. If rGraph[i][j] is 0, then there is not)   
    for (u = 0; u < V; u++) 
        for (v = 0; v < V; v++) 
             rGraph[u][v] = graph[u][v]; 
  
    int parent[V];  // This array is filled by BFS and to store path 
  
    ll max_flow = 0;  // There is no flow initially 
  
    // Augment the flow while tere is path from source to sink 
    while (bfs(rGraph, s, t, parent)) 
    { 
        // Find minimum residual capacity of the edges along the 
        // path filled by BFS. Or we can say find the maximum flow 
        // through the path found. 
        ll path_flow = 1e18; 
        for (v=t; v!=s; v=parent[v]) 
        { 
            u = parent[v]; 
            path_flow = min(path_flow, rGraph[u][v]); 
        } 
  
        // update residual capacities of the edges and reverse edges 
        // along the path 
        for (v=t; v != s; v=parent[v]) 
        { 
            u = parent[v]; 
            rGraph[u][v] -= path_flow; 
            rGraph[v][u] += path_flow; 
        } 
  
        // Add path flow to overall flow 
        max_flow += path_flow; 
    } 
  
    // Return the overall flow 
    return max_flow; 
} 

int n;
ll a[105],graph[105][105],ans,MaxFlow;
int main(){
	ios_base::sync_with_stdio(NULL);
	cin.tie(0);cout.tie(0);
	cin>>n;
	ans = 0;
	memset(graph,0,sizeof graph);
	for(int i=1;i<=n;i++){
		cin>>a[i];
		if(a[i]<=0){
			graph[0][i] = -a[i];
		}
		else{
			graph[i][n+1] = a[i];
			ans += a[i];
		}
		for(int j=1;j<i;j++){
			if(i%j == 0){
				graph[j][i] = 1e17;
				//cout<<i<<" "<<j<<endl;
			}
		}
	}
	MaxFlow = fordFulkerson(graph,0,n+1);
	cout << max(0ll,ans - MaxFlow) << endl;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:115:33: error: cannot convert 'long long int (*)[105]' to 'long long int (*)[205]'
  115 |         MaxFlow = fordFulkerson(graph,0,n+1);
      |                                 ^~~~~
      |                                 |
      |                                 long long int (*)[105]
a.cc:43:21: note:   initializing argument 1 of 'long long int fordFulkerson(long long int (*)[205], int, int)'
   43 | ll fordFulkerson(ll graph[V][V], int s, int t)
      |                     ^