Leetcode: Unique Paths

easy one;

A robot is located at the top-left corner of a m x ngrid (marked ‘Start’ in the diagram below).

The robot can only move either down or right at any point in time. The robot is trying to reach the bottom-right corner of the grid (marked ‘Finish’ in the diagram below).

How many possible unique paths are there?

class Solution {
public:
    int uniquePaths(int m, int n) {
        if (m==0 || n==0) return 0;

        int all[m][n];
        for (int i=0;i<n;i++) all[0][i] = 1;
        for (int i=1;i<m;i++) all[i][0] = 1;

        for (int i=1;i<m;i++){
            for (int j=1;j<n;j++){
                all[i][j] = all[i-1][j] + all[i][j-1];
            }
        }

        return all[m-1][n-1];

    }
};

python
class Solution:
    # @return an integer
    def uniquePaths(self, m, n):
        if m==0 or n==0:
            return 0

        all = [[0]*n for i in range(m)]
        for i in range(n):
            all[0][i] = 1
        for i in range(1,m):
            all[i][0] = 1

        for i in range(1,m):
            for j in range(1,n):
                all[i][j] = all[i-1][j] + all[i][j-1]

        return all[m-1][n-1]

---

The space complexity can be optimized to O( min(m,n) ), instead of O(mn)

class Solution {
public:
    int uniquePaths(int m, int n) {
        if(m<=0 || n<=0) return 0;

        int k = min( m, n );
        int s,l;
        if(k==m){
            s = m;
            l = n;
        }else{
            s = n;
            l = m;
        }

        //int array[s] = {1};
        int* a = new int[s];
        for(int i=0; i<s; ++i){
            cout << "init: " << i <<endl;
            a[i] = 1;
        }
        for(int temp=1; temp<l; ++temp){
            for(int ind=1; ind<s; ++ind){
                a[ind] = a[ind] + a[ind-1];
            }
        }

        return a[s-1];
    }
};

use std::vector

vector<int> a(s,1);
        cout << "size of a " << a.size() << endl; 
        for(int temp=1; temp<l; ++temp){
            for(int ind=1; ind<s; ++ind){
                a[ind] = a[ind] + a[ind-1];
            }
        }

class Solution(object):
    def uniquePaths(self, m, n):
        """
        :type m: int
        :type n: int
        :rtype: int
        """

        if m<=0 or n<=0:
            return 0

        k = min(m, n)
        if m==k:
            short, long = m, n
        else:
            short, long = n, m

        array = [1]*short
        for i in range(1, long):
            for j in range(1,short):
                array[j] = array[j-1] + array[j]

        return array[-1]

---

Take home message

1. for variable length array, should write in this way

int* a = new int[ array_size ]
for(int ind=1; ind<array_size; ++i){
    a[ind] = some_number;
}

not

int a[ array_size ] = {1}  //incorrect 

It can also be written in another way ( use vector ):

vector<int> first;                                // empty vector of ints
vector<int> second (4,100);                       // four ints with value 100
vector<int> third (second.begin(),second.end());  // iterating through second
vector<int> fourth (third);                       // a copy of third

// the iterator constructor can also be used to construct from arrays:
int myints[] = {16,2,77,29};
vector<int> fifth (myints, myints + sizeof(myints) / sizeof(int) );