Stone problem

Problem: A playground is surrounded by n piles of stones. Each time the two adjacent piles of stones are combined, and finally merged into one pile, each time it is moved, it takes effort. The price of the strength is the number of the two piles of stones. The sum, ask: How to minimize the total effort. (Not greedy)

Method: dynamic programming 

#include<iostream>
#include<vector>
#include<algorithm>
#include<cmath>
using namespace std;
vector<vector<int>>m;
int digui(int i, int j, vector<int>& arr)
{
	if (m[i][j] != 0)
		return m[i][j];

	if (i == j)
	{
		m[i][j] = arr[i];
		return arr[i];
	}

	if (i == j - 1)
	{
		m[i][j] = arr[i] + arr[j];
		return arr[i] + arr[j];
	}

	int temp = INT_MAX;
	for (int k = i; k < j; k++)
		temp = min(digui(i, k, arr) + digui(k + 1, j, arr), temp);

	m[i][j] = temp;
	return m[i][j];
}
int dp_1(int n,vector<int>&arr)
{
	vector<vector<int>>dp(n + 1, vector<int>(n + 1, 0));
	for (int i = 1; i <=n; i++)
	{
		dp[i][i] = arr[i];
		if(i<n)
			dp[i][i + 1] = arr[i] + arr[i + 1];
	}
	for (int i = n-1; i>=1; i--)
	{
		for (int j = i+1; j <= n; j++)
		{
			int temp = INT_MAX;
			for (int k = i; k < j; k++)
				temp = min(temp, dp[i][k] + dp[k + 1][j]);
			dp[i][j] = temp;

		}
	}
	return dp[1][n];
}
int main()
{
	int n;
	while (cin >> n)
	{
		//m = vector<vector<int>>(n + 1, vector<int>(n + 1, 0));
		vector<int>v;
		v.push_back(0);
		int num = 0;
		for (int i = 1; i <= n; i++)
		{
			cin >> num;
			v.push_back(num);
		}
		//cout << digui(1, n, v);
		cout << dp_1(n, v);
	}


	return 0;
}
/*
7
1 5 7 2 6 9 4
*/