int main()
{
Solution s;
vector<vector<int>> vec;
cout<<s.minPathSum(vec)<<endl;
vec={{}};
cout<<s.minPathSum(vec)<<endl;
vec={{1,1,1}};
cout<<s.minPathSum(vec)<<endl;
vec={{1,2,3},{1,2,3}};
cout<<s.minPathSum(vec)<<endl;
vec={{1,2,3},{1,1,1}};
cout<<s.minPathSum(vec)<<endl;
}
int main(){
Solution s;
vector<vector<int>> grid={{1,2,0},{0,4,0},{4,0,5}};
cout<<s.minPathSum(grid)<<endl;
return 0;
}
int
main()
{
vector<vector<int> > grid = {{1,1,1}, {2,1,3},{0,0,0}};
Solution solution;
cout << solution.minPathSum(grid) << endl;
}
int main() {
vector<int> v1{1, 2}, v2{1, 1};
vector<vector<int> > test{v1, v2};
Solution a;
std::cout << a.minPathSum(test) << std::endl;
}
int main()
{
vector<vector<int> > grid = {
{7,1,3,5,8,9,9,2,1,9,0,8,3,1,6,6,9,5},
{9,5,9,4,0,4,8,8,9,5,7,3,6,6,6,9,1,6},
{8,2,9,1,3,1,9,7,2,5,3,1,2,4,8,2,8,8},
{6,7,9,8,4,8,3,0,4,0,9,6,6,0,0,5,1,4},
{7,1,3,1,8,8,3,1,2,1,5,0,2,1,9,1,1,4},
{9,5,4,3,5,6,1,3,6,4,9,7,0,8,0,3,9,9},
{1,4,2,5,8,7,7,0,0,7,1,2,1,2,7,7,7,4},
{3,9,7,9,5,8,9,5,6,9,8,8,0,1,4,2,8,2},
{1,5,2,2,2,5,6,3,9,3,1,7,9,6,8,6,8,3},
{5,7,8,3,8,8,3,9,9,8,1,9,2,5,4,7,7,7},
{2,3,2,4,8,5,1,7,2,9,5,2,4,2,9,2,8,7},
{0,1,6,1,1,0,0,6,5,4,3,4,3,7,9,6,1,9}
};
Solution sol;
int ret1 = sol.minPathSum(grid);
int ret2 = sol.minPathSum2(grid);
int ret3 = sol.minPathSum3(grid);
cout << ret1 << endl;
cout << ret2 << endl;
cout << ret3 << endl;
}
int main(int argc, char* argv[]){
vector<int> v(1);
v[0] = 0;
vector< vector<int> > vv;
vv.push_back(v);
Solution sol;
sol.minPathSum(vv);
}
int main(int argc, const char * argv[])
{
vector<vector<int>> grid = {{1,2}, {1,1}};
Solution s;
cout << s.minPathSum(grid) << endl;
return 0;
}
int main(int argc, char** argv){
Solution s;
std::vector<int> v1 = {3};
std::vector<vector<int>> v = {v1};
cout << s.minPathSum(v);
}
int main(){
Solution so;
string line;
vector<vector<int>> grid;
while(getline(cin,line)){
grid.push_back(string2vector<int>(line));
}
cout<<so.minPathSum(grid)<<endl;
}
int main() {
Solution s;
vector<vector<int>> mat{
{1,3,1},
{1,5,1},
{4,2,1}
};
cout << s.minPathSum(mat) << endl;
return 0; }
int main(){
vector<vector<int> > grid {
{1, 3, 1},
{1, 5, 1},
{4, 2, 1}
};
Solution s;
cout << s.minPathSum(grid) << endl;
return 0;
}
int main() {
Solution s;
vector< vector<int> > grid(2,vector<int>(2,0));
grid[0][0] = 1;
grid[0][1] = 2;
grid[1][0] = 1;
grid[1][1] = 1;
int m = s.minPathSum(grid);
return 0;
}
int main()
{
vector<int> line1{1,2};
vector<int> line2{1,1};
vector<vector<int>> grid{line1,line2};
Solution slt;
cout<<slt.minPathSum(grid)<<endl;
while(1);
}
TEST(minimum_path_sum, case1)
{
std::vector<std::vector<int> > v =
{
{1, 2},
{5, 6},
{1, 1}
};
Solution s;
EXPECT_EQ(s.minPathSum(v), 8);
}
int main()
{
vector<vector<int>> grid(2);
grid[0].push_back(1);
grid[0].push_back(2);
grid[0].push_back(5);
grid[1].push_back(3);
grid[1].push_back(2);
grid[1].push_back(1);
Solution s;
s.minPathSum(grid);
return 0;
}
int LEET_MINIMUM_PATH_SUM()
{
Solution s;
vector<vector<int>> grid;
vector<int> row1;
vector<int> row2;
row1.push_back(1); row1.push_back(2);
row2.push_back(3); row2.push_back(4);
grid.push_back(row1);
grid.push_back(row2);
cout << s.minPathSum(grid) << endl;
return 0;
}
int main(int argc, char **argv)
{
Solution solution;
int n, m;
while (scanf("%d%d", &n, &m) != EOF) {
vector<vector<int>> v(n, vector<int>(m, 0));
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
cin >> v[i][j];
}
cout << solution.minPathSum(v) << endl;
}
return 0;
}
int main(){
int a[2][3] = {{1, 2, 5}, {3, 2, 1}};
vector<vector<int> > grid;
for(int i = 0; i < 2; i++){
vector<int> row = vector<int>(a[i], a[i] + 3);
grid.push_back(row);
}
Solution solution;
int res = solution.minPathSum(grid);
cout << res << endl;
return 0;
}
int main()
{
vector<int> a, b, c, d;
a.push_back(2), a.push_back(2);
b.push_back(3), b.push_back(4);
c.push_back(6), c.push_back(5);
d.push_back(4), d.push_back(1);
vector<vector<int> > res;
res.push_back(a); res.push_back(b); res.push_back(c); res.push_back(d);
printf("%d\n", g.minPathSum(res));
system("pause");
return 0;
}
int main() {
Solution demo = Solution();
vector<vector<int>> nums = {
{1, 2, 3},
{4, 5, 6},
};
int rel;
rel = demo.minPathSum(nums);
cout<<"rel:"<<rel<<endl;
}
int main(){
Solution s;
vector<int> a1;
a1.push_back(1);
a1.push_back(2);
vector<int> a2;
a2.push_back(1);
a2.push_back(1);
vector<vector<int> >grid;
grid.push_back(a1);
grid.push_back(a2);
cout<<s.minPathSum(grid)<<endl;
}
int main(int argc, char** argv)
{
const int rownum = 3;
const int colnum = 3;
int arrys[rownum][colnum] = { {1,3,1}, {1,5,1}, {4,2,1} };
vector<vector<int> > grid(rownum);
for (int i=0; i<rownum; ++i)
{
grid[i] = vector<int>(arrys[i], arrys[i]+colnum);
}
Solution solver;
int result = solver.minPathSum(grid);
return 0;
}
int main()
{
Solution s;
vector<vector<int> > v = {
{1,1,1},
{2,2,2},
{3,3,3}
};
v = {
{1,2},
{1,1}
};
auto r = s.minPathSum(v);
cout << r << endl;
}
int main() {
vector<vector<int> > grid;
// test case 1
//int r0[] = {1, 2};
int r0[] = {1};
//int r1[] = {1, 1};
vector<int> v0(r0, r0+sizeof(r0)/sizeof(r0[0]));
//vector<int> v1(r1, r1+sizeof(r1)/sizeof(r1[0]));
grid.push_back(v0);
//grid.push_back(v1);
Solution sol;
cout << sol.minPathSum(grid) << endl;
return 0;
}
void test()
{
Solution s;
vector<vector<int>> nums;
vector<int> sub_nums;
sub_nums.resize(2);
sub_nums[0] = 1;
sub_nums[1] = 2;
nums.push_back(sub_nums);
sub_nums[0] = 1;
sub_nums[1] = 1;
nums.push_back(sub_nums);
cout << s.minPathSum(nums) << endl;
}
int main()
{
Solution s;
vector<vector<int>> grid;
vector<int> v;
int m = 3, n = 1;
int k = 1;
for (int i = 0; i < m; i++){
for (int j = 0; j < n; j++)
v.push_back(k++);
grid.push_back(v);
v.clear();
}
// grid[2][0] = 0;
cout << s.minPathSum(grid) << endl;
system("pause");
}
int main() {
freopen("test.txt", "r", stdin);
vector<int> v1;
v1.push_back(1);
v1.push_back(2);
vector<int> v2;
v2.push_back(3);
v2.push_back(4);
vector<vector<int> > v;
v.push_back(v1);
v.push_back(v2);
Solution s;
cout << s.minPathSum(v) << endl;
return 0;
}
void main(){
Solution test;
vector<int> fi;
fi.push_back(1);
fi.push_back(2);
fi.push_back(5);
vector<int> se;
se.push_back(3);
se.push_back(2);
se.push_back(1);
vector<vector<int>> testGrid;
testGrid.push_back(fi);
testGrid.push_back(se);
int ret;
ret = test.minPathSum(testGrid);
}
void test() {
vector<vector<int>> grid;
vector<int> row0, row1, row2;
row0.push_back(5);
row0.push_back(3);
row0.push_back(7);
row1.push_back(2);
row1.push_back(7);
row1.push_back(1);
row2.push_back(8);
row2.push_back(5);
row2.push_back(3);
grid.push_back(row0);
grid.push_back(row1);
grid.push_back(row2);
Solution so;
cout << "N064MinPathSum:\t\t" << so.minPathSum(grid) << endl;
}
TEST(minPathSums_Test, Positive01){
Solution s;
const int rows = 3, cols = 3;
int arr[][cols] = {
{1, 2, 2},
{3, 1, 0},
{2, 3, 1}};
vector<vector<int> > grid;
for(int i = 0; i < rows; i++){
grid.push_back(vector<int>(arr[i], arr[i] + cols));
}
int expected = 5;
EXPECT_EQ(expected, s.minPathSum(grid));
grid.clear();
}
